static ngx_int_t ngx_statsd_init_endpoint(ngx_conf_t *cf, ngx_udp_endpoint_t *endpoint) { ngx_pool_cleanup_t *cln; ngx_udp_connection_t *uc; ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0, "statsd: initting endpoint"); cln = ngx_pool_cleanup_add(cf->pool, 0); if(cln == NULL) { return NGX_ERROR; } cln->handler = ngx_statsd_updater_cleanup; cln->data = endpoint; uc = ngx_calloc(sizeof(ngx_udp_connection_t), cf->log); if (uc == NULL) { return NGX_ERROR; } endpoint->udp_connection = uc; uc->sockaddr = endpoint->peer_addr.sockaddr; uc->socklen = endpoint->peer_addr.socklen; uc->server = endpoint->peer_addr.name; endpoint->log = &cf->cycle->new_log; return NGX_OK; }
static ngx_int_t ngx_http_lua_ngx_ctx_add_cleanup(ngx_http_request_t *r, int ref) { lua_State *L; ngx_pool_cleanup_t *cln; ngx_http_lua_ctx_t *ctx; ngx_http_lua_ngx_ctx_cleanup_data_t *data; ctx = ngx_http_get_module_ctx(r, ngx_http_lua_module); L = ngx_http_lua_get_lua_vm(r, ctx); cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_http_lua_ngx_ctx_cleanup_data_t)); if (cln == NULL) { return NGX_ERROR; } cln->handler = ngx_http_lua_ngx_ctx_cleanup; data = cln->data; data->vm = L; data->ref = ref; return NGX_OK; }
static ngx_int_t ngx_http_poller_set_ssl(ngx_conf_t *cf, ngx_http_poller_t *poller) { ngx_pool_cleanup_t *cln; ngx_uint_t protocols; poller->upstream.ssl = ngx_pcalloc(cf->pool, sizeof(ngx_ssl_t)); if (poller->upstream.ssl == NULL) { return NGX_ERROR; } poller->upstream.ssl->log = cf->log; protocols = NGX_SSL_SSLv2 | NGX_SSL_SSLv3 | NGX_SSL_TLSv1 | NGX_SSL_TLSv1_1 | NGX_SSL_TLSv1_2; if (ngx_ssl_create(poller->upstream.ssl, protocols, NULL) != NGX_OK) { return NGX_ERROR; } cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { return NGX_ERROR; } cln->handler = ngx_ssl_cleanup_ctx; cln->data = poller->upstream.ssl; return NGX_OK; }
ngx_int_t ngx_http_file_cache_create(ngx_http_request_t *r) { ngx_http_cache_t *c; ngx_pool_cleanup_t *cln; ngx_http_file_cache_t *cache; c = r->cache; cache = c->file_cache; cln = ngx_pool_cleanup_add(r->pool, 0); if (cln == NULL) { return NGX_ERROR; } cln->handler = ngx_http_file_cache_cleanup; cln->data = c; if (ngx_http_file_cache_exists(cache, c) == NGX_ERROR) { return NGX_ERROR; } if (ngx_http_file_cache_name(r, cache->path) != NGX_OK) { return NGX_ERROR; } return NGX_OK; }
ngx_open_file_cache_t * ngx_open_file_cache_init(ngx_pool_t *pool, ngx_uint_t max, time_t inactive) { ngx_pool_cleanup_t *cln; ngx_open_file_cache_t *cache; cache = ngx_palloc(pool, sizeof(ngx_open_file_cache_t)); if (cache == NULL) { return NULL; } ngx_rbtree_init(&cache->rbtree, &cache->sentinel, ngx_open_file_cache_rbtree_insert_value); ngx_queue_init(&cache->expire_queue); cache->current = 0; cache->max = max; cache->inactive = inactive; cln = ngx_pool_cleanup_add(pool, 0); if (cln == NULL) { return NULL; } cln->handler = ngx_open_file_cache_cleanup; cln->data = cache; return cache; }
static ngx_int_t ngx_fluentd_init_endpoint(ngx_conf_t *cf, ngx_udp_endpoint_t *endpoint) { ngx_pool_cleanup_t *cln; ngx_udp_connection_t *uc; cln = ngx_pool_cleanup_add(cf->pool, 0); if(cln == NULL) { return NGX_ERROR; } cln->handler = ngx_fluentd_cleanup; cln->data = endpoint; uc = ngx_calloc(sizeof(ngx_udp_connection_t), cf->log); if (uc == NULL) { return NGX_ERROR; } endpoint->udp_connection = uc; uc->sockaddr = endpoint->peer_addr.sockaddr; uc->socklen = endpoint->peer_addr.socklen; uc->server = endpoint->peer_addr.name; #if defined nginx_version && ( nginx_version >= 7054 && nginx_version < 8055 ) uc->log = cf->cycle->new_log; #else uc->log = cf->cycle->new_log; #if defined nginx_version && nginx_version >= 8032 uc->log.handler = NULL; uc->log.data = NULL; uc->log.action = "logging"; #endif #endif return NGX_OK; }
static char * ngx_http_xrlt(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) { ngx_http_xrlt_loc_conf_t *xlcf = conf; ngx_http_core_loc_conf_t *clcf; ngx_str_t *value; ngx_pool_cleanup_t *cln; xmlDocPtr doc; xrltRequestsheetPtr sheet; value = cf->args->elts; if (xlcf->sheet != NULL) { ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "Duplicate xrlt instruction"); return NGX_CONF_ERROR; } if (ngx_conf_full_name(cf->cycle, &value[1], 0) != NGX_OK) { return NGX_CONF_ERROR; } cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { return NGX_CONF_ERROR; } doc = xmlParseFile((const char *)value[1].data); if (doc == NULL) { ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "xmlParseFile(\"%s\") failed", value[1].data); return NGX_CONF_ERROR; } sheet = xrltRequestsheetCreate(doc); if (sheet == NULL) { xmlFreeDoc(doc); ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "xrltRequestsheetCreate(\"%s\") failed", value[1].data); return NGX_CONF_ERROR; } xlcf->sheet = sheet; cln->handler = ngx_http_xrlt_cleanup_requestsheet; cln->data = sheet; clcf = ngx_http_conf_get_module_loc_conf(cf, ngx_http_core_module); if (clcf == NULL) { return NGX_CONF_ERROR; } clcf->handler = ngx_http_xrlt_handler; return NGX_CONF_OK; }
static ngx_int_t ngx_http_js_init_vm(ngx_http_request_t *r) { void **ext; ngx_http_js_ctx_t *ctx; ngx_pool_cleanup_t *cln; nxt_mem_cache_pool_t *mcp; ngx_http_js_loc_conf_t *jlcf; jlcf = ngx_http_get_module_loc_conf(r, ngx_http_js_module); if (jlcf->vm == NULL) { return NGX_DECLINED; } ctx = ngx_http_get_module_ctx(r, ngx_http_js_module); if (ctx == NULL) { ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_js_ctx_t)); if (ctx == NULL) { return NGX_ERROR; } ngx_http_set_ctx(r, ctx, ngx_http_js_module); } if (ctx->vm) { return NGX_OK; } mcp = ngx_http_js_create_mem_cache_pool(); if (mcp == NULL) { return NGX_ERROR; } cln = ngx_pool_cleanup_add(r->pool, 0); if (cln == NULL) { return NGX_ERROR; } cln->handler = ngx_http_js_cleanup_mem_cache_pool; cln->data = mcp; ext = ngx_palloc(r->pool, sizeof(void *)); if (ext == NULL) { return NGX_ERROR; } *ext = r; ctx->vm = njs_vm_clone(jlcf->vm, mcp, ext); if (ctx->vm == NULL) { return NGX_ERROR; } ctx->args = &jlcf->args[0]; return NGX_OK; }
//allocates message and responds to subscriber ngx_int_t ngx_http_push_alloc_for_subscriber_response(ngx_pool_t *pool, ngx_int_t shared, ngx_http_push_msg_t *msg, ngx_chain_t **chain, ngx_str_t **content_type, ngx_str_t **etag, time_t *last_modified) { if(etag != NULL && (*etag = ngx_http_push_store->message_etag(msg, pool))==NULL) { //oh, nevermind... ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate memory for Etag header"); return NGX_ERROR; } if(content_type != NULL && (*content_type= ngx_http_push_store->message_content_type(msg, pool))==NULL) { //oh, nevermind... ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate memory for Content Type header"); if(pool == NULL) { ngx_free(*etag); } else { ngx_pfree(pool, *etag); } return NGX_ERROR; } //preallocate output chain. yes, same one for every waiting subscriber if(chain != NULL && (*chain = ngx_http_push_create_output_chain(msg->buf, pool, ngx_cycle->log))==NULL) { ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate buffer chain while responding to subscriber request"); if(pool == NULL) { ngx_free(*etag); ngx_free(*content_type); } else { ngx_pfree(pool, *etag); ngx_pfree(pool, *content_type); } return NGX_ERROR; } if(last_modified != NULL) { *last_modified = msg->message_time; } ngx_http_push_store->unlock(); if(pool!=NULL && shared == 0 && ((*chain)->buf->file!=NULL)) { //close file when we're done with it ngx_pool_cleanup_t *cln; ngx_pool_cleanup_file_t *clnf; if((cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_cleanup_file_t)))==NULL) { ngx_log_error(NGX_LOG_ERR, ngx_cycle->log, 0, "push module: unable to allocate buffer chain pool cleanup while responding to subscriber request"); ngx_pfree(pool, *etag); ngx_pfree(pool, *content_type); ngx_pfree(pool, *chain); return NGX_ERROR; } cln->handler = ngx_pool_cleanup_file; clnf = cln->data; clnf->fd = (*chain)->buf->file->fd; clnf->name = (*chain)->buf->file->name.data; clnf->log = ngx_cycle->log; } return NGX_OK; }
static ngx_int_t ngx_http_js_variable(ngx_http_request_t *r, ngx_http_variable_value_t *v, uintptr_t data) { njs_vm_t *vm = (njs_vm_t *) data; nxt_str_t value; njs_vm_t *nvm; ngx_pool_cleanup_t *cln; nxt_mem_cache_pool_t *mcp; ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "http js variable handler"); mcp = ngx_http_js_create_mem_cache_pool(); if (mcp == NULL) { return NGX_ERROR; } cln = ngx_pool_cleanup_add(r->pool, 0); if (cln == NULL) { return NGX_ERROR; } cln->handler = ngx_http_js_cleanup_mem_cache_pool; cln->data = mcp; nvm = njs_vm_clone(vm, mcp, (void **) &r); if (nvm == NULL) { return NGX_ERROR; } if (njs_vm_run(nvm) == NJS_OK) { if (njs_vm_retval(nvm, &value) != NJS_OK) { return NGX_ERROR; } v->len = value.len; v->valid = 1; v->no_cacheable = 0; v->not_found = 0; v->data = value.data; } else { njs_vm_exception(nvm, &value); ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "js exception: %*s", value.len, value.data); v->not_found = 1; } ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "http js variable done"); return NGX_OK; }
static ngx_int_t ngx_http_gettoken_init_connections(ngx_cycle_t *cycle) { ngx_http_gettoken_connection_t *c; ngx_http_gettoken_main_conf_t *halmcf; ngx_http_gettoken_server_t *server; ngx_pool_cleanup_t *cleanup; ngx_connection_t *dummy_conn; ngx_uint_t i, j; //int option; halmcf = ngx_http_cycle_get_module_main_conf(cycle, ngx_http_gettoken_module); if (halmcf == NULL || halmcf->servers == NULL) { return NGX_OK; } for (i = 0; i < halmcf->servers->nelts; i++) { server = &((ngx_http_gettoken_server_t *) halmcf->servers->elts)[i]; ngx_queue_init(&server->free_connections); ngx_queue_init(&server->waiting_requests); if (server->connections <= 1) { server->connections = 1; } for (j = 0; j < server->connections; j++) { c = ngx_pcalloc(cycle->pool, sizeof(ngx_http_gettoken_connection_t)); cleanup = ngx_pool_cleanup_add(cycle->pool, 0); dummy_conn = ngx_pcalloc(cycle->pool, sizeof(ngx_connection_t)); if (c == NULL || cleanup == NULL || dummy_conn == NULL) { return NGX_ERROR; } cleanup->handler = &ngx_http_gettoken_connection_cleanup; cleanup->data = c; c->log = cycle->log; c->server = server; c->state = STATE_DISCONNECTED; /* Various debug logging around timer management assume that the field 'data' in ngx_event_t is a pointer to ngx_connection_t, therefore we have a dummy such structure around so that it does not crash etc. */ dummy_conn->data = c; c->reconnect_event.log = c->log; c->reconnect_event.data = dummy_conn; c->reconnect_event.handler = ngx_http_gettoken_reconnect_handler; ngx_http_gettoken_connect(c); } } return NGX_OK; }
static ngx_int_t ngx_http_xslt_send(ngx_http_request_t *r, ngx_http_xslt_filter_ctx_t *ctx, ngx_buf_t *b) { ngx_int_t rc; ngx_chain_t out; ngx_pool_cleanup_t *cln; ngx_http_xslt_filter_loc_conf_t *conf; ctx->done = 1; if (b == NULL) { return ngx_http_filter_finalize_request(r, &ngx_http_xslt_filter_module, NGX_HTTP_INTERNAL_SERVER_ERROR); } cln = ngx_pool_cleanup_add(r->pool, 0); if (cln == NULL) { ngx_free(b->pos); return ngx_http_filter_finalize_request(r, &ngx_http_xslt_filter_module, NGX_HTTP_INTERNAL_SERVER_ERROR); } if (r == r->main) { r->headers_out.content_length_n = b->last - b->pos; if (r->headers_out.content_length) { r->headers_out.content_length->hash = 0; r->headers_out.content_length = NULL; } ngx_http_clear_etag(r); conf = ngx_http_get_module_loc_conf(r, ngx_http_xslt_filter_module); if (!conf->last_modified) { ngx_http_clear_last_modified(r); } } rc = ngx_http_next_header_filter(r); if (rc == NGX_ERROR || rc > NGX_OK || r->header_only) { ngx_free(b->pos); return rc; } cln->handler = ngx_http_xslt_cleanup; cln->data = b->pos; out.buf = b; out.next = NULL; return ngx_http_next_body_filter(r, &out); }
static ngx_int_t ngx_stream_lua_init(ngx_conf_t *cf) { ngx_int_t rc; volatile ngx_cycle_t *saved_cycle; ngx_stream_lua_main_conf_t *lmcf; #ifndef NGX_LUA_NO_FFI_API ngx_pool_cleanup_t *cln; #endif lmcf = ngx_stream_conf_get_module_main_conf(cf, ngx_stream_lua_module); #ifndef NGX_LUA_NO_FFI_API /* add the cleanup of semaphores after the lua_close */ cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { return NGX_ERROR; } cln->data = lmcf; cln->handler = ngx_stream_lua_cleanup_semaphore_mm; #endif if (lmcf->lua == NULL) { dd("initializing lua vm"); lmcf->lua = ngx_stream_lua_init_vm(NULL, cf->cycle, cf->pool, lmcf, cf->log, NULL); if (lmcf->lua == NULL) { ngx_conf_log_error(NGX_LOG_ERR, cf, 0, "failed to initialize Lua VM"); return NGX_ERROR; } if (!lmcf->requires_shm && lmcf->init_handler) { saved_cycle = ngx_cycle; ngx_cycle = cf->cycle; rc = lmcf->init_handler(cf->log, lmcf, lmcf->lua); ngx_cycle = saved_cycle; if (rc != NGX_OK) { /* an error happened */ return NGX_ERROR; } } dd("Lua VM initialized!"); } return NGX_OK; }
static char * ngx_http_ip2location_init_main_conf(ngx_conf_t *cf, void *data) { ngx_http_ip2location_main_conf_t *imcf = data; ngx_pool_cleanup_t *cln; if (imcf->access_type == NGX_CONF_UNSET) { imcf->access_type = IP2LOCATION_SHARED_MEMORY; } if (imcf->enabled) { if (imcf->filename.len == 0) { ngx_log_error(NGX_LOG_EMERG, cf->log, 0, "ip2location enabled with no database specified in %s:%ui", imcf->enable_file, imcf->enable_line); return NGX_CONF_ERROR; } // open database imcf->database = IP2Location_open((char *)imcf->filename.data); if (imcf->database == NULL) { ngx_log_error(NGX_LOG_EMERG, cf->log, 0, "can not open database file \"%V\" in %s:%ui", &imcf->filename, imcf->database_file, imcf->database_line); return NGX_CONF_ERROR; } if (IP2Location_open_mem(imcf->database, imcf->access_type) == -1) { IP2Location_close(imcf->database); ngx_log_error(NGX_LOG_EMERG, cf->log, 0, "can not load database file %V using \"%V\" access type in %s:%ui", &imcf->filename, &imcf->access_type_name, imcf->database_file, imcf->database_line); return NGX_CONF_ERROR; } cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { return NGX_CONF_ERROR; } cln->data = imcf->database; cln->handler = ngx_http_ip2location_cleanup; } return NGX_CONF_OK; }
static char * ngx_http_lua_init_vm(ngx_conf_t *cf, ngx_http_lua_main_conf_t *lmcf) { ngx_pool_cleanup_t *cln; ngx_http_lua_preload_hook_t *hook; lua_State *L; ngx_uint_t i; ngx_http_lua_content_length_hash = ngx_http_lua_hash_literal("content-length"); ngx_http_lua_location_hash = ngx_http_lua_hash_literal("location"); /* add new cleanup handler to config mem pool */ cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { return NGX_CONF_ERROR; } /* create new Lua VM instance */ lmcf->lua = ngx_http_lua_new_state(cf, lmcf); if (lmcf->lua == NULL) { return NGX_CONF_ERROR; } /* register cleanup handler for Lua VM */ cln->handler = ngx_http_lua_cleanup_vm; cln->data = lmcf->lua; if (lmcf->preload_hooks) { /* register the 3rd-party module's preload hooks */ L = lmcf->lua; lua_getglobal(L, "package"); lua_getfield(L, -1, "preload"); hook = lmcf->preload_hooks->elts; for (i = 0; i < lmcf->preload_hooks->nelts; i++) { ngx_http_lua_probe_register_preload_package(L, hook[i].package); lua_pushcfunction(L, hook[i].loader); lua_setfield(L, -2, (char *) hook[i].package); } lua_pop(L, 2); } return NGX_CONF_OK; }
static ngx_int_t ngx_http_realip_set_addr(ngx_http_request_t *r, u_char *ip, size_t len) { u_char *p; ngx_int_t rc; ngx_addr_t addr; ngx_connection_t *c; ngx_pool_cleanup_t *cln; ngx_http_realip_ctx_t *ctx; cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_http_realip_ctx_t)); if (cln == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } ctx = cln->data; ngx_http_set_ctx(r, ctx, ngx_http_realip_module); c = r->connection; rc = ngx_parse_addr(c->pool, &addr, ip, len); switch (rc) { case NGX_DECLINED: return NGX_DECLINED; case NGX_ERROR: return NGX_HTTP_INTERNAL_SERVER_ERROR; default: /* NGX_OK */ break; } p = ngx_pnalloc(c->pool, len); if (p == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } ngx_memcpy(p, ip, len); cln->handler = ngx_http_realip_cleanup; ctx->connection = c; ctx->sockaddr = c->sockaddr; ctx->socklen = c->socklen; ctx->addr_text = c->addr_text; c->sockaddr = addr.sockaddr; c->socklen = addr.socklen; c->addr_text.len = len; c->addr_text.data = p; return NGX_DECLINED; }
static void * ngx_dso_create_conf(ngx_cycle_t *cycle) { ngx_dso_conf_ctx_t *ctx; ngx_pool_cleanup_t *cln; ctx = ngx_pcalloc(cycle->pool, sizeof(ngx_dso_conf_ctx_t)); if (ctx == NULL) { return NULL; } if (NGX_DSO_MAX < ngx_max_module) { ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "please set max dso module" "(use configure with --dso-max-modules)," "current is %ud, expect %ud", NGX_DSO_MAX, ngx_max_module + 1); return NULL; } if (ngx_is_init_cycle(cycle->old_cycle)) { ngx_memcpy(ngx_static_modules, ngx_modules, sizeof(ngx_module_t *) * ngx_max_module); ngx_memcpy(ngx_static_module_names, ngx_module_names, sizeof(u_char *) * ngx_max_module); } else { ngx_memcpy(ngx_old_modules, ngx_modules, sizeof(ngx_module_t *) * NGX_DSO_MAX); ngx_memcpy(ngx_modules, ngx_static_modules, sizeof(ngx_module_t *) * NGX_DSO_MAX); ngx_memcpy(ngx_old_module_names, ngx_module_names, sizeof(u_char *) * NGX_DSO_MAX); ngx_memcpy(ngx_module_names, ngx_static_module_names, sizeof(u_char *) * NGX_DSO_MAX); } cln = ngx_pool_cleanup_add(cycle->pool, 0); if (cln == NULL) { return NULL; } cln->handler = ngx_dso_cleanup; cln->data = cycle; return ctx; }
static ngx_int_t ngx_http_realip_set_addr(ngx_http_request_t *r, ngx_addr_t *addr) { size_t len; u_char *p; u_char text[NGX_SOCKADDR_STRLEN]; ngx_connection_t *c; ngx_pool_cleanup_t *cln; ngx_http_realip_ctx_t *ctx; cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_http_realip_ctx_t)); if (cln == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } ctx = cln->data; ngx_http_set_ctx(r, ctx, ngx_http_realip_module); c = r->connection; len = ngx_sock_ntop(addr->sockaddr, addr->socklen, text, NGX_SOCKADDR_STRLEN, 0); if (len == 0) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } p = ngx_pnalloc(c->pool, len); if (p == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } ngx_memcpy(p, text, len); cln->handler = ngx_http_realip_cleanup; ctx->connection = c; ctx->sockaddr = c->sockaddr; ctx->socklen = c->socklen; ctx->addr_text = c->addr_text; c->sockaddr = addr->sockaddr; c->socklen = addr->socklen; c->addr_text.len = len; c->addr_text.data = p; return NGX_DECLINED; }
ngx_int_t ngx_pool_set_ctx(ngx_pool_t *pool, ngx_uint_t index, void *data) { ngx_uint_t hash; uint32_t key; ngx_pool_context_node_t *node; ngx_pool_cleanup_t *cln; hash = (ngx_uint_t) pool + index; key = ngx_murmur_hash2((u_char *)&hash, sizeof(hash)) % ngx_pool_context_hash_size; node = ngx_pool_context_hash[key]; while (node) { if (node->pool == pool && node->index == index) { node->data = data; return NGX_OK; } node = node->next; } cln = ngx_pool_cleanup_add(pool, sizeof(ngx_pool_context_node_t)); if (cln == NULL) { return NGX_ERROR; } cln->handler = ngx_pool_context_cleanup; node = cln->data; node->prev = NULL; node->next = NULL; node->pool = pool; node->index = index; node->data = data; ngx_pool_context_link(&ngx_pool_context_hash[key], node); return NGX_OK; }
int ngx_tcl_cleanup_add_Tcl_Obj(ngx_pool_t *p, Tcl_Obj *obj) { ngx_pool_cleanup_t *cln; printf("%s(%p)\n", __FUNCTION__, obj); fflush(stdout); cln = ngx_pool_cleanup_add(p, sizeof(Tcl_Obj*)); if (cln == NULL) { return TCL_ERROR; } cln->handler = ngx_tcl_cleanup_Tcl_Obj; *(Tcl_Obj**)cln->data = obj; Tcl_IncrRefCount(obj); return TCL_OK; }
ngx_inline ngx_http_modsecurity_ctx_t * ngx_http_modsecurity_create_ctx(ngx_http_request_t *r) { ngx_http_modsecurity_ctx_t *ctx; ngx_http_modsecurity_loc_conf_t *loc_cf = NULL; ngx_http_modsecurity_main_conf_t *cf = NULL; ngx_pool_cleanup_t *cln = NULL; ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_modsecurity_ctx_t)); if (ctx == NULL) { dd("failed to allocate memory for the context."); return NULL; } cf = ngx_http_get_module_main_conf(r, ngx_http_modsecurity); loc_cf = ngx_http_get_module_loc_conf(r, ngx_http_modsecurity); dd("creating transaction with the following rules: '%p' -- ms: '%p'", loc_cf->rules_set, cf->modsec); ctx->modsec_transaction = msc_new_transaction(cf->modsec, loc_cf->rules_set, r->connection->log); dd("transaction created"); ngx_http_set_ctx(r, ctx, ngx_http_modsecurity); cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_http_modsecurity_ctx_t)); if (cln == NULL) { dd("failed to create the ModSecurity context cleanup"); return NGX_CONF_ERROR; } cln->handler = ngx_http_modsecurity_cleanup; cln->data = ctx; #ifdef MODSECURITY_SANITY_CHECKS ctx->sanity_headers_out = ngx_array_create(r->pool, 12, sizeof(ngx_http_modsecurity_header_t)); if (ctx->sanity_headers_out == NULL) { return NGX_CONF_ERROR; } #endif return ctx; }
static void * ngx_http_modsecurity_create_loc_conf(ngx_conf_t *cf) { ngx_http_modsecurity_loc_conf_t *conf; ngx_pool_cleanup_t *cln = NULL; conf = (ngx_http_modsecurity_loc_conf_t *) ngx_palloc(cf->pool, sizeof(ngx_http_modsecurity_loc_conf_t)); dd("creating a location specific conf"); if (conf == NULL) { dd("Failed to allocate space for a location specific conf"); return NGX_CONF_ERROR; } conf->enable = NGX_CONF_UNSET; conf->rules_remote_server.len = 0; conf->rules_remote_server.data = NULL; conf->rules_remote_key.len = 0; conf->rules_remote_key.data = NULL; conf->rules_file.len = 0; conf->rules_file.data = NULL; conf->rules.len = 0; conf->rules.data = NULL; conf->id = 0; /* Create a new rules instance */ conf->rules_set = msc_create_rules_set(); dd("created a location specific conf -- RuleSet is at: \"%p\"", conf->rules_set); //msc_rules_dump(conf->rules_set); // This was for debug cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { dd("failed to create the ModSecurity location specific configuration cleanup"); return NGX_CONF_ERROR; } cln->handler = ngx_http_modsecurity_config_cleanup; cln->data = conf; return conf; }
static ngx_int_t ngx_http_removeip_handler(ngx_http_request_t *r) { ngx_connection_t *c; ngx_pool_cleanup_t *cln; ngx_http_removeip_ctx_t *ctx; ngx_http_removeip_loc_conf_t *rlcf; ctx = ngx_http_get_module_ctx(r, ngx_http_removeip_module); if (ctx) { return NGX_DECLINED; } rlcf = ngx_http_get_module_loc_conf(r, ngx_http_removeip_module); if (!rlcf->enabled) { return NGX_DECLINED; } cln = ngx_pool_cleanup_add(r->pool, sizeof(ngx_http_removeip_ctx_t)); if (cln == NULL) { return NGX_HTTP_INTERNAL_SERVER_ERROR; } ctx = cln->data; ngx_http_set_ctx(r, ctx, ngx_http_removeip_module); c = r->connection; cln->handler = ngx_http_removeip_cleanup; ctx->connection = c; ctx->sockaddr = c->sockaddr; ctx->socklen = c->socklen; ctx->addr_text = c->addr_text; c->sockaddr = removeip_addr.sockaddr; c->socklen = removeip_addr.socklen; ngx_str_set(&c->addr_text, REMOVEIP_ADDR); return NGX_DECLINED; }
static ngx_int_t ngx_http_js_handler(ngx_http_request_t *r) { nxt_str_t value; njs_vm_t *nvm; ngx_pool_cleanup_t *cln; nxt_mem_cache_pool_t *mcp; ngx_http_js_loc_conf_t *jlcf; ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0, "http js handler"); mcp = ngx_http_js_create_mem_cache_pool(); if (mcp == NULL) { return NGX_ERROR; } cln = ngx_pool_cleanup_add(r->pool, 0); if (cln == NULL) { return NGX_ERROR; } cln->handler = ngx_http_js_cleanup_mem_cache_pool; cln->data = mcp; jlcf = ngx_http_get_module_loc_conf(r, ngx_http_js_module); nvm = njs_vm_clone(jlcf->vm, mcp, (void **) &r); if (nvm == NULL) { return NGX_ERROR; } if (njs_vm_run(nvm) != NJS_OK) { njs_vm_exception(nvm, &value); ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "js exception: %*s", value.len, value.data); return NGX_ERROR; } return NGX_OK; }
static void *ngx_stream_mruby_create_main_conf(ngx_conf_t *cf) { ngx_stream_mruby_main_conf_t *mmcf; ngx_stream_mruby_internal_ctx_t *ictx; ngx_pool_cleanup_t *cln; cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { return NULL; } mmcf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_mruby_main_conf_t)); if (mmcf == NULL) { return NULL; } mmcf->ctx = ngx_pcalloc(cf->pool, sizeof(ngx_stream_mruby_conf_ctx_t)); if (mmcf->ctx == NULL) { return NULL; } mmcf->init_code = NGX_CONF_UNSET_PTR; mmcf->init_worker_code = NGX_CONF_UNSET_PTR; mmcf->exit_worker_code = NGX_CONF_UNSET_PTR; mmcf->ctx->mrb = mrb_open(); if (mmcf->ctx->mrb == NULL) return NULL; ngx_stream_mrb_class_init(mmcf->ctx->mrb); cln->handler = ngx_stream_mruby_cleanup; cln->data = mmcf->ctx->mrb; ictx = ngx_pcalloc(cf->pool, sizeof(ngx_stream_mruby_internal_ctx_t)); if (ictx == NULL) { return NULL; } ictx->s = NULL; ictx->stream_status = NGX_DECLINED; mmcf->ctx->mrb->ud = ictx; return mmcf; }
static ngx_int_t output(ngx_http_request_t *r,void *conf,ngx_str_t type) { ngx_int_t status = 0; ngx_image_conf_t *info = conf; ngx_http_complex_value_t cv; ngx_pool_cleanup_t *cln; cln = ngx_pool_cleanup_add(r->pool, 0); if (cln == NULL) { gdFree(info->img_data); return status; } cln->handler = gd_clean_data; cln->data = info->img_data; ngx_memzero(&cv, sizeof(ngx_http_complex_value_t)); cv.value.len = info->img_size; cv.value.data = (u_char *)info->img_data; status = ngx_http_send_response(r, NGX_HTTP_OK, &type, &cv); return status; }
static void * ngx_http_modsecurity_create_main_conf(ngx_conf_t *cf) { ngx_http_modsecurity_main_conf_t *conf; dd("creating the ModSecurity main configuration"); /* ngx_pcalloc already sets all of this scructure to zeros. */ conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_modsecurity_main_conf_t)); if (conf == NULL) { dd("failed to allocate space for the ModSecurity configuration"); return NGX_CONF_ERROR; } /* Create our ModSecurity instace */ conf->modsec = msc_init(); if (conf->modsec == NULL) { dd("failed to create the ModSecurity instance"); return NGX_CONF_ERROR; } ngx_pool_cleanup_t *cln = NULL; /* Provide our connector information to LibModSecurity */ msc_set_connector_info(conf->modsec, "ModSecurity-nginx v0.0.2-alpha"); msc_set_log_cb(conf->modsec, ngx_http_modsecurity_log); cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { dd("failed to create the ModSecurity main configuration cleanup"); return NGX_CONF_ERROR; } cln->handler = ngx_http_modsecurity_main_config_cleanup; cln->data = conf; return conf; }
static void * ngx_stream_geoip_create_conf(ngx_conf_t *cf) { ngx_pool_cleanup_t *cln; ngx_stream_geoip_conf_t *conf; conf = ngx_pcalloc(cf->pool, sizeof(ngx_stream_geoip_conf_t)); if (conf == NULL) { return NULL; } cln = ngx_pool_cleanup_add(cf->pool, 0); if (cln == NULL) { return NULL; } cln->handler = ngx_stream_geoip_cleanup; cln->data = conf; return conf; }
static void * ngx_dso_create_conf(ngx_cycle_t *cycle) { ngx_dso_conf_ctx_t *ctx; ngx_pool_cleanup_t *cln; ctx = ngx_pcalloc(cycle->pool, sizeof(ngx_dso_conf_ctx_t)); if (ctx == NULL) { return NULL; } if (ngx_is_init_cycle(cycle->old_cycle)) { ngx_memcpy(ngx_static_modules, ngx_modules, sizeof(ngx_module_t *) * ngx_max_module); ngx_memcpy(ngx_static_module_names, ngx_module_names, sizeof(u_char *) * ngx_max_module); } else { ngx_memcpy(ngx_old_modules, ngx_modules, sizeof(ngx_module_t *) * NGX_DSO_MAX); ngx_memcpy(ngx_modules, ngx_static_modules, sizeof(ngx_module_t *) * NGX_DSO_MAX); ngx_memcpy(ngx_old_module_names, ngx_module_names, sizeof(u_char *) * NGX_DSO_MAX); ngx_memcpy(ngx_module_names, ngx_static_module_names, sizeof(u_char *) * NGX_DSO_MAX); } cln = ngx_pool_cleanup_add(cycle->pool, 0); if (cln == NULL) { return NULL; } cln->handler = ngx_dso_cleanup; cln->data = cycle; return ctx; }
void * ngx_postgres_create_upstream_srv_conf(ngx_conf_t *cf) { ngx_postgres_upstream_srv_conf_t *conf; ngx_pool_cleanup_t *cln; dd("entering"); conf = ngx_pcalloc(cf->pool, sizeof(ngx_postgres_upstream_srv_conf_t)); if (conf == NULL) { dd("returning NULL"); return NULL; } /* * set by ngx_pcalloc(): * * conf->peers = NULL * conf->current = 0 * conf->servers = NULL * conf->free = { NULL, NULL } * conf->cache = { NULL, NULL } * conf->active_conns = 0 * conf->reject = 0 */ conf->pool = cf->pool; /* enable keepalive (single) by default */ conf->max_cached = 10; conf->single = 1; cln = ngx_pool_cleanup_add(cf->pool, 0); cln->handler = ngx_postgres_keepalive_cleanup; cln->data = conf; dd("returning"); return conf; }