static void x_SetupUserAgent(SConnNetInfo* net_info)
{
CNcbiApplication* theApp = CNcbiApplication::Instance();
if (theApp) {
string user_agent("User-Agent: ");
user_agent += theApp->GetProgramDisplayName();
ConnNetInfo_ExtendUserHeader(net_info, user_agent.c_str());
}
}
/*ARGSUSED*/
const SSERV_VTable* SERV_DISPD_Open(SERV_ITER iter,
const SConnNetInfo* net_info,
SSERV_Info** info, HOST_INFO* u/*unused*/)
{
struct SDISPD_Data* data;
if (!(data = (struct SDISPD_Data*) calloc(1, sizeof(*data))))
return 0;
iter->data = data;
assert(net_info); /*must be called with non-NULL*/
data->net_info = ConnNetInfo_Clone(net_info);
if (!ConnNetInfo_SetupStandardArgs(data->net_info, iter->name)) {
s_Close(iter);
return 0;
}
if (g_NCBI_ConnectRandomSeed == 0) {
g_NCBI_ConnectRandomSeed = iter->time ^ NCBI_CONNECT_SRAND_ADDEND;
srand(g_NCBI_ConnectRandomSeed);
}
/* Reset request method to be GET ('cause no HTTP body is ever used) */
data->net_info->req_method = eReqMethod_Get;
if (iter->stateless)
data->net_info->stateless = 1/*true*/;
if ((iter->types & fSERV_Firewall) && !data->net_info->firewall)
data->net_info->firewall = eFWMode_Adaptive;
ConnNetInfo_ExtendUserHeader(data->net_info,
"User-Agent: NCBIServiceDispatcher/"
HTTP_DISP_VERSION
#ifdef NCBI_CXX_TOOLKIT
" (CXX Toolkit)"
#else
" (C Toolkit)"
#endif /*NCBI_CXX_TOOLKIT*/
"\r\n");
data->n_skip = iter->n_skip;
iter->op = &s_op; /*SERV_Update() [from HTTP callback] expects*/
s_Resolve(iter);
iter->op = 0;
if (!data->n_cand && (data->fail
|| !(data->net_info->stateless &&
data->net_info->firewall))) {
s_Reset(iter);
s_Close(iter);
return 0;
}
/* call GetNextInfo subsequently if info is actually needed */
if (info)
*info = 0;
return &s_op;
}
/* NB: HTTP tag name misspelled as "Referer" as per the standard. */
static void s_AddReferer(SConnNetInfo* net_info)
{
const char* s;
char* referer;
if (!net_info || !net_info->http_referer || !*net_info->http_referer)
return;
if ((s = net_info->http_user_header) != 0) {
int/*bool*/ first;
for (first = 1; *s; first = 0) {
if (strncasecmp(s++, "\nReferer: " + first, 10 - first) == 0)
return;
if (!(s = strchr(s, '\n')))
break;
}
}
if (!(referer = (char*) malloc(strlen(net_info->http_referer) + 12)))
return;
sprintf(referer, "Referer: %s\r\n", net_info->http_referer);
ConnNetInfo_ExtendUserHeader(net_info, referer);
free(referer);
}
/* Set HTTP user header */
static void x_SetupUserHeader (
SConnNetInfo* net_info,
const char* appName,
EMIME_Type type,
EMIME_SubType subtype,
EMIME_Encoding encoding
)
{
const char* userAgentName = NULL;
char user_header [MAX_CONTENT_TYPE_LEN + 80];
/* content-type if specified */
if (type < eMIME_T_Unknown) {
VERIFY( MIME_ComposeContentTypeEx (type, subtype, encoding,
user_header, MAX_CONTENT_TYPE_LEN) );
ConnNetInfo_OverrideUserHeader (net_info, user_header);
}
/* allow the user to specify a prog. name, otherwise get it from elsewhere */
if (StringHasNoText (appName)) {
const char* progName = GetProgramName();
if (StringHasNoText (progName)) {
char path [PATH_MAX];
Nlm_ProgramPath (path, sizeof (path));
userAgentName = StringRChr (path, DIRDELIMCHR);
if (userAgentName)
++userAgentName;
} else
userAgentName = progName;
} else
userAgentName = appName;
if (StringDoesHaveText (userAgentName)) {
sprintf (user_header, "User-Agent: %.80s\r\n", userAgentName);
ConnNetInfo_ExtendUserHeader (net_info, user_header);
}
}
/* Connect to the HTTP server, specified by uuu->net_info's "port:host".
* Return eIO_Success only if socket connection has succeeded and uuu->sock
* is non-zero. If unsuccessful, try to adjust uuu->net_info by s_Adjust(),
* and then re-try the connection attempt.
*/
static EIO_Status s_Connect(SHttpConnector* uuu,
EReadMode read_mode)
{
EIO_Status status;
assert(!uuu->sock);
if (uuu->can_connect == eCC_None) {
CORE_LOG_X(5, eLOG_Error, "[HTTP] Connector no longer usable");
return eIO_Closed;
}
/* the re-try loop... */
for (;;) {
int/*bool*/ reset_user_header = 0;
char* http_user_header = 0;
char* null = 0;
TSOCK_Flags flags;
uuu->w_len = BUF_Size(uuu->w_buf);
if (uuu->net_info->http_user_header)
http_user_header = strdup(uuu->net_info->http_user_header);
if (!uuu->net_info->http_user_header == !http_user_header) {
ConnNetInfo_ExtendUserHeader
(uuu->net_info, "User-Agent: NCBIHttpConnector"
#ifdef NCBI_CXX_TOOLKIT
" (C++ Toolkit)"
#else
" (C Toolkit)"
#endif
"\r\n");
reset_user_header = 1;
}
if (uuu->net_info->debug_printout)
ConnNetInfo_Log(uuu->net_info, CORE_GetLOG());
flags = (uuu->net_info->debug_printout == eDebugPrintout_Data
? fSOCK_LogOn : fSOCK_LogDefault);
if (uuu->net_info->scheme == eURL_Https)
flags |= fSOCK_Secure;
if (!(uuu->flags & fHCC_NoUpread))
flags |= fSOCK_ReadOnWrite;
/* connect & send HTTP header */
if ((status = URL_ConnectEx
(uuu->net_info->host, uuu->net_info->port,
uuu->net_info->path, uuu->net_info->args,
uuu->net_info->req_method, uuu->w_len,
uuu->o_timeout, uuu->w_timeout,
uuu->net_info->http_user_header,
(int/*bool*/)(uuu->flags & fHCC_UrlEncodeArgs),
flags, &uuu->sock)) != eIO_Success) {
uuu->sock = 0;
}
if (reset_user_header) {
ConnNetInfo_SetUserHeader(uuu->net_info, 0);
uuu->net_info->http_user_header = http_user_header;
}
if (uuu->sock)
break/*success*/;
/* connection failed, no socket was created */
if (!s_Adjust(uuu, &null, read_mode))
break/*closed*/;
}
return status;
}
static CONNECTOR s_Open(SServiceConnector* uuu,
const STimeout* timeout,
const SSERV_Info* info,
SConnNetInfo* net_info,
int/*bool*/ second_try)
{
int/*bool*/ but_last = 0/*false*/;
const char* user_header; /* either "" or non-empty dynamic string */
char* iter_header;
EReqMethod req_method;
if (info && info->type != fSERV_Firewall) {
/* Not a firewall/relay connection here */
assert(!second_try);
/* We know the connection point, let's try to use it! */
if (info->type != fSERV_Standalone || !net_info->stateless) {
SOCK_ntoa(info->host, net_info->host, sizeof(net_info->host));
net_info->port = info->port;
}
switch (info->type) {
case fSERV_Ncbid:
/* Connection directly to NCBID, add NCBID-specific tags */
if (net_info->stateless) {
/* Connection request with data */
user_header = "Connection-Mode: STATELESS\r\n"; /*default*/
req_method = eReqMethod_Post;
} else {
/* We will be waiting for conn-info back */
user_header = "Connection-Mode: STATEFUL\r\n";
req_method = eReqMethod_Get;
}
user_header = s_AdjustNetParams(uuu->service, net_info, req_method,
NCBID_WEBPATH,
SERV_NCBID_ARGS(&info->u.ncbid),
0, user_header, info->mime_t,
info->mime_s, info->mime_e, 0);
break;
case fSERV_Http:
case fSERV_HttpGet:
case fSERV_HttpPost:
/* Connection directly to CGI */
req_method = info->type == fSERV_HttpGet
? eReqMethod_Get : (info->type == fSERV_HttpPost
? eReqMethod_Post : eReqMethod_Any);
user_header = "Client-Mode: STATELESS_ONLY\r\n"; /*default*/
user_header = s_AdjustNetParams(uuu->service, net_info, req_method,
SERV_HTTP_PATH(&info->u.http),
SERV_HTTP_ARGS(&info->u.http),
0, user_header, info->mime_t,
info->mime_s, info->mime_e, 0);
break;
case fSERV_Standalone:
if (!net_info->stateless)
return s_CreateSocketConnector(net_info, 0, 0);
/* Otherwise, it will be a pass-thru connection via dispatcher */
user_header = "Client-Mode: STATELESS_ONLY\r\n"; /*default*/
user_header = s_AdjustNetParams(uuu->service, net_info,
eReqMethod_Post, 0, 0,
0, user_header, info->mime_t,
info->mime_s, info->mime_e, 0);
but_last = 1/*true*/;
break;
default:
user_header = 0;
break;
}
} else {
EMIME_Type mime_t;
EMIME_SubType mime_s;
EMIME_Encoding mime_e;
if (net_info->stateless ||
(info && (info->u.firewall.type & fSERV_Http))) {
if (info) {
req_method = info->u.firewall.type == fSERV_HttpGet
? eReqMethod_Get : (info->u.firewall.type == fSERV_HttpPost
? eReqMethod_Post : eReqMethod_Any);
net_info->stateless = 1/*true*/;
} else
req_method = eReqMethod_Any;
} else
req_method = eReqMethod_Get;
if (info) {
mime_t = info->mime_t;
mime_s = info->mime_s;
mime_e = info->mime_e;
} else {
mime_t = eMIME_T_Undefined;
mime_s = eMIME_Undefined;
mime_e = eENCOD_None;
}
/* Firewall/relay connection to dispatcher, special tags */
user_header = net_info->stateless
? "Client-Mode: STATELESS_ONLY\r\n" /*default*/
: "Client-Mode: STATEFUL_CAPABLE\r\n";
user_header = s_AdjustNetParams(uuu->service, net_info, req_method,
0, 0, 0, user_header,
mime_t, mime_s, mime_e, 0);
}
if (!user_header)
return 0;
if ((iter_header = SERV_Print(uuu->iter, net_info, but_last)) != 0) {
size_t uh_len;
if ((uh_len = strlen(user_header)) > 0) {
char* ih;
size_t ih_len = strlen(iter_header);
if ((ih = (char*) realloc(iter_header, ih_len + uh_len + 1)) != 0){
strcpy(ih + ih_len, user_header);
iter_header = ih;
}
free((char*) user_header);
}
user_header = iter_header;
} else if (!*user_header)
user_header = 0; /* special case of assignment of literal "" */
if (uuu->user_header) {
ConnNetInfo_DeleteUserHeader(net_info, uuu->user_header);
free((void*) uuu->user_header);
}
uuu->user_header = user_header;
if (user_header && !ConnNetInfo_OverrideUserHeader(net_info, user_header))
return 0;
if (!second_try) {
ConnNetInfo_ExtendUserHeader
(net_info, "User-Agent: NCBIServiceConnector/"
DISP_PROTOCOL_VERSION
#ifdef NCBI_CXX_TOOLKIT
" (C++ Toolkit)"
#else
" (C Toolkit)"
#endif
"\r\n");
}
if (!net_info->stateless && (!info ||
info->type == fSERV_Firewall ||
info->type == fSERV_Ncbid)) {
/* Auxiliary HTTP connector first */
EIO_Status status = eIO_Success;
CONNECTOR c;
CONN conn;
/* Clear connection info */
uuu->host = 0;
uuu->port = 0;
uuu->ticket = 0;
net_info->max_try = 1;
c = HTTP_CreateConnectorEx(net_info,
(uuu->params.flags & fHCC_Flushable)
| fHCC_SureFlush/*flags*/,
s_ParseHeader, 0/*adj.info*/,
uuu/*adj.data*/, 0/*cleanup.data*/);
/* Wait for connection info back (error-transparent by DISPD.CGI) */
if (c && (status = CONN_Create(c, &conn)) == eIO_Success) {
CONN_SetTimeout(conn, eIO_Open, timeout);
CONN_SetTimeout(conn, eIO_ReadWrite, timeout);
CONN_SetTimeout(conn, eIO_Close, timeout);
CONN_Flush(conn);
/* This also triggers parse header callback */
CONN_Close(conn);
} else {
const char* error = c ? IO_StatusStr(status) : 0;
CORE_LOGF_X(4, eLOG_Error,
("[%s] Unable to create auxiliary HTTP %s%s%s",
uuu->service, c ? "connection" : "connector",
error && *error ? ": " : "", error ? error : ""));
assert(0);
}
if (!uuu->host)
return 0/*failed, no connection info returned*/;
if (uuu->host == (unsigned int)(-1)) {
/* Firewall mode only in stateful mode, fallback requested */
assert((!info || info->type == fSERV_Firewall) && !second_try);
/* Try to use stateless mode instead */
net_info->stateless = 1/*true*/;
return s_Open(uuu, timeout, info, net_info, 1/*second try*/);
}
SOCK_ntoa(uuu->host, net_info->host, sizeof(net_info->host));
net_info->port = uuu->port;
return s_CreateSocketConnector(net_info, &uuu->ticket,
uuu->ticket ? sizeof(uuu->ticket) : 0);
}
return HTTP_CreateConnectorEx(net_info,
(uuu->params.flags
& (fHCC_Flushable | fHCC_NoAutoRetry))
| fHCC_AutoReconnect,
s_ParseHeader, s_AdjustNetInfo,
uuu/*adj.data*/, 0/*cleanup.data*/);
}
static void TEST_ConnNetInfo(void)
{
size_t n;
char* str;
char buf[80];
SConnNetInfo* net_info;
CORE_LOG(eLOG_Note, "ConnNetInfo test started");
net_info = ConnNetInfo_Create(0);
assert(net_info);
assert(ConnNetInfo_ParseURL(net_info,
"ftp://*****:*****@host:8888/ro.t/p@th"
"?arg/arg:arg@arg:arg/arg"));
assert(net_info->scheme == eURL_Ftp);
assert(strcmp(net_info->user, "user") == 0);
assert(strcmp(net_info->pass, "pass") == 0);
assert(strcmp(net_info->host, "host") == 0);
assert( net_info->port == 8888);
assert(strcmp(net_info->path, "/ro.t/p@th") == 0);
assert(strcmp(net_info->args, "arg/arg:arg@arg:arg/arg") == 0);
assert(ConnNetInfo_ParseURL(net_info, "https://www/path"
"?arg:arg@arg#frag"));
assert( net_info->scheme == eURL_Https);
assert( *net_info->user == 0);
assert( *net_info->pass == 0);
assert(strcmp(net_info->host, "www") == 0);
assert( net_info->port == 0);
assert(strcmp(net_info->path, "/path") == 0);
assert(strcmp(net_info->args, "arg:arg@arg#frag") == 0);
assert(ConnNetInfo_ParseURL(net_info, "/path1?arg1#frag2"));
assert(strcmp(net_info->args, "arg1#frag2") == 0);
assert(ConnNetInfo_ParseURL(net_info, "path0/0"));
assert(strcmp(net_info->path, "/path0/0") == 0);
assert(strcmp(net_info->args, "#frag2") == 0);
assert(ConnNetInfo_ParseURL(net_info, "#frag3"));
assert(strcmp(net_info->path, "/path0/0") == 0);
assert(strcmp(net_info->args, "#frag3") == 0);
assert(ConnNetInfo_ParseURL(net_info, "path2"));
assert(strcmp(net_info->path, "/path0/path2") == 0);
assert(strcmp(net_info->args, "#frag3") == 0);
assert(ConnNetInfo_ParseURL(net_info, "/path3?arg3"));
assert(strcmp(net_info->path, "/path3") == 0);
assert(strcmp(net_info->args, "arg3#frag3") == 0);
strcpy(net_info->user, "user");
strcpy(net_info->pass, "pass");
str = ConnNetInfo_URL(net_info);
assert(str);
assert(strcmp(str, "https://www/path3?arg3#frag3") == 0);
free(str);
assert(ConnNetInfo_ParseURL(net_info, "path4/path5?arg4#"));
assert(strcmp(net_info->user, "user") == 0);
assert(strcmp(net_info->pass, "pass") == 0);
assert(strcmp(net_info->path, "/path4/path5") == 0);
assert(strcmp(net_info->args, "arg4") == 0);
assert(ConnNetInfo_ParseURL(net_info, "../path6"));
assert(strcmp(net_info->path, "/path4/../path6") == 0);
assert(strcmp(net_info->args, "") == 0);
ConnNetInfo_SetUserHeader(net_info, "");
str = UTIL_PrintableString(net_info->http_user_header, 0, buf, 0);
printf("HTTP User Header after set:\n%s%s%s\n",
"\"" + !str, str ? buf : "NULL", "\"" + !str);
assert(!net_info->http_user_header && !str);
ConnNetInfo_AppendUserHeader(net_info,
"T0: V0\n"
"T1:V1\r\n"
"T2: V2\r\n"
"T3: V3\n"
"T4: V4\n"
"T1: V6");
str = UTIL_PrintableString(net_info->http_user_header, 0, buf, 0);
if (str)
*str = '\0';
printf("HTTP User Header after append:\n%s%s%s\n",
"\"" + !str, str ? buf : "NULL", "\"" + !str);
assert(strcmp(net_info->http_user_header,
"T0: V0\n"
"T1:V1\r\n"
"T2: V2\r\n"
"T3: V3\n"
"T4: V4\n"
"T1: V6\r\n") == 0);
ConnNetInfo_OverrideUserHeader(net_info,
"T0\r\n"
"T5: V5\n"
"T1: \t \r\n"
"T2:V2.1\r\n"
"T3:V3\r\n"
"T4: W4");
str = UTIL_PrintableString(net_info->http_user_header, 0, buf, 0);
if (str)
*str = '\0';
printf("HTTP User Header after override:\n%s%s%s\n",
"\"" + !str, str ? buf : "NULL", "\"" + !str);
assert(strcmp(net_info->http_user_header,
"T0: V0\n"
"T2:V2.1\r\n"
"T3:V3\n"
"T4: W4\r\n"
"T5: V5\r\n") == 0);
ConnNetInfo_ExtendUserHeader(net_info,
"T0: V0\n"
"T1:V1\r\n"
"T2:V2\n"
"T3: T3:V3\n"
"T4:\n"
"T5");
str = UTIL_PrintableString(net_info->http_user_header, 0, buf, 0);
if (str)
*str = '\0';
printf("HTTP User Header after extend:\n%s%s%s\n",
"\"" + !str, str ? buf : "NULL", "\"" + !str);
assert(strcmp(net_info->http_user_header,
"T0: V0\n"
"T2:V2.1 V2\r\n"
"T3:V3 T3:V3\n"
"T4: W4\r\n"
"T5: V5\r\n"
"T1:V1\r\n") == 0);
ConnNetInfo_SetUserHeader(net_info, 0);
str = UTIL_PrintableString(net_info->http_user_header, 0, buf, 0);
if (str)
*str = '\0';
printf("HTTP User Header after reset:\n%s%s%s\n",
"\"" + !str, str ? buf : "NULL", "\"" + !str);
assert(!net_info->http_user_header);
for (n = 0; n < sizeof(net_info->args); n++)
net_info->args[n] = "0123456789"[rand() % 10];
strncpy0(net_info->args, "a=b&b=c&c=d", sizeof(net_info->args) - 1);
printf("HTTP Arg: \"%s\"\n", net_info->args);
ConnNetInfo_PrependArg(net_info, "d=e", 0);
ConnNetInfo_PrependArg(net_info, "e", "f");
printf("HTTP Arg after prepend: \"%s\"\n", net_info->args);
ConnNetInfo_AppendArg(net_info, "f=g", 0);
ConnNetInfo_AppendArg(net_info, "g", "h");
printf("HTTP Arg after append: \"%s\"\n", net_info->args);
ConnNetInfo_PreOverrideArg(net_info, "a=z&b", "y");
ConnNetInfo_PreOverrideArg(net_info, "c", "x");
printf("HTTP Arg after pre-override: \"%s\"\n", net_info->args);
ConnNetInfo_PostOverrideArg(net_info, "d=w&e", "v");
ConnNetInfo_PostOverrideArg(net_info, "f", "u");
printf("HTTP Arg after post-override: \"%s\"\n", net_info->args);
ConnNetInfo_DeleteArg(net_info, "g");
ConnNetInfo_DeleteArg(net_info, "h=n");
printf("HTTP Arg after delete: \"%s\"\n", net_info->args);
ConnNetInfo_DeleteAllArgs(net_info, "a=b&p=q&f=d");
printf("HTTP Arg after delete-all: \"%s\"\n", net_info->args);
ConnNetInfo_LogEx(net_info, eLOG_Note, CORE_GetLOG());
ConnNetInfo_Destroy(net_info);
CORE_LOG(eLOG_Note, "ConnNetInfo test completed");
}
