void
TSPluginInit(int argc, const char *argv[])
{
const char prefix[] = "http://";
int uri_len;
TSPluginRegistrationInfo info;
info.plugin_name = "redirect-1";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("Plugin registration failed.\n");
}
if (!check_ts_version()) {
TSError("Plugin requires Traffic Server 3.0 or later\n");
return;
}
if (argc == 3) {
block_ip = TSstrdup(argv[1]);
/*
* The Location header must contain an absolute URI:
*/
url_redirect = TSstrdup(argv[2]);
uri_len = strlen(prefix) + strlen(url_redirect) + 1;
uri_redirect = TSmalloc(uri_len);
TSstrlcpy(uri_redirect, prefix, uri_len);
TSstrlcat(uri_redirect, url_redirect, uri_len);
} else {
TSError("Incorrect syntax in plugin.conf: correct usage is" "redirect-1.so ip_deny url_redirect");
return;
}
ip_deny = inet_addr(block_ip);
TSDebug("redirect_init", "initializing stats...");
init_stats();
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(redirect_plugin, NULL));
TSDebug("redirect_init", "block_ip is %s, url_redirect is %s, and uri_redirect is %s",
block_ip, url_redirect, uri_redirect);
// ToDo: Should figure out how to print IPs which are IPv4 / v6.
// TSDebug("redirect_init", "ip_deny is %ld\n", ip_deny);
/*
* Demonstrate another tracing function. This can be used to
* enable debug calculations and other work that should only
* be done in debug mode.
*/
if (TSIsDebugTagSet("redirect_demo"))
TSDebug("redirect_init", "The redirect_demo tag is set");
else
TSDebug("redirect_init", "The redirect_demo tag is not set");
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
TSCont cont;
info.plugin_name = "server-transform";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("Plugin registration failed.\n");
}
if (!check_ts_version()) {
TSError("Plugin requires Traffic Server 3.0 or later\n");
return;
}
/* connect to the echo port on localhost */
server_ip = (127 << 24) | (0 << 16) | (0 << 8) | (1);
server_ip = htonl(server_ip);
server_port = 7;
cont = TSContCreate(transform_plugin, NULL);
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont);
}
void
TSPluginInit(int argc, const char *argv[])
{
TSCont contp;
TSPluginRegistrationInfo info;
info.plugin_name = "session-1";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("[session-1] Plugin registration failed.\n");
goto error;
}
transaction_count = INKStatCreate("transaction.count", INKSTAT_TYPE_INT64);
session_count = INKStatCreate("session.count", INKSTAT_TYPE_INT64);
av_transaction = INKStatCreate("avg.transactions", INKSTAT_TYPE_FLOAT);
contp = TSContCreate(ssn_handler, NULL);
TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, contp);
error:
TSError("[session-1] Plugin not initialized");
}
void
TSPluginInit(int argc, const char *argv[])
{
int i;
TSPluginRegistrationInfo info;
info.plugin_name = "blacklist-0";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("[blacklist-0] Plugin registration failed.");
}
nsites = argc - 1;
if (nsites > 0) {
sites = (char **)TSmalloc(sizeof(char *) * nsites);
for (i = 0; i < nsites; i++) {
sites[i] = TSstrdup(argv[i + 1]);
}
TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, TSContCreate(blacklist_plugin, NULL));
}
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
info.plugin_name = "null-transform";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("[null-transform] Plugin registration failed.\n");
goto Lerror;
}
if (!check_ts_version()) {
TSError("[null-transform] Plugin requires Traffic Server 3.0 " "or later\n");
goto Lerror;
}
TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(transform_plugin, NULL));
return;
Lerror:
TSError("[null-tranform] Unable to initialize plugin (disabled).\n");
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
TSMutex mutex = TS_NULL_MUTEX;
info.plugin_name = "buffered-null-transform";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("[bnull-transform] Plugin registration failed.\n");
goto Lerror;
}
if (!check_ts_version()) {
TSError("[bnull-transform] Plugin requires Traffic Server 3.0" " or later\n");
goto Lerror;
}
/* This is call we could use if we need to protect global data */
/* TSReleaseAssert ((mutex = TSMutexCreate()) != TS_NULL_MUTEX); */
TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(transform_plugin, mutex));
return;
Lerror:
TSError("[bnull-transform] Plugin disabled\n");
}
/**
* Initialize the IronBee ATS plugin.
*
* Performs initializations required by ATS.
*
* @param[in] argc Command-line argument count
* @param[in] argv Command-line argument list
*/
static void *ibinit(void *x)
{
TSCont cont = x;
ib_status_t rc;
rc = ironbee_init(&module_data);
if (rc != IB_OK) {
TSError("[ironbee] initialization failed: %s",
ib_status_to_string(rc));
goto Lerror;
}
/* connection initialization & cleanup */
TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, cont);
/* now all's up and running, flag it to our READ_REQUEST_HDR hook */
TSContDataSet(cont, &module_data);
/* Register our continuation for management update for traffic_line -x
* Note that this requires Trafficserver 3.3.5 or later, or else
* apply the patch from bug TS-2036
*/
TSMgmtUpdateRegister(cont, "ironbee");
return NULL;
Lerror:
TSError("[ironbee] Unable to initialize plugin (disabled).");
return NULL;
}
void TSPluginInit(int argc, const char *argv[]) {
TSPluginRegistrationInfo info;
TSCont main_cont, config_cont;
config_holder_t *config_holder;
info.plugin_name = PLUGIN_TAG;
info.vendor_name = "Comcast";
info.support_email = "*****@*****.**";
astatsLoad = time(NULL);
if (TSPluginRegister(TS_SDK_VERSION_2_0, &info) != TS_SUCCESS)
TSError("Plugin registration failed. \n");
if (!check_ts_version()) {
TSError("Plugin requires Traffic Server 2.0 or later\n");
return;
}
config_holder = new_config_holder(argc > 1 ? argv[1] : NULL);
main_cont = TSContCreate(astats_origin, NULL);
TSContDataSet(main_cont, (void *) config_holder);
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, main_cont);
config_cont = TSContCreate(config_handler, TSMutexCreate());
TSContDataSet(config_cont, (void *) config_holder);
TSMgmtUpdateRegister(config_cont, PLUGIN_TAG);
/* Create a continuation with a mutex as there is a shared global structure
containing the headers to add */
TSDebug(PLUGIN_TAG, "astats module registered, path: '%s'", config_holder->config->stats_path);
}
/** Create and return top-level cont with no transient data
* Sets up engine manager and kill-or-continue txn hook before launching
* potentially-slow mainconfiguration in separate thread.
*/
static ib_status_t tsib_pre_init(TSCont *contp)
{
int rv;
ib_status_t rc;
TSCont cont;
assert(contp != NULL);
/* create a cont to fend off traffic while we read config */
*contp = cont = TSContCreate(ironbee_plugin, NULL);
if (cont == NULL) {
TSError("[ironbee] failed to create initial continuation: disabled");
return IB_EUNKNOWN;
}
if (module_data.allow_at_startup) {
/* SSN_START doesn't use contdata; READ_REQUEST_HDR only needs non-null flag.
* Using &module_data might let us clean up some tsib_api stuff in future.
*/
TSContDataSet(cont, &module_data);
}
else {
/* NULL contdata signals the READ_REQUEST_HDR hook to reject requests */
TSContDataSet(cont, NULL);
}
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, cont);
if (!module_data.log_disable) {
/* success is documented as TS_LOG_ERROR_NO_ERROR but that's undefined.
* It's actually a TS_SUCCESS (proxy/InkAPI.cc line 6641).
*/
printf("Logging to \"%s\"\n", module_data.log_file);
rv = TSTextLogObjectCreate(module_data.log_file,
TS_LOG_MODE_ADD_TIMESTAMP,
&module_data.logger);
if (rv != TS_SUCCESS) {
TSError("[ironbee] Error creating log file.");
return IB_EUNKNOWN;
}
}
/* Initialize IronBee (including util) */
rc = ib_initialize();
if (rc != IB_OK) {
TSError("[ironbee] Error initializing IronBee: %s",
ib_status_to_string(rc));
return rc;
}
/* Create the IronBee engine manager */
TSDebug("ironbee", "Creating IronBee engine manager");
rc = ib_manager_create(&(module_data.manager), /* Engine Manager */
&ibplugin, /* Server object */
module_data.max_engines); /* Default max */
if (rc != IB_OK) {
TSError("[ironbee] Error creating IronBee engine manager: %s",
ib_status_to_string(rc));
}
return rc;
}
void
TSPluginInit(int argc, const char *argv[])
{
const char prefix[] = "http://";
int uri_len;
TSPluginRegistrationInfo info;
info.plugin_name = PLUGIN_NAME;
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("[%s] Plugin registration failed", PLUGIN_NAME);
}
if (argc == 3) {
block_ip = TSstrdup(argv[1]);
/*
* The Location header must contain an absolute URI:
*/
url_redirect = TSstrdup(argv[2]);
uri_len = strlen(prefix) + strlen(url_redirect) + 1;
uri_redirect = TSmalloc(uri_len);
TSstrlcpy(uri_redirect, prefix, uri_len);
TSstrlcat(uri_redirect, url_redirect, uri_len);
} else {
TSError("[%s] Incorrect syntax in plugin.conf: correct usage is", PLUGIN_NAME "redirect_1.so ip_deny url_redirect");
return;
}
ip_deny = inet_addr(block_ip);
TSDebug(PLUGIN_NAME, "initializing stats");
init_stats();
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(redirect_plugin, NULL));
TSDebug(PLUGIN_NAME ".init", "block_ip is %s, url_redirect is %s, and uri_redirect is %s", block_ip, url_redirect, uri_redirect);
/*
* Demonstrate another tracing function. This can be used to
* enable debug calculations and other work that should only
* be done in debug mode.
*/
if (TSIsDebugTagSet(PLUGIN_NAME ".demo")) {
TSDebug(PLUGIN_NAME ".init", "The redirect_demo tag is set");
} else {
TSDebug(PLUGIN_NAME ".init", "The redirect_demo tag is not set");
}
}
/* Initialize the plugin / global continuation hook */
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
const char *proof = "acme";
static const struct option longopt[] = {
{(char *)"proof-directory", optional_argument, NULL, 'p'},
{NULL, no_argument, NULL, '\0'},
};
memset(&gConfig, 0, sizeof(gConfig));
while (true) {
int opt = getopt_long(argc, (char *const *)argv, "", longopt, NULL);
switch (opt) {
case 'p':
proof = optarg;
break;
}
if (opt == -1) {
break;
}
}
if ('/' != *proof) {
const char *confdir = TSConfigDirGet();
int len = strlen(proof) + strlen(confdir) + 8;
gConfig.proof = TSmalloc(len);
snprintf(gConfig.proof, len, "%s/%s", confdir, proof);
TSDebug(PLUGIN_NAME, "base directory for proof-types is %s", gConfig.proof);
} else {
gConfig.proof = TSstrdup(proof);
}
info.plugin_name = "acme";
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TS_SUCCESS != TSPluginRegister(&info)) {
TSError("[%s] Plugin registration failed", PLUGIN_NAME);
return;
}
TSDebug(PLUGIN_NAME, "Started the %s plugin", PLUGIN_NAME);
TSDebug(PLUGIN_NAME, "\tproof-type dir = %s", gConfig.proof);
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(acme_hook, NULL));
}
void
TSPluginInit(int argc, const char *argv[])
{
int ret = 0;
ts_lua_g_main_ctx_array = TSmalloc(sizeof(ts_lua_main_ctx) * TS_LUA_MAX_STATE_COUNT);
memset(ts_lua_g_main_ctx_array, 0, sizeof(ts_lua_main_ctx) * TS_LUA_MAX_STATE_COUNT);
ret = ts_lua_create_vm(ts_lua_g_main_ctx_array, TS_LUA_MAX_STATE_COUNT);
if (ret) {
ts_lua_destroy_vm(ts_lua_g_main_ctx_array, TS_LUA_MAX_STATE_COUNT);
TSfree(ts_lua_g_main_ctx_array);
return;
}
if (argc < 2) {
TSError("[%s] lua script file required !!", __FUNCTION__);
return;
}
if (strlen(argv[1]) >= TS_LUA_MAX_SCRIPT_FNAME_LENGTH - 16) {
TSError("[%s] lua script file name too long !!", __FUNCTION__);
return;
}
ts_lua_instance_conf *conf = TSmalloc(sizeof(ts_lua_instance_conf));
if (!conf) {
TSError("[%s] TSmalloc failed !!", __FUNCTION__);
return;
}
sprintf(conf->script, "%s", argv[1]);
ret = ts_lua_add_module(conf, ts_lua_g_main_ctx_array, TS_LUA_MAX_STATE_COUNT, argc - 1, (char **) &argv[1]);
if (ret != 0) {
TSError("[%s] ts_lua_add_module failed", __FUNCTION__);
return;
}
TSCont txn_start_contp = TSContCreate(transactionStartHookHandler, NULL);
if (!txn_start_contp) {
TSError("[%s] could not create transaction start continuation", __FUNCTION__);
return;
}
TSContDataSet(txn_start_contp, conf);
TSHttpHookAdd(TS_HTTP_TXN_START_HOOK, txn_start_contp);
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
static const char usage[] = PLUGIN_NAME ".so [--integer-counters] [PATH]";
static const struct option longopts[] = {{(char *)("integer-counters"), no_argument, NULL, 'i'},
{(char *)("wrap-counters"), no_argument, NULL, 'w'},
{NULL, 0, NULL, 0}};
info.plugin_name = PLUGIN_NAME;
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("[%s] registration failed", PLUGIN_NAME);
}
for (;;) {
switch (getopt_long(argc, (char *const *)argv, "iw", longopts, NULL)) {
case 'i':
integer_counters = true;
break;
case 'w':
wrap_counters = true;
break;
case -1:
goto init;
default:
TSError("[%s] usage: %s", PLUGIN_NAME, usage);
}
}
init:
argc -= optind;
argv += optind;
if (argc > 0) {
url_path = TSstrdup(argv[0] + ('/' == argv[0][0] ? 1 : 0)); /* Skip leading / */
}
url_path_len = strlen(url_path);
/* Create a continuation with a mutex as there is a shared global structure
containing the headers to add */
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(stats_origin, NULL));
TSDebug(PLUGIN_NAME, "stats module registered");
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
info.plugin_name = PLUGIN_NAME;
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError(PCP "Plugin registration failed.\n");
return;
}
TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(main_hook, NULL));
return;
}
/*-------------------------------------------------------------------------
TSPluginInit
Function called at plugin init time
Input:
argc number of args
argv list vof args
Output :
Return Value:
-------------------------------------------------------------------------*/
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
int i;
TSReturnCode retval;
info.plugin_name = "psi";
info.vendor_name = "Apache";
info.support_email = "";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("Plugin registration failed.\n");
}
if (!check_ts_version()) {
TSError("Plugin requires Traffic Server 3.0 or later\n");
return;
}
/* Initialize the psi directory = <plugin_path>/include */
sprintf(psi_directory, "%s/%s", TSPluginDirGet(), PSI_PATH);
/* create an TSTextLogObject to log any psi include */
retval = TSTextLogObjectCreate("psi", TS_LOG_MODE_ADD_TIMESTAMP, &log);
if (retval == TS_ERROR) {
TSError("Failed creating log for psi plugin");
log = NULL;
}
/* Create working threads */
thread_init();
init_queue(&job_queue);
for (i = 0; i < NB_THREADS; i++) {
char *thread_name = (char *) TSmalloc(64);
sprintf(thread_name, "Thread[%d]", i);
if (!TSThreadCreate((TSThreadFunc) thread_loop, thread_name)) {
TSError("[TSPluginInit] Error while creating threads");
return;
}
}
TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(read_response_handler, TSMutexCreate()));
TSDebug(DBG_TAG, "Plugin started");
}
/* Initialize the plugin / global continuation hook */
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
if (2 != argc) {
TSError("Must specify a configuration file.\n");
return;
}
info.plugin_name = "health_checks";
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TS_SUCCESS != TSPluginRegister(TS_SDK_VERSION_3_0, &info)) {
TSError("Plugin registration failed. \n");
return;
}
if (!check_ts_version()) {
TSError("Plugin requires Traffic Server 3.0 or later\n");
return;
}
/* This will update the global configuration file, and is not reloaded at run time */
/* ToDo: Support reloading with traffic_line -x ? */
if (NULL == (g_config = parse_configs(argv[1]))) {
TSError("Unable to read / parse %s config file", argv[1]);
return;
}
/* Setup the background thread */
if (!TSThreadCreate(hc_thread, NULL)) {
TSError("Failure in thread creation");
return;
}
/* Create a continuation with a mutex as there is a shared global structure
containing the headers to add */
TSDebug(PLUGIN_NAME, "Started %s plugin", PLUGIN_NAME);
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(health_check_origin, NULL));
}
void TSPluginInit(int argc, const char *argv[])
{
int rv;
TSPluginRegistrationInfo info;
TSCont cont;
/* FIXME - check why these are char*, not const char* */
info.plugin_name = (char *)"ironbee";
info.vendor_name = (char *)"Qualys, Inc";
info.support_email = (char *)"*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("[ironbee] Plugin registration failed.\n");
goto Lerror;
}
if (!check_ts_version()) {
TSError("[ironbee] Plugin requires Traffic Server 3.0 or later\n");
goto Lerror;
}
cont = TSContCreate(ironbee_plugin, NULL);
/* connection initialisation & cleanup */
TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, cont);
if (argc < 2) {
TSError("[ironbee] configuration file name required\n");
goto Lerror;
}
rv = ironbee_init(argv[1], argc >= 3 ? argv[2] : DEFAULT_LOG);
if (rv != IB_OK) {
TSError("[ironbee] initialisation failed with %d\n", rv);
}
return;
Lerror:
TSError("[ironbee] Unable to initialize plugin (disabled).\n");
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
info.plugin_name = "stats";
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_2_0, &info) != TS_SUCCESS)
TSError("Plugin registration failed. \n");
if (argc > 1) {
url_path = TSstrdup(argv[1] + ('/' == argv[1][0] ? 1 : 0)); /* Skip leading / */
}
url_path_len = strlen(url_path);
/* Create a continuation with a mutex as there is a shared global structure
containing the headers to add */
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(stats_origin, NULL));
TSDebug("istats", "stats module registered");
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
info.plugin_name = (char *)PLUGIN_NAME;
info.vendor_name = (char *)"Apache Software Foundation";
info.support_email = (char *)"*****@*****.**";
if (argc > 1) {
TSstrlcpy(genid_kyoto_db, argv[1], sizeof(genid_kyoto_db));
} else {
TSError("[%s] plugin registration failed. check argv[1] for db path", PLUGIN_NAME);
return;
}
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("[%s] plugin registration failed, check version", PLUGIN_NAME);
return;
}
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate((TSEventFunc)handle_hook, NULL));
}
void
TSPluginInit(int argc, const char *argv[])
{
TSMLoc chk_field_loc;
TSPluginRegistrationInfo info;
info.plugin_name = "response-header-1";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("Plugin registration failed.\n");
}
init_buffer_status = 0;
if (argc > 1) {
TSError("usage: %s \n", argv[0]);
TSError("warning: too many args %d\n", argc);
TSError("warning: ignoring unused arguments beginning with %s\n", argv[1]);
}
/*
* The following code sets up an "init buffer" containing an extension header
* and its initial value. This will be the same for all requests, so we try
* to be efficient and do all of the work here rather than on a per-transaction
* basis.
*/
hdr_bufp = TSMBufferCreate();
TSMimeHdrCreate(hdr_bufp, &hdr_loc);
mimehdr1_name = TSstrdup("x-num-served-from-cache");
mimehdr1_value = TSstrdup("0");
/* Create name here and set DateTime value when o.s.
* response 200 is received
*/
mimehdr2_name = TSstrdup("x-date-200-recvd");
TSDebug("resphdr", "Inserting header %s with value %s into init buffer", mimehdr1_name, mimehdr1_value);
TSMimeHdrFieldCreate(hdr_bufp, hdr_loc, &field_loc); /* Probably should check for errors */
TSMimeHdrFieldAppend(hdr_bufp, hdr_loc, field_loc);
TSMimeHdrFieldNameSet(hdr_bufp, hdr_loc, field_loc, mimehdr1_name, strlen(mimehdr1_name));
TSMimeHdrFieldValueStringInsert(hdr_bufp, hdr_loc, field_loc, -1, mimehdr1_value, strlen(mimehdr1_value));
TSDebug("resphdr", "init buffer hdr, field and value locs are %p, %p and %p", hdr_loc, field_loc, value_loc);
init_buffer_status = 1;
TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(modify_response_header_plugin, NULL));
/*
* The following code demonstrates how to extract the field_loc from the header.
* In this plugin, the init buffer and thus field_loc never changes. Code
* similar to this may be used to extract header fields from any buffer.
*/
if (TS_NULL_MLOC == (chk_field_loc = TSMimeHdrFieldGet(hdr_bufp, hdr_loc, 0))) {
TSError("couldn't retrieve header field from init buffer");
TSError("marking init buffer as corrupt; no more plugin processing");
init_buffer_status = 0;
/* bail out here and reenable transaction */
} else {
if (field_loc != chk_field_loc)
TSError("retrieved buffer field loc is %p when it should be %p", chk_field_loc, field_loc);
}
}
void
TSPluginInit(int argc, const char *argv[])
{
TSMLoc field_loc;
const char *p;
int i, retval;
TSPluginRegistrationInfo info;
info.plugin_name = "add-header";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("[PluginInit] Plugin registration failed.\n");
goto error;
}
if (!check_ts_version()) {
TSError("[PluginInit] Plugin requires Traffic Server 3.0 or later\n");
goto error;
}
if (argc < 2) {
TSError("[PluginInit] Usage: %s \"name1: value1\" \"name2: value2\" ...>\n", argv[0]);
goto error;
}
hdr_bufp = TSMBufferCreate();
if (TSMimeHdrCreate(hdr_bufp, &hdr_loc) != TS_SUCCESS) {
TSError("[PluginInit] Can not create mime header");
goto error;
}
for (i = 1; i < argc; i++) {
if (TSMimeHdrFieldCreate(hdr_bufp, hdr_loc, &field_loc) != TS_SUCCESS) {
TSError("[PluginInit] Error while creating field");
goto error;
}
retval = TSMimeHdrFieldAppend(hdr_bufp, hdr_loc, field_loc);
if (retval != TS_SUCCESS) {
TSError("[PluginInit] Error while adding field");
goto error;
}
p = strchr(argv[i], ':');
if (p) {
retval = TSMimeHdrFieldNameSet(hdr_bufp, hdr_loc, field_loc, argv[i], p - argv[i]);
if (retval == TS_ERROR) {
TSError("[PluginInit] Error while naming field");
goto error;
}
p += 1;
while (isspace(*p)) {
p += 1;
}
retval = TSMimeHdrFieldValueStringInsert(hdr_bufp, hdr_loc, field_loc, -1, p, strlen(p));
if (retval == TS_ERROR) {
TSError("[PluginInit] Error while inserting field value");
goto error;
}
} else {
retval = TSMimeHdrFieldNameSet(hdr_bufp, hdr_loc, field_loc, argv[i], strlen(argv[i]));
if (retval == TS_ERROR) {
TSError("[PluginInit] Error while inserting field value");
goto error;
}
}
}
/* Create a continuation with a mutex as there is a shared global structure
containing the headers to add */
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(add_header_plugin, TSMutexCreate()));
goto done;
error:
TSError("[PluginInit] Plugin not initialized");
done:
return;
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
TSCont main_cont, config_cont;
plugin_state_t *pstate;
invalidate_t *iptr = NULL;
bool disable_timed_reload = false;
TSDebug(LOG_PREFIX, "Starting plugin init");
pstate = (plugin_state_t *)TSmalloc(sizeof(plugin_state_t));
init_plugin_state_t(pstate);
int c;
static const struct option longopts[] = {{"config", required_argument, NULL, 'c'},
{"log", required_argument, NULL, 'l'},
{"disable-timed-reload", no_argument, NULL, 'd'},
{NULL, 0, NULL, 0}};
while ((c = getopt_long(argc, (char *const *)argv, "c:l:", longopts, NULL)) != -1) {
switch (c) {
case 'c':
pstate->config_file = TSstrdup(optarg);
break;
case 'l':
if (TS_SUCCESS == TSTextLogObjectCreate(optarg, TS_LOG_MODE_ADD_TIMESTAMP, &pstate->log)) {
TSTextLogObjectRollingEnabledSet(pstate->log, 1);
TSTextLogObjectRollingIntervalSecSet(pstate->log, LOG_ROLL_INTERVAL);
TSTextLogObjectRollingOffsetHrSet(pstate->log, LOG_ROLL_OFFSET);
}
break;
case 'd':
disable_timed_reload = true;
break;
default:
break;
}
}
if (!pstate->config_file) {
TSError("[regex_revalidate] Plugin requires a --config option along with a config file name");
free_plugin_state_t(pstate);
return;
}
if (!load_config(pstate, &iptr)) {
TSDebug(LOG_PREFIX, "Problem loading config from file %s", pstate->config_file);
} else {
pstate->invalidate_list = iptr;
list_config(pstate, iptr);
}
info.plugin_name = LOG_PREFIX;
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("[regex_revalidate] Plugin registration failed");
free_plugin_state_t(pstate);
return;
} else {
TSDebug(LOG_PREFIX, "Plugin registration succeeded");
}
if (!check_ts_version()) {
TSError("[regex_revalidate] Plugin requires Traffic Server %d.%d.%d", TS_VERSION_MAJOR, TS_VERSION_MINOR, TS_VERSION_MICRO);
free_plugin_state_t(pstate);
return;
}
pcre_malloc = &ts_malloc;
pcre_free = &ts_free;
main_cont = TSContCreate(main_handler, NULL);
TSContDataSet(main_cont, (void *)pstate);
TSHttpHookAdd(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, main_cont);
config_cont = TSContCreate(config_handler, TSMutexCreate());
TSContDataSet(config_cont, (void *)pstate);
TSMgmtUpdateRegister(config_cont, LOG_PREFIX);
if (!disable_timed_reload) {
TSContScheduleOnPool(config_cont, CONFIG_TMOUT, TS_THREAD_POOL_TASK);
}
TSDebug(LOG_PREFIX, "Plugin Init Complete");
}
void
TSPluginInit(int argc, const char *argv[])
{
int ret = 0;
ts_lua_g_main_ctx_array = TSmalloc(sizeof(ts_lua_main_ctx) * TS_LUA_MAX_STATE_COUNT);
memset(ts_lua_g_main_ctx_array, 0, sizeof(ts_lua_main_ctx) * TS_LUA_MAX_STATE_COUNT);
ret = ts_lua_create_vm(ts_lua_g_main_ctx_array, TS_LUA_MAX_STATE_COUNT);
if (ret) {
ts_lua_destroy_vm(ts_lua_g_main_ctx_array, TS_LUA_MAX_STATE_COUNT);
TSfree(ts_lua_g_main_ctx_array);
return;
}
if (argc < 2) {
TSError("[%s] lua script file required !!", __FUNCTION__);
return;
}
if (strlen(argv[1]) >= TS_LUA_MAX_SCRIPT_FNAME_LENGTH - 16) {
TSError("[%s] lua script file name too long !!", __FUNCTION__);
return;
}
ts_lua_instance_conf *conf = TSmalloc(sizeof(ts_lua_instance_conf));
if (!conf) {
TSError("[%s] TSmalloc failed !!", __FUNCTION__);
return;
}
memset(conf, 0, sizeof(ts_lua_instance_conf));
sprintf(conf->script, "%s", argv[1]);
ts_lua_init_instance(conf);
ret = ts_lua_add_module(conf, ts_lua_g_main_ctx_array, TS_LUA_MAX_STATE_COUNT, argc - 1, (char **) &argv[1]);
if (ret != 0) {
TSError("[%s] ts_lua_add_module failed", __FUNCTION__);
return;
}
TSCont global_contp = TSContCreate(globalHookHandler, NULL);
if (!global_contp) {
TSError("[%s] could not create transaction start continuation", __FUNCTION__);
return;
}
TSContDataSet(global_contp, conf);
//adding hook based on whether the lua global function exists.
ts_lua_main_ctx *main_ctx = &ts_lua_g_main_ctx_array[0];
ts_lua_http_ctx *http_ctx = ts_lua_create_http_ctx(main_ctx, conf);
lua_State *l = http_ctx->lua;
lua_getglobal(l, TS_LUA_FUNCTION_G_SEND_REQUEST);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_SEND_REQUEST_HDR_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "send_request_hdr_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_READ_RESPONSE);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "read_response_hdr_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_SEND_RESPONSE);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_SEND_RESPONSE_HDR_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "send_response_hdr_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_CACHE_LOOKUP_COMPLETE);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "cache_lookup_complete_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_READ_REQUEST);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "read_request_hdr_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_TXN_START);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_TXN_START_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "txn_start_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_PRE_REMAP);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_PRE_REMAP_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "pre_remap_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_POST_REMAP);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_POST_REMAP_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "post_remap_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_SELECT_ALT);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_SELECT_ALT_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "select_alt_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_OS_DNS);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "os_dns_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_READ_CACHE);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_READ_CACHE_HDR_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "read_cache_hdr_hook added");
}
lua_pop(l, 1);
lua_getglobal(l, TS_LUA_FUNCTION_G_TXN_CLOSE);
if (lua_type(l, -1) == LUA_TFUNCTION) {
TSHttpHookAdd(TS_HTTP_TXN_CLOSE_HOOK, global_contp);
TSDebug(TS_LUA_DEBUG_TAG, "txn_close_hook added");
}
lua_pop(l, 1);
ts_lua_destroy_http_ctx(http_ctx);
}
void
TSPluginInit(int argc, const char *argv[])
{
TSPluginRegistrationInfo info;
TSCont pre_remap_cont, post_remap_cont, global_cont;
config_t *config;
info.plugin_name = PLUGIN_NAME;
info.vendor_name = "Apache Software Foundation";
info.support_email = "*****@*****.**";
if (TSPluginRegister(TS_SDK_VERSION_3_0, &info) != TS_SUCCESS) {
TSError("Plugin registration failed.");
return;
} else
TSDebug(DEBUG_TAG, "Plugin registration succeeded.");
config = TSmalloc(sizeof(config_t));
config->post_remap_host = false;
config->persist_type = TS_STAT_NON_PERSISTENT;
config->stat_creation_mutex = TSMutexCreate();
if (argc > 1) {
int c;
optind = 1;
static const struct option longopts[] = {
{"post-remap-host", no_argument, NULL, 'P'},
{"persistent", no_argument, NULL, 'p'},
{NULL, 0, NULL, 0}
};
while ((c = getopt_long(argc, (char *const *) argv, "Pp", longopts, NULL)) != -1) {
switch (c) {
case 'P':
config->post_remap_host = true;
TSDebug(DEBUG_TAG, "Using post remap hostname");
break;
case 'p':
config->persist_type = TS_STAT_PERSISTENT;
TSDebug(DEBUG_TAG, "Using persistent stats");
break;
default:
break;
}
}
}
TSHttpArgIndexReserve(PLUGIN_NAME, "txn data", &(config->txn_slot));
if (!config->post_remap_host) {
pre_remap_cont = TSContCreate(handle_read_req_hdr, NULL);
TSContDataSet(pre_remap_cont, (void *) config);
TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, pre_remap_cont);
}
post_remap_cont = TSContCreate(handle_post_remap, NULL);
TSContDataSet(post_remap_cont, (void *) config);
TSHttpHookAdd(TS_HTTP_POST_REMAP_HOOK, post_remap_cont);
global_cont = TSContCreate(handle_txn_close, NULL);
TSContDataSet(global_cont, (void *) config);
TSHttpHookAdd(TS_HTTP_TXN_CLOSE_HOOK, global_cont);
TSDebug(DEBUG_TAG, "Init complete");
}
