void
ts_http_fetcher_launch(http_fetcher *fch)
{
int64_t hdr_len;
// post body , content-length
TSIOBufferWrite(fch->req_buffer, "\r\n", sizeof("\r\n")-1);
hdr_len = TSIOBufferReaderAvail(fch->req_reader);
fch->http_vc = TSHttpConnect(&(fch->aip));
fch->hdr_buffer = TSIOBufferSizedCreate(TS_IOBUFFER_SIZE_INDEX_8K);
fch->hdr_reader = TSIOBufferReaderAlloc(fch->hdr_buffer);
fch->hdr_bufp = TSMBufferCreate();
fch->hdr_loc = TSHttpHdrCreate(fch->hdr_bufp);
fch->resp_buffer = TSIOBufferCreate();
fch->resp_reader = TSIOBufferReaderAlloc(fch->resp_buffer);
fch->http_parser = TSHttpParserCreate();
fch->fetch_contp = TSContCreate(ts_http_fetch_handler, fch->mutexp);
TSContDataSet(fch->fetch_contp, fch);
fch->read_vio = TSVConnRead(fch->http_vc, fch->fetch_contp, fch->resp_buffer, INT64_MAX);
if (fch->method == TS_FETCH_METHOD_POST && fch->post_cl >= 0) {
fch->write_vio = TSVConnWrite(fch->http_vc, fch->fetch_contp, fch->req_reader, hdr_len + fch->post_cl);
} else {
fch->write_vio = TSVConnWrite(fch->http_vc, fch->fetch_contp, fch->req_reader, hdr_len);
}
fch->launched = 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;
}
static ResponseInfo *
create_response_info(void)
{
ResponseInfo *resp_info;
resp_info = (ResponseInfo *)TSmalloc(sizeof(ResponseInfo));
resp_info->buf = TSMBufferCreate();
resp_info->http_hdr_loc = TSHttpHdrCreate(resp_info->buf);
resp_info->parser = TSHttpParserCreate();
resp_info->parsed = false;
return resp_info;
}
static char *
get_effective_host(TSHttpTxn txn)
{
char *effective_url, *tmp;
const char *host;
int len;
TSMBuffer buf;
TSMLoc url_loc;
effective_url = TSHttpTxnEffectiveUrlStringGet(txn, &len);
buf = TSMBufferCreate();
TSUrlCreate(buf, &url_loc);
tmp = effective_url;
TSUrlParse(buf, url_loc, (const char **) (&tmp), (const char *) (effective_url + len));
TSfree(effective_url);
host = TSUrlHostGet(buf, url_loc, &len);
tmp = TSstrndup(host, len);
TSHandleMLocRelease(buf, TS_NULL_MLOC, url_loc);
TSMBufferDestroy(buf);
return tmp;
}
static RequestInfo *
create_request_info(TSHttpTxn txn)
{
RequestInfo *req_info;
char *url;
int url_len;
TSMBuffer buf;
TSMLoc loc;
const struct sockaddr *sa;
req_info = (RequestInfo *)TSmalloc(sizeof(RequestInfo));
memset(req_info, 0, 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);
sa = TSHttpTxnClientAddrGet(txn);
switch (sa->sa_family) {
case AF_INET:
memcpy(&req_info->client_addr.sin, sa, sizeof(struct sockaddr_in));
break;
case AF_INET6:
memcpy(&req_info->client_addr.sin6, sa, sizeof(struct sockaddr_in6));
break;
default:
break;
}
return req_info;
}
static TSCacheKey
ts_lua_cache_key_create(const char *keystr, size_t key_len, const char *optstr, size_t opt_len)
{
const char *ptr, *end, *host;
char c;
int host_len;
TSCacheKey key;
TSMBuffer urlBuf;
TSMLoc urlLoc;
int url, http;
ptr = optstr;
end = optstr + opt_len;
url = http = 0;
while (ptr < end) {
c = *ptr;
switch (c) {
case 'u':
url = 1;
break;
case 'h':
http = 1;
break;
default:
break;
}
ptr++;
}
key = TSCacheKeyCreate();
urlBuf = NULL;
if (url == 0) {
TSCacheKeyDigestSet(key, keystr, key_len);
} else {
end = keystr + key_len;
ptr = memchr(keystr, ':', key_len);
if (ptr == NULL)
goto fail;
ptr += 3;
if (ptr >= end)
goto fail;
host = ptr;
ptr = memchr(host, '/', end-host);
if (ptr != NULL) {
host_len = ptr - host;
} else {
host_len = end - host;
}
if (host_len <= 0)
goto fail;
ptr = memchr(host, ':', host_len);
if (ptr != NULL) {
host_len = ptr - host;
}
urlBuf = TSMBufferCreate();
TSUrlCreate(urlBuf, &urlLoc);
if (TSUrlParse(urlBuf, urlLoc, (const char **) &keystr, end) != TS_PARSE_DONE ||
TSCacheKeyDigestFromUrlSet(key, urlLoc) != TS_SUCCESS) {
goto fail;
}
TSHandleMLocRelease(urlBuf, NULL, urlLoc);
TSMBufferDestroy(urlBuf);
TSCacheKeyHostNameSet(key, host, host_len);
}
if (http) {
TSCacheKeyDataTypeSet(key, TS_CACHE_DATA_TYPE_HTTP);
}
return key;
fail:
TSCacheKeyDestroy(key);
if (urlBuf) {
TSHandleMLocRelease(urlBuf, NULL, urlLoc);
TSMBufferDestroy(urlBuf);
}
return NULL;
}
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[])
{
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);
}
}