static void delete_config(config_t* config) { TSDebug(PLUGIN_TAG, "Freeing config"); TSfree(config->allowIps); TSfree(config->allowIps6); TSfree(config->stats_path); TSfree(config); }
static void free_request_info(RequestInfo *req_info) { TSfree(req_info->effective_url); TSHandleMLocRelease(req_info->buf, TS_NULL_MLOC, req_info->http_hdr_loc); TSMBufferDestroy(req_info->buf); TSfree(req_info); }
void TSRemapDeleteInstance(void *ih) { secure_link_info *sli = (secure_link_info *)ih; TSfree(sli->secret); TSfree(sli); }
/* handle_hook * Fires on TS_EVENT_HTTP_READ_REQUEST_HDR events, gets the effectiveUrl * finds the host, gets the generation ID, gen_id, for the host * and runs TSCacheUrlSet to change the cache key for the read */ static int handle_hook(TSCont *contp, TSEvent event, void *edata) { TSHttpTxn txnp = (TSHttpTxn)edata; char *url = NULL, *host = NULL; int url_length; int gen_id; int ok = 1; switch (event) { case TS_EVENT_HTTP_READ_REQUEST_HDR: TSDebug(PLUGIN_NAME, "handling TS_EVENT_HTTP_READ_REQUEST_HDR"); if (ok) { url = TSHttpTxnEffectiveUrlStringGet(txnp, &url_length); if (!url) { TSError("[%s] could not retrieve request url", PLUGIN_NAME); ok = 0; } } if (ok) { get_genid_host(&host, url); if (!host) { TSError("[%s] could not retrieve request host", PLUGIN_NAME); ok = 0; } } if (ok) { TSDebug(PLUGIN_NAME, "From url (%s) discovered host (%s)", url, host); if ((gen_id = get_genid(host)) != 0) { if (TSHttpTxnConfigIntSet(txnp, TS_CONFIG_HTTP_CACHE_GENERATION, gen_id) != TS_SUCCESS) { TSDebug(PLUGIN_NAME, "Error, unable to modify cache url"); TSError("[%s] Unable to set cache generation for %s to %d", PLUGIN_NAME, url, gen_id); ok = 0; } } } /* Clean up */ if (url) { TSfree(url); } if (host) { TSfree(host); } TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE); break; default: TSAssert(!"Unexpected event"); ok = 0; break; } return ok; }
static void free_plugin_state_t(plugin_state_t *pstate) { if (pstate->invalidate_list) free_invalidate_t_list(pstate->invalidate_list); if (pstate->config_file) TSfree(pstate->config_file); if (pstate->log) TSTextLogObjectDestroy(pstate->log); TSfree(pstate); }
static void delete_purge_instance(PurgeInstance *purge) { if (purge) { TSfree(purge->id); TSfree(purge->state_file); TSfree(purge->secret); TSfree(purge->header); TSMutexDestroy(purge->lock); TSfree(purge); } }
/** * Handle transaction context destroy. * * Handles TS_EVENT_HTTP_TXN_CLOSE (transaction close) close event from the * ATS. * * @param[in,out] ctx Transaction context */ static void tsib_txn_ctx_destroy(tsib_txn_ctx *txndata) { if (txndata == NULL) { return; } ib_tx_t *tx = txndata->tx; tsib_ssn_ctx *ssndata = txndata->ssn; assert(tx != NULL); assert(ssndata != NULL); txndata->tx = NULL; ib_log_debug_tx(tx, "TX DESTROY: conn=>%p tx_count=%zd tx=%p id=%s txn_count=%d", tx->conn, tx->conn->tx_count, tx, tx->id, ssndata->txn_count); tx_finish(tx); ib_lock_lock(ssndata->mutex); ib_tx_destroy(tx); txndata->ssn = NULL; /* Decrement the txn count on the ssn, and destroy ssn if it's closing. * We trust TS not to create more TXNs after signalling SSN close! */ if (ssndata->closing && ssndata->txn_count <= 1) { if (ssndata->iconn) { tx_list_destroy(ssndata->iconn); ib_conn_t *conn = ssndata->iconn; ib_engine_t *ib = conn->ib; ssndata->iconn = NULL; TSDebug("ironbee", "tsib_txn_ctx_destroy: calling ib_state_notify_conn_closed()"); ib_state_notify_conn_closed(ib, conn); TSDebug("ironbee", "CONN DESTROY: conn=%p", conn); ib_conn_destroy(conn); } TSContDataSet(ssndata->contp, NULL); TSContDestroy(ssndata->contp); ib_lock_unlock(ssndata->mutex); ib_lock_destroy_malloc(ssndata->mutex); TSfree(ssndata); } else { --(ssndata->txn_count); ib_lock_unlock(ssndata->mutex); } TSfree(txndata); }
static int rewrite_cacheurl(pr_list *prl, TSHttpTxn txnp) { int ok = 1; char *newurl = 0; int retval; char *url; int url_length; int i; if (ok) { url = TSHttpTxnEffectiveUrlStringGet(txnp, &url_length); if (!url) { TSError("[%s] couldn't retrieve request url\n", PLUGIN_NAME); ok = 0; } } if (ok) { i=0; while (i < prl->patterncount && prl->pr[i]) { retval = regex_substitute(&newurl, url, prl->pr[i]); if (retval) { /* Successful match/substitution */ break; } i++; } if (newurl) { if (log) { TSTextLogObjectWrite(log, "Rewriting cache URL for %s to %s", url, newurl); } TSDebug(PLUGIN_NAME, "Rewriting cache URL for %s to %s\n", url, newurl); if (TSCacheUrlSet(txnp, newurl, strlen(newurl)) != TS_SUCCESS) { TSError("[%s] Unable to modify cache url from " "%s to %s\n", PLUGIN_NAME, url, newurl); ok = 0; } } } /* Clean up */ if (url) TSfree(url); if (newurl) TSfree(newurl); return ok; }
void ts_lua_destroy_http_ctx(ts_lua_http_ctx* http_ctx) { ts_lua_main_ctx *main_ctx; main_ctx = http_ctx->mctx; if (http_ctx->server_request_bufp) { TSHandleMLocRelease(http_ctx->server_request_bufp, TS_NULL_MLOC, http_ctx->server_request_hdrp); } if (http_ctx->server_response_bufp) { TSHandleMLocRelease(http_ctx->server_response_bufp, TS_NULL_MLOC, http_ctx->server_response_hdrp); } if (http_ctx->client_response_bufp) { TSHandleMLocRelease(http_ctx->client_response_bufp, TS_NULL_MLOC, http_ctx->client_response_hdrp); } if (http_ctx->cached_response_bufp) { TSHandleMLocRelease(http_ctx->cached_response_bufp, TS_NULL_MLOC, http_ctx->cached_response_hdrp); } luaL_unref(main_ctx->lua, LUA_REGISTRYINDEX, http_ctx->ref); TSfree(http_ctx); }
TSReturnCode TSRemapInit(TSRemapInterface * api_info, char *errbuf, int errbuf_size) { int ret; if (!api_info || api_info->size < sizeof(TSRemapInterface)) { strncpy(errbuf, "[TSRemapInit] - Incorrect size of TSRemapInterface structure", errbuf_size - 1); return TS_ERROR; } if (ts_lua_main_ctx_array != NULL) return TS_SUCCESS; ts_lua_main_ctx_array = TSmalloc(sizeof(ts_lua_main_ctx) * TS_LUA_MAX_STATE_COUNT); memset(ts_lua_main_ctx_array, 0, sizeof(ts_lua_main_ctx) * TS_LUA_MAX_STATE_COUNT); ret = ts_lua_create_vm(ts_lua_main_ctx_array, TS_LUA_MAX_STATE_COUNT); if (ret) { ts_lua_destroy_vm(ts_lua_main_ctx_array, TS_LUA_MAX_STATE_COUNT); TSfree(ts_lua_main_ctx_array); return TS_ERROR; } return TS_SUCCESS; }
static int ts_lua_client_request_get_pristine_url(lua_State *L) { char *url; int url_len; TSMBuffer bufp; TSMLoc url_loc; ts_lua_http_ctx *http_ctx; http_ctx = ts_lua_get_http_ctx(L); if (TSHttpTxnPristineUrlGet(http_ctx->txnp, &bufp, &url_loc) != TS_SUCCESS) return 0; url = TSUrlStringGet(bufp, url_loc, &url_len); if (url) { lua_pushlstring(L, url, url_len); TSfree(url); } else { lua_pushnil(L); } TSHandleMLocRelease(bufp, NULL, url_loc); return 1; }
static int ts_lua_http_get_remap_to_url(lua_State *L) { TSMLoc url = TS_NULL_MLOC; char *str = NULL; int len; ts_lua_http_ctx *http_ctx; GET_HTTP_CONTEXT(http_ctx, L); if (TSRemapToUrlGet(http_ctx->txnp, &url) != TS_SUCCESS) { lua_pushnil(L); goto done; } str = TSUrlStringGet(NULL, url, &len); lua_pushlstring(L, str, len >= TS_LUA_MAX_URL_LENGTH ? TS_LUA_MAX_URL_LENGTH - 1 : len); done: if (str != NULL) { TSfree(str); } return 1; }
static void jcrusher_data_destroy(JCrusherData * data) { TSDebug("jcrusher", "Start of jcrusher_data_destroy()"); if (data) { if (data->downstream_buffer) { TSDebug("jcrusher", "jcrusher_data_destroy - destroying downstream buffer"); TSIOBufferDestroy(data->downstream_buffer); } if (data->json_obj) { TSDebug("jcrusher", "jcrusher_data_destroy - destroying json object"); json_object_put(data->json_obj); data->json_obj = NULL; TSDebug("jcrusher", "jcrusher_data_destroy - destroying json object -> done"); } if (data->json_tok) { TSDebug("jcrusher", "jcrusher_data_destroy - destroying json tokener"); json_tokener_free(data->json_tok); data->json_tok = NULL; TSDebug("jcrusher", "jcrusher_data_destroy - destroying json tokener -> done"); } TSDebug("jcrusher", "jcrusher_data_destroy - Freeing data"); TSfree(data); TSDebug("jcrusher", "jcrusher_data_destroy - Freeing data -> done"); } TSDebug("jcrusher", "End of jcrusher_data_destroy()"); }
void * remove_from_queue(Queue *q) { void *data = NULL; Cell *remove_cell; TSMutexLock(q->mutex); if (q->nb_elem > 0) { remove_cell = q->head; TSAssert(remove_cell->magic == MAGIC_ALIVE); data = remove_cell->ptr_data; q->head = remove_cell->ptr_prev; if (q->head == NULL) { TSAssert(q->nb_elem == 1); q->tail = NULL; } else { TSAssert(q->head->magic == MAGIC_ALIVE); q->head->ptr_next = NULL; } remove_cell->magic = MAGIC_DEAD; TSfree(remove_cell); q->nb_elem--; } TSMutexUnlock(q->mutex); return data; }
static int ts_lua_remap_get_to_url(lua_State *L) { char output[TS_LUA_MAX_URL_LENGTH]; char *url; int url_len; int output_len; ts_lua_http_ctx *http_ctx; GET_HTTP_CONTEXT(http_ctx, L); if (http_ctx->rri != NULL) { url = TSUrlStringGet(http_ctx->client_request_bufp, http_ctx->rri->mapToUrl, &url_len); output_len = snprintf(output, TS_LUA_MAX_URL_LENGTH, "%.*s", url_len, url); if (output_len >= TS_LUA_MAX_URL_LENGTH) { lua_pushlstring(L, output, TS_LUA_MAX_URL_LENGTH - 1); } else { lua_pushlstring(L, output, output_len); } TSfree(url); } else { lua_pushnil(L); } return 1; }
static RequestInfo * create_request_info(TSHttpTxn txn) { RequestInfo *req_info; char *url; int url_len; TSMBuffer buf; TSMLoc loc; req_info = (RequestInfo *)TSmalloc(sizeof(RequestInfo)); url = TSHttpTxnEffectiveUrlStringGet(txn, &url_len); req_info->effective_url = TSstrndup(url, url_len); TSfree(url); TSHttpTxnClientReqGet(txn, &buf, &loc); req_info->buf = TSMBufferCreate(); TSHttpHdrClone(req_info->buf, buf, loc, &(req_info->http_hdr_loc)); TSHandleMLocRelease(buf, TS_NULL_MLOC, loc); req_info->client_addr = TSmalloc(sizeof(struct sockaddr)); memmove((void *)req_info->client_addr, (void *)TSHttpTxnClientAddrGet(txn), sizeof(struct sockaddr)); return req_info; }
/** * Handle session context destroy. * * Handles TS_EVENT_HTTP_SSN_CLOSE (session close) close event from the * ATS. * * @param[in,out] ctx session context */ static void tsib_ssn_ctx_destroy(tsib_ssn_ctx * ssndata) { if (ssndata == NULL) { return; } /* To avoid the risk of sequencing issues with this coming before TXN_CLOSE, * we just mark the session as closing, but leave actually closing it * for the TXN_CLOSE if there's a TXN */ if (ssndata->txn_count == 0) { /* No outstanding TXN_CLOSE to come. */ if (ssndata->iconn != NULL) { ib_conn_t *conn = ssndata->iconn; ssndata->iconn = NULL; tx_list_destroy(conn); TSDebug("ironbee", "tsib_ssn_ctx_destroy: calling ib_state_notify_conn_closed()"); ib_state_notify_conn_closed(conn->ib, conn); TSDebug("ironbee", "CONN DESTROY: conn=%p", conn); ib_conn_destroy(conn); } /* Store off the continuation pointer */ TSCont contp = ssndata->contp; TSContDataSet(contp, NULL); ssndata->contp = NULL; TSContDestroy(contp); TSfree(ssndata); } else { ssndata->closing = 1; } }
static void free_request_state(StateInfo *state) { #if defined(DEBUG) int verify = 1; #else int verify = TSIsDebugTagSet(PLUGIN_NAME); #endif // Verify that the effective URL of this state object has been removed before we delete the state. if (verify) { void *ptr; TSMutexLock(state->plugin_config->troot_mutex); ptr = tfind(state->req_info->effective_url, &(state->plugin_config->troot), xstrcmp); TSMutexUnlock(state->plugin_config->troot_mutex); if (ptr) { TSReleaseAssert(ptr != state->req_info->effective_url); } } if (state->resp_info) { free_response_info(state->resp_info); } free_request_info(state->req_info); TSfree(state); }
int ts_lua_transform_entry(TSCont contp, TSEvent event, void *edata) { TSVIO input_vio; ts_lua_transform_ctx *transform_ctx = (ts_lua_transform_ctx*)TSContDataGet(contp); if (TSVConnClosedGet(contp)) { TSContDestroy(contp); TSfree(transform_ctx); return 0; } switch (event) { case TS_EVENT_ERROR: input_vio = TSVConnWriteVIOGet(contp); TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio); break; case TS_EVENT_VCONN_WRITE_COMPLETE: TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1); break; case TS_EVENT_VCONN_WRITE_READY: default: ts_lua_transform_handler(contp, transform_ctx); break; } return 0; }
static void transform_destroy(TSCont contp) { TransformData *data; data = TSContDataGet(contp); if (data != NULL) { if (data->input_buf) { TSIOBufferDestroy(data->input_buf); } if (data->output_buf) { TSIOBufferDestroy(data->output_buf); } if (data->pending_action) { TSActionCancel(data->pending_action); } if (data->server_vc) { TSVConnAbort(data->server_vc, 1); } TSfree(data); } else { TSError("[%s] Unable to get Continuation's Data. TSContDataGet returns NULL", PLUGIN_NAME); } TSContDestroy(contp); }
static void ts_lua_release_cache_info(ts_lua_cache_info *info, int destroy) { if (info == NULL) return; if (info->cache_action) { TSActionCancel(info->cache_action); info->cache_action = NULL; } if (info->cache_key) { TSCacheKeyDestroy(info->cache_key); info->cache_key = NULL; } if (info->cache_vc) { TSVConnClose(info->cache_vc); info->cache_vc = NULL; } TS_LUA_RELEASE_IO_HANDLE((&info->ioh)); TS_LUA_RELEASE_IO_HANDLE((&info->reserved)); if (destroy) { TSfree(info); } }
/*------------------------------------------------------------------------- cont_data_destroy Deallocate ContData structure associated to a transaction Input: data structure to deallocate Output: Return Value: none -------------------------------------------------------------------------*/ static void cont_data_destroy(ContData * data) { TSDebug(DBG_TAG, "Destroying continuation data"); if (data) { TSAssert(data->magic == MAGIC_ALIVE); if (data->output_reader) { TSIOBufferReaderFree(data->output_reader); data->output_reader = NULL; } if (data->output_buffer) { TSIOBufferDestroy(data->output_buffer); data->output_buffer = NULL; } if (data->psi_reader) { TSIOBufferReaderFree(data->psi_reader); data->psi_reader = NULL; } if (data->psi_buffer) { TSIOBufferDestroy(data->psi_buffer); data->psi_buffer = NULL; } data->magic = MAGIC_DEAD; TSfree(data); } }
// This serves to consume all the data that arrives. If it's not consumed the tunnel gets stalled // and the transaction doesn't complete. Other things could be done with the data, accessible via // the IO buffer @a reader, such as writing it to disk to make an externally accessible copy. static int client_reader(TSCont contp, TSEvent event, void *edata) { SinkData *data = TSContDataGet(contp); // If we got closed, we're done. if (TSVConnClosedGet(contp)) { TSfree(data); TSContDestroy(contp); return 0; } TSVIO input_vio = TSVConnWriteVIOGet(contp); if (!data) { data = TSmalloc(sizeof(SinkData)); data->total = 0; TSContDataSet(contp, data); } switch (event) { case TS_EVENT_ERROR: TSDebug(PLUGIN_NAME, "Error event"); TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio); break; case TS_EVENT_VCONN_READ_COMPLETE: TSDebug(PLUGIN_NAME, "READ_COMPLETE"); break; case TS_EVENT_VCONN_READ_READY: case TS_EVENT_IMMEDIATE: TSDebug(PLUGIN_NAME, "Data event - %s", event == TS_EVENT_IMMEDIATE ? "IMMEDIATE" : "READ_READY"); // Look for data and if we find any, consume. if (TSVIOBufferGet(input_vio)) { TSIOBufferReader reader = TSVIOReaderGet(input_vio); int64_t n = TSIOBufferReaderAvail(reader); if (n > 0) { TSIOBufferReaderConsume(reader, n); TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + n); data->total += n; // internal accounting so we can print the value at the end. TSDebug(PLUGIN_NAME, "Consumed %" PRId64 " bytes", n); } if (TSVIONTodoGet(input_vio) > 0) { // signal that we can accept more data. TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio); } else { TSDebug(PLUGIN_NAME, "send WRITE_COMPLETE"); TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio); } } else { // buffer gone, we're done. TSDebug(PLUGIN_NAME, "upstream buffer disappeared - %" PRId64 " bytes", data->total); } break; default: TSDebug(PLUGIN_NAME, "unhandled event %d", event); break; } return 0; }
static void free_response_info(ResponseInfo *resp_info) { TSHandleMLocRelease(resp_info->buf, TS_NULL_MLOC, resp_info->http_hdr_loc); TSMBufferDestroy(resp_info->buf); TSHttpParserDestroy(resp_info->parser); TSfree(resp_info); }
void TSRemapDeleteInstance(void* ih) { /* Release instance memory allocated in TSRemapNewInstance */ TSDebug(PLUGIN_NAME, "deleting instance %p", ih); if (ih != NULL) { hash_remap_struct *hash = (hash_remap_struct*) ih; if (hash->isp_name != NULL) TSfree(hash->isp_name); if (hash->hash != NULL) TSfree(hash->hash); TSfree(hash); } }
static void ib_ssn_ctx_destroy(ib_ssn_ctx * data) { if (data) { if (data->iconn) ib_state_notify_conn_closed(ironbee, data->iconn); TSfree(data); } }
void TSRemapDeleteInstance(void *ih) { ts_lua_del_module((ts_lua_instance_conf *) ih, ts_lua_main_ctx_array, TS_LUA_MAX_STATE_COUNT); ts_lua_del_instance(ih); TSfree(ih); return; }
/*------------------------------------------------------------------------- trylock_handler Small handler to handle TSMutexLockTry failures Input: contp continuation for the current transaction event event received data pointer on optional data Output : Return Value: -------------------------------------------------------------------------*/ static int trylock_handler(TSCont contp, TSEvent event, void *edata) { TryLockData *data = TSContDataGet(contp); transform_handler(data->contp, data->event, NULL); TSfree(data); TSContDestroy(contp); return 0; }
static void free_cfg(struct config *cfg) { TSError("[url_sig] Cleaning up..."); TSfree(cfg->err_url); if (cfg->regex_extra) #ifndef PCRE_STUDY_JIT_COMPILE pcre_free(cfg->regex_extra); #else pcre_free_study(cfg->regex_extra); #endif if (cfg->regex) pcre_free(cfg->regex); TSfree(cfg); }
static void my_data_destroy(MyData *data) { if (data) { if (data->output_buffer) TSIOBufferDestroy(data->output_buffer); TSfree(data); } }