static SSERV_Info* s_GetInfo(const char* service,
TSERV_Type types,
unsigned int preferred_host,
unsigned short preferred_port,
double preference,
const SConnNetInfo* net_info,
const SSERV_InfoCPtr skip[],
size_t n_skip,
int /*bool*/ external,
const char* arg,
const char* val,
HOST_INFO* host_info)
{
SSERV_Info* info = 0;
SERV_ITER iter = s_Open(service, 0/*not mask*/, types,
preferred_host, preferred_port, preference,
net_info, skip, n_skip,
external, arg, val,
&info, host_info);
if (iter && iter->op && !info) {
/* All LOCAL/DISPD searches end up here, but none LBSMD ones */
info = s_GetNextInfo(iter, host_info, 1/*internal*/);
}
SERV_Close(iter);
return info;
}
SERV_ITER SERV_Open(const char* service,
TSERV_Type types,
unsigned int preferred_host,
const SConnNetInfo* net_info)
{
return s_Open(service, 0/*not mask*/, types,
preferred_host, 0/*preferred_port*/, 0.0/*preference*/,
net_info, 0/*skip*/, 0/*n_skip*/,
0/*not external*/, 0/*arg*/, 0/*val*/,
0/*info*/, 0/*host_info*/);
}
SERV_ITER SERV_OpenP(const char* service,
TSERV_Type types,
unsigned int preferred_host,
unsigned short preferred_port,
double preference,
const SConnNetInfo* net_info,
const SSERV_InfoCPtr skip[],
size_t n_skip,
int/*bool*/ external,
const char* arg,
const char* val)
{
return s_Open(service,
service && (!*service || strpbrk(service, "?*")), types,
preferred_host, preferred_port, preference,
net_info, skip, n_skip,
external, arg, val,
0/*info*/, 0/*host_info*/);
}
static EIO_Status s_VT_Open(CONNECTOR connector, const STimeout* timeout)
{
SServiceConnector* uuu = (SServiceConnector*) connector->handle;
SMetaConnector* meta = connector->meta;
EIO_Status status;
for (;;) {
const SSERV_Info* info;
SConnNetInfo* net_info;
CONNECTOR conn;
int stateless;
assert(!uuu->meta.list && !uuu->name && !uuu->descr);
if (!uuu->iter && !s_OpenDispatcher(uuu)) {
status = eIO_Closed;
break;
}
if (uuu->net_info->firewall && strcasecmp(uuu->iter->name, "local"))
info = 0;
else if (!(info = s_GetNextInfo(uuu))) {
status = eIO_Closed;
break;
}
if (!(net_info = ConnNetInfo_Clone(uuu->net_info))) {
status = eIO_Unknown;
break;
}
net_info->scheme = eURL_Unspec;
conn = s_Open(uuu, timeout, info, net_info, 0/*!second_try*/);
if (conn)
uuu->descr = ConnNetInfo_URL(net_info);
stateless = net_info->stateless;
ConnNetInfo_Destroy(net_info);
if (!conn) {
if (!info) {
status = eIO_Closed;
break;
}
continue;
}
/* Setup the new connector on a temporary meta-connector... */
memset(&uuu->meta, 0, sizeof(uuu->meta));
METACONN_Add(&uuu->meta, conn);
/* ...then link it in using current connection's meta */
conn->meta = meta;
conn->next = meta->list;
meta->list = conn;
if (!uuu->descr && uuu->meta.descr)
CONN_SET_METHOD(meta, descr, uuu->meta.descr, uuu->meta.c_descr);
CONN_SET_METHOD (meta, wait, uuu->meta.wait, uuu->meta.c_wait);
CONN_SET_METHOD (meta, write, uuu->meta.write, uuu->meta.c_write);
CONN_SET_METHOD (meta, flush, uuu->meta.flush, uuu->meta.c_flush);
CONN_SET_METHOD (meta, read, uuu->meta.read, uuu->meta.c_read);
CONN_SET_METHOD (meta, status,uuu->meta.status,uuu->meta.c_status);
if (uuu->meta.get_type) {
const char* type;
if ((type = uuu->meta.get_type(uuu->meta.c_get_type)) != 0) {
size_t slen = strlen(uuu->service);
size_t tlen = strlen(type);
char* name = (char*) malloc(slen + tlen + 2);
if (name) {
memcpy(name, uuu->service, slen);
name[slen++] = '/';
memcpy(name + slen, type, tlen);
tlen += slen;
name[tlen] = '\0';
uuu->name = name;
}
}
}
status = uuu->meta.open
? uuu->meta.open(uuu->meta.c_open, timeout) : eIO_Success;
if (status == eIO_Success)
break;
if (!stateless && (!info || info->type == fSERV_Firewall)) {
static const char kFWLink[] = { "http://www.ncbi.nlm.nih.gov"
"/IEB/ToolBox/NETWORK"
"/dispatcher.html#Firewalling"};
CORE_LOGF_X(6, eLOG_Error,
("[%s] %s connection failed (%s) indicating possible "
"firewall configuration problem; please consult <%s>",
uuu->service, !info ? "Firewall" : "Stateful relay",
IO_StatusStr(status), kFWLink));
}
s_Close(connector, timeout, 0/*don't close dispatcher just as yet*/);
}
uuu->status = status;
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*/);
}