void
TSPluginInit(int argc, const char *argv[])
{
TSFile filep;
char buf[4096];
int i;
TSPluginRegistrationInfo info;
info.plugin_name = "file_plugin";
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;
}
for (i = 1; i < argc; i++) {
filep = TSfopen(argv[i], "r");
if (!filep) {
continue;
}
while (TSfgets(filep, buf, 4096)) {
TSDebug("debug-file", "%s", buf);
}
TSfclose(filep);
}
}
void
TSPluginInit(int argc, const char *argv[])
{
TSFile filep;
char buf[4096];
int i;
TSPluginRegistrationInfo info;
info.plugin_name = "file_plugin";
info.vendor_name = "MyCompany";
info.support_email = "*****@*****.**";
if (TSPluginRegister(&info) != TS_SUCCESS) {
TSError("[file-1] Plugin registration failed.");
}
for (i = 1; i < argc; i++) {
filep = TSfopen(argv[i], "r");
if (!filep) {
continue;
}
while (TSfgets(filep, buf, 4096)) {
TSDebug("debug-file", "%s", buf);
}
TSfclose(filep);
}
}
static config_t* new_config(TSFile fh) {
char buffer[STR_BUFFER_SIZE];
config_t* config = NULL;
config = (config_t*)TSmalloc(sizeof(config_t));
config->stats_path = 0;
config->stats_path_len = 0;
config->allowIps = 0;
config->ipCount = 0;
config->allowIps6 = 0;
config->ip6Count = 0;
config->recordTypes = DEFAULT_RECORD_TYPES;
// TSmalloc(6);
if(!fh) {
config->stats_path = nstr("_astats");
config->stats_path_len = strlen(config->stats_path);
TSDebug(PLUGIN_TAG, "No config, using defaults");
return config;
}
while (TSfgets(fh, buffer, STR_BUFFER_SIZE - 1)) {
if (*buffer == '#') {
continue; /* # Comments, only at line beginning */
}
char* p = 0;
if((p = strstr(buffer, "path="))) {
p+=strlen("path=");
config->stats_path = nstr(strtok_r(p, " \n", &p));
config->stats_path_len = strlen(config->stats_path);
} else if((p = strstr(buffer, "record_types="))) {
p+=strlen("record_types=");
config->recordTypes = strtol(strtok_r(p, " \n", &p), NULL, 16);
} else if((p = strstr(buffer, "allow_ip="))) {
p+=strlen("allow_ip=");
parseIps(config, p);
} else if((p = strstr(buffer, "allow_ip6="))) {
p+=strlen("allow_ip6=");
parseIps6(config, p);
}
}
if(!config->ipCount) {
parseIps(config, NULL);
}
if(config->ip6Count) {
parseIps6(config, NULL);
}
TSDebug(PLUGIN_TAG, "config path=%s", config->stats_path);
return config;
}
static void
read_blacklist(TSCont contp)
{
char blacklist_file[1024];
TSFile file;
sprintf(blacklist_file, "%s/blacklist.txt", TSPluginDirGet());
file = TSfopen(blacklist_file, "r");
nsites = 0;
/* If the Mutext lock is not successful try again in RETRY_TIME */
if (TSMutexLockTry(sites_mutex) != TS_SUCCESS) {
if (file != NULL) {
TSfclose(file);
}
TSContSchedule(contp, RETRY_TIME, TS_THREAD_POOL_DEFAULT);
return;
}
if (file != NULL) {
char buffer[1024];
while (TSfgets(file, buffer, sizeof(buffer) - 1) != NULL && nsites < MAX_NSITES) {
char *eol;
if ((eol = strstr(buffer, "\r\n")) != NULL) {
/* To handle newlines on Windows */
*eol = '\0';
} else if ((eol = strchr(buffer, '\n')) != NULL) {
*eol = '\0';
} else {
/* Not a valid line, skip it */
continue;
}
if (sites[nsites] != NULL) {
TSfree(sites[nsites]);
}
sites[nsites] = TSstrdup(buffer);
nsites++;
}
TSfclose(file);
} else {
TSError("[%s] Unable to open %s", PLUGIN_NAME, blacklist_file);
TSError("[%s] All sites will be allowed", PLUGIN_NAME);
}
TSMutexUnlock(sites_mutex);
}
/*-------------------------------------------------------------------------
psi_include
Read file to include. Copy its content into an iobuffer.
This is the function doing blocking calls and called by the plugin's threads
Input:
data continuation for the current transaction
Output :
data->psi_buffer contains the file content
data->psi_sucess 0 if include failed, 1 if success
Return Value:
0 if failure
1 if success
-------------------------------------------------------------------------*/
static int
psi_include(TSCont contp, void *edata)
{
#define BUFFER_SIZE 1024
ContData *data;
TSFile filep;
char buf[BUFFER_SIZE];
char inc_file[PSI_PATH_MAX_SIZE + PSI_FILENAME_MAX_SIZE];
/* We manipulate plugin continuation data from a separate thread.
Grab mutex to avoid concurrent access */
TSMutexLock(TSContMutexGet(contp));
data = TSContDataGet(contp);
TSAssert(data->magic == MAGIC_ALIVE);
if (!data->psi_buffer) {
data->psi_buffer = TSIOBufferCreate();
data->psi_reader = TSIOBufferReaderAlloc(data->psi_buffer);
}
/* For security reason, we do not allow to include files that are
not in the directory <plugin_path>/include.
Also include file cannot contain any path. */
sprintf(inc_file, "%s/%s", psi_directory, _basename(data->psi_filename));
/* Read the include file and copy content into iobuffer */
if ((filep = TSfopen(inc_file, "r")) != NULL) {
TSDebug(DBG_TAG, "Reading include file %s", inc_file);
while (TSfgets(filep, buf, BUFFER_SIZE) != NULL) {
TSIOBufferBlock block;
int64_t len, avail, ndone, ntodo, towrite;
char *ptr_block;
len = strlen(buf);
ndone = 0;
ntodo = len;
while (ntodo > 0) {
/* TSIOBufferStart allocates more blocks if required */
block = TSIOBufferStart(data->psi_buffer);
ptr_block = TSIOBufferBlockWriteStart(block, &avail);
towrite = MIN(ntodo, avail);
memcpy(ptr_block, buf + ndone, towrite);
TSIOBufferProduce(data->psi_buffer, towrite);
ntodo -= towrite;
ndone += towrite;
}
}
TSfclose(filep);
data->psi_success = 1;
if (log) {
TSTextLogObjectWrite(log, "Successfully included file: %s", inc_file);
}
} else {
data->psi_success = 0;
if (log) {
TSTextLogObjectWrite(log, "Failed to include file: %s", inc_file);
}
}
/* Change state and schedule an event EVENT_IMMEDIATE on the plugin continuation
to let it know we're done. */
/* Note: if the blocking call was not in the transformation state (i.e. in
TS_HTTP_READ_REQUEST_HDR, TS_HTTP_OS_DNS and so on...) we could
use TSHttpTxnReenable to wake up the transaction instead of sending an event. */
TSContSchedule(contp, 0, TS_THREAD_POOL_DEFAULT);
data->psi_success = 0;
data->state = STATE_READ_DATA;
TSMutexUnlock(TSContMutexGet(contp));
return 0;
}
static pr_list* load_config_file(const char *config_file) {
char buffer[1024];
char default_config_file[1024];
TSFile fh;
pr_list *prl = TSmalloc(sizeof(pr_list));
prl->patterncount = 0;
/* locations in a config file line, end of line, split start, split end */
char *eol, *spstart, *spend;
int lineno = 0;
int retval;
regex_info *info = 0;
if (!config_file) {
/* Default config file of plugins/cacheurl.config */
sprintf(default_config_file, "%s/cacheurl.config", TSPluginDirGet());
config_file = (const char *)default_config_file;
}
TSDebug(PLUGIN_NAME, "Opening config file: %s", config_file);
fh = TSfopen(config_file, "r");
if (!fh) {
TSError("[%s] Unable to open %s. No patterns will be loaded\n",
PLUGIN_NAME, config_file);
return prl;
}
while (TSfgets(fh, buffer, sizeof(buffer) - 1)) {
lineno++;
if (*buffer == '#') {
/* # Comments, only at line beginning */
continue;
}
eol = strstr(buffer, "\n");
if (eol) {
*eol = 0; /* Terminate string at newline */
} else {
/* Malformed line - skip */
continue;
}
/* Split line into two parts based on whitespace */
/* Find first whitespace */
spstart = strstr(buffer, " ");
if (!spstart) {
spstart = strstr(buffer, "\t");
}
if (!spstart) {
TSError("[%s] ERROR: Invalid format on line %d. Skipping\n",
PLUGIN_NAME, lineno);
continue;
}
/* Find part of the line after any whitespace */
spend = spstart + 1;
while(*spend == ' ' || *spend == '\t') {
spend++;
}
if (*spend == 0) {
/* We reached the end of the string without any non-whitepace */
TSError("[%s] ERROR: Invalid format on line %d. Skipping\n",
PLUGIN_NAME, lineno);
continue;
}
*spstart = 0;
/* We have the pattern/replacement, now do precompilation.
* buffer is the first part of the line. spend is the second part just
* after the whitespace */
if (log) {
TSTextLogObjectWrite(log,
"Adding pattern/replacement pair: '%s' -> '%s'",
buffer, spend);
}
TSDebug(PLUGIN_NAME, "Adding pattern/replacement pair: '%s' -> '%s'\n",
buffer, spend);
retval = regex_compile(&info, buffer, spend);
if (!retval) {
TSError("[%s] Error precompiling regex/replacement. Skipping.\n",
PLUGIN_NAME);
}
// TODO - remove patterncount and make pr_list infinite (linked list)
if (prl->patterncount >= PATTERNCOUNT) {
TSError("[%s] Warning, too many patterns - skipping the rest"
"(max: %d)\n", PLUGIN_NAME, PATTERNCOUNT);
TSfree(info);
break;
}
prl->pr[prl->patterncount] = info;
prl->patterncount++;
}
TSfclose(fh);
// Make sure the last element is null
if (prl->patterncount < PATTERNCOUNT) {
prl->pr[prl->patterncount] = NULL;
}
return prl;
}