string CSocketAPI::ntoa(unsigned int host)
{
char addr[40];
if (SOCK_ntoa(host, addr, sizeof(addr)) != 0)
*addr = 0;
return string(addr);
}
/*ARGSUSED*/
static const SLBSM_Sysinfo* s_GetSysinfo(const HOST_INFO hinfo,
int/*bool*/ warn)
{
const SLBSM_Sysinfo* si =
(const SLBSM_Sysinfo*)((const char*) hinfo + sizeof(*hinfo));
assert(hinfo);
#if defined(_DEBUG) && !defined(NDEBUG) && defined(NETDAEMONS_VERSION_INT)
if (si->data.version < NETDAEMONS_VERSION_INT && warn) {
static int s_Warn = 0;
if (s_Warn < 20) {
char addr[64];
if (SOCK_ntoa(hinfo->addr, addr, sizeof(addr)) != 0)
strncpy0(addr, "unknown", sizeof(addr) - 1);
CORE_LOGF(s_Warn++ < 5 ? eLOG_Warning : eLOG_Trace,
("HINFO may be incorrect for obsolete daemon on %s"
" (detected=%hu.%hu.%hu, expected=%s+)", addr,
NETDAEMONS_MAJOR_OF(si->data.version),
NETDAEMONS_MINOR_OF(si->data.version),
NETDAEMONS_PATCH_OF(si->data.version),
NETDAEMONS_VERSION_STR));
}
}
#endif /*_DEBUG && !NDEBUG && NETDAEMONS_VERSION_INT*/
return si;
}
static const char* s_ntoa(unsigned int host)
{
static char buf[256];
if (SOCK_ntoa(host, buf, sizeof(buf)) != 0) {
buf[0] = '?';
buf[1] = '\0';
}
return buf;
}
EIO_Status CDatagramSocket::Connect(unsigned int host,
unsigned short port)
{
char addr[40];
if (host && SOCK_ntoa(host, addr, sizeof(addr)) != 0)
return eIO_Unknown;
return m_Socket
? DSOCK_Connect(m_Socket, host ? addr : 0, port)
: eIO_Closed;
}
CSocket::CSocket(unsigned int host,
unsigned short port,
const STimeout* timeout,
TSOCK_Flags flags)
: m_IsOwned(eTakeOwnership),
r_timeout(0), w_timeout(0), c_timeout(0)
{
char x_host[16/*sizeof("255.255.255.255")*/];
if (timeout && timeout != kDefaultTimeout) {
oo_timeout = *timeout;
o_timeout = &oo_timeout;
} else
o_timeout = 0;
if (SOCK_ntoa(host, x_host, sizeof(x_host)) != 0)
m_Socket = 0;
else
SOCK_CreateEx(x_host, port, o_timeout, &m_Socket, 0, 0, flags);
}
static const SLBSM_Host* s_LookupHost(HEAP heap, const SERV_ITER iter,
const SLBSM_Service* svc)
{
unsigned int addr =
svc->info.host ? svc->info.host : s_GetLocalHostAddress(heap);
const SLBSM_Host* host = LBSM_LookupHost(heap, addr, &svc->entry);
if (!host || host->entry.good < iter->time) {
if (svc->info.rate > 0.0) {
char buf[40];
if (SOCK_ntoa(addr, buf, sizeof(buf)) != 0)
strcpy(buf, "(unknown)");
CORE_LOGF_X(8, eLOG_Error,
("Dynamic %s server `%s' on [%s] w/%s host entry",
SERV_TypeStr(svc->info.type),
(const char*) svc + svc->name,
buf, host ? "outdated" : "o"));
}
return 0;
}
return host;
}
static CONNECTOR s_Init
(SOCK sock,
const char* host,
unsigned short port,
unsigned short try_own,
const void* init_data,
size_t init_size,
TSOCK_Flags flags)
{
CONNECTOR ccc;
SSockConnector* xxx;
/* some sanity checks */
assert(!sock || !(init_size || init_data || flags));
assert(!init_size || init_data);
if (!(ccc = (SConnector*) malloc(sizeof(SConnector))))
return 0;
if (!(xxx = (SSockConnector*) malloc(sizeof(*xxx)
+ (init_data ? init_size : 0)
+ (host
? strlen(host) + 1
: MAX_IP_ADDR_LEN)))) {
free(ccc);
return 0;
}
/* initialize internal data structures */
if (sock || !host || !port) {
xxx->sock = sock;
xxx->init_size = 0;
xxx->init_data = 0;
if (host) {
xxx->host = strcpy((char*) xxx + sizeof(*xxx), host);
xxx->port = 0;
} else if (sock) {
unsigned int x_host;
char* addr = (char*) xxx + sizeof(*xxx);
SOCK_GetPeerAddress(sock, &x_host, &xxx->port, eNH_HostByteOrder);
SOCK_ntoa(SOCK_HostToNetLong(x_host), addr, MAX_IP_ADDR_LEN);
xxx->host = addr;
assert(xxx->port);
} else {
/* this signifies invalid state */
xxx->host = 0;
xxx->port = 0;
}
xxx->try_own = try_own ? 1 : 0;
} else {
void* data = (char*) xxx + sizeof(*xxx);
xxx->sock = 0;
xxx->init_size = init_data ? init_size : 0;
xxx->init_data = memcpy(data, init_data, xxx->init_size);
xxx->host = strcpy((char*) data + xxx->init_size, host);
xxx->port = port;
xxx->try_own = try_own ? try_own : 1;
xxx->flags = flags;
}
/* initialize connector data */
ccc->handle = xxx;
ccc->next = 0;
ccc->meta = 0;
ccc->setup = s_Setup;
ccc->destroy = s_Destroy;
return ccc;
}
static int run_a_test(size_t test_idx, int live, const char *svc,
const char *hdr, int check_for_match, int exp_err,
const char *mock_body_in, int repop, int reset)
{
const SSERV_Info *info = NULL;
SConnNetInfo *net_info;
SERV_ITER iter;
const char *mock_body = NULL;
char *mock_body_adj = NULL;
int n_matches_perfect = 0, n_matches_near = 0;
int success = 0, errors = 0;
int retval = -1;
s_n_hits_got = 0;
/* Adjust mock data for current time, if necessary. */
adjust_mock_times(mock_body_in, &mock_body_adj);
mock_body = mock_body_adj ? mock_body_adj : mock_body_in;
/* Select the HTTP data source (live or mock). */
s_results[test_idx].live = live;
if ( ! s_results[test_idx].live &&
( ! mock_body || ! *mock_body))
{
CORE_TRACE("Mock HTTP data source unavailable.");
s_results[test_idx].live = 1;
}
if (s_results[test_idx].live) {
CORE_TRACE("Using a live HTTP data source.");
SERV_NAMERD_SetConnectorSource(NULL); /* use live HTTP */
} else {
CORE_TRACE("Using a mock HTTP data source.");
if ( ! SERV_NAMERD_SetConnectorSource(mock_body)) {
CORE_LOG(eLOG_Error, "Unable to create mock HTTP data source.");
retval = 1;
goto out;
}
}
/* Set up the server iterator. */
net_info = ConnNetInfo_Create(svc);
if (*hdr) ConnNetInfo_SetUserHeader(net_info, hdr);
iter = SERV_OpenP(svc, fSERV_All |
(strpbrk(svc, "?*") ? fSERV_Promiscuous : 0),
SERV_LOCALHOST, 0/*port*/, 0.0/*preference*/,
net_info, 0/*skip*/, 0/*n_skip*/,
0/*external*/, 0/*arg*/, 0/*val*/);
ConnNetInfo_Destroy(net_info);
/* Fetch the server hits from namerd. */
if (iter) {
for (; s_n_hits_got < MAX_HITS && (info = SERV_GetNextInfo(iter));
++s_n_hits_got)
{
if (info->type & fSERV_Http) {
CORE_LOGF(eLOG_Note, (" HTTP extra (path): %s",
SERV_HTTP_PATH(&info->u.http)));
}
strcpy(s_hits_got[s_n_hits_got].type, SERV_TypeStr(info->type));
strcpy(s_hits_got[s_n_hits_got].xtra,
(info->type & fSERV_Http) ? SERV_HTTP_PATH(&info->u.http) : "");
strcpy(s_hits_got[s_n_hits_got].loc ,
(info->site & fSERV_Local ) ? "yes" : "no");
strcpy(s_hits_got[s_n_hits_got].priv,
(info->site & fSERV_Private ) ? "yes" : "no");
strcpy(s_hits_got[s_n_hits_got].stfl,
(info->mode & fSERV_Stateful) ? "yes" : "no");
SOCK_ntoa(info->host, s_hits_got[s_n_hits_got].host, LEN_HOST);
s_hits_got[s_n_hits_got].port = info->port;
s_hits_got[s_n_hits_got].match = 0;
char *info_str;
info_str = SERV_WriteInfo(info);
CORE_LOGF(eLOG_Note, (" Found server %d: %s",
s_n_hits_got, info_str ? info_str : "?"));
if (info_str)
free(info_str);
}
/* Make sure endpoint data can be repopulated and reset. */
if (repop && s_n_hits_got) {
/* repopulate */
CORE_LOG(eLOG_Trace, "Repopulating the service mapper.");
if ( ! info && ! SERV_GetNextInfo(iter)) {
CORE_LOG(eLOG_Error, "Unable to repopulate endpoint data.");
errors = 1;
}
}
if (reset && s_n_hits_got) {
/* reset */
CORE_LOG(eLOG_Trace, "Resetting the service mapper.");
SERV_Reset(iter);
if ( ! SERV_GetNextInfo(iter)) {
CORE_LOG(eLOG_Error, "No services found after reset.");
errors = 1;
}
}
SERV_Close(iter);
} else {
errors = 1;
}
/* Search for matches unless this is a standalone run. */
if (check_for_match) {
/* Search for perfect matches first (order is unknown). */
int it_exp, it_got;
for (it_got=0; it_got < s_n_hits_got; ++it_got) {
for (it_exp=0; it_exp < s_n_hits_exp; ++it_exp) {
if (s_hits_exp[it_exp].match) continue;
/*if (check_match(fMatch_Default, it_exp, it_got)) {*/
if (check_match(fMatch_All, it_exp, it_got)) {
CORE_LOGF(eLOG_Note, (
" Found server %d perfectly matched expected server "
"%d.", it_got, it_exp));
s_hits_exp[it_exp].match = 1;
s_hits_got[it_got].match = 1;
++n_matches_perfect;
break;
}
}
}
/* If not all found, search again but exclude host:port from match. */
for (it_got=0; it_got < s_n_hits_got; ++it_got) {
if (s_hits_got[it_got].match) continue;
for (it_exp=0; it_exp < s_n_hits_exp; ++it_exp) {
if (s_hits_exp[it_exp].match) continue;
if (check_match(fMatch_NoHostPort, it_exp, it_got)) {
CORE_LOGF(eLOG_Note, (
" Found server %d nearly matched expected server %d.",
it_got, it_exp));
s_hits_exp[it_exp].match = 1;
s_hits_got[it_got].match = 1;
++n_matches_near;
log_match_diffs(it_exp, it_got);
break;
}
}
}
/* List any non-matching servers. */
for (it_exp=0; it_exp < s_n_hits_exp; ++it_exp) {
if ( ! s_hits_exp[it_exp].match)
CORE_LOGF(eLOG_Note, (
" Expected server %d didn't match any found servers.",
it_exp));
}
for (it_got=0; it_got < s_n_hits_got; ++it_got) {
if ( ! s_hits_got[it_got].match)
CORE_LOGF(eLOG_Note, (
" Found server %d didn't match any expected servers.",
it_got));
}
CORE_LOGF(n_matches_perfect + n_matches_near == s_n_hits_got ?
eLOG_Note : eLOG_Error,
("Expected %d servers; found %d (%d perfect matches, %d near "
"matches, and %d non-matches).",
s_n_hits_exp, s_n_hits_got, n_matches_perfect, n_matches_near,
s_n_hits_got - n_matches_perfect - n_matches_near));
if (!errors &&
s_n_hits_got == s_n_hits_exp &&
s_n_hits_got == n_matches_perfect + n_matches_near)
{
success = 1;
}
retval = (success != exp_err ? 1 : 0);
CORE_LOGF(eLOG_Note, ("Test result: %s.",
retval ?
(success ? "PASS" : "PASS (with expected error)") :
(success ? "FAIL (success when error expected)" : "FAIL")));
}
out:
if (mock_body_adj)
free(mock_body_adj);
return retval == -1 ? (success != exp_err ? 1 : 0) : retval;
}
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*/);
}
/* This callback is only for services called via direct HTTP */
static int/*bool*/ s_AdjustNetInfo(SConnNetInfo* net_info,
void* data,
unsigned int n)
{
SServiceConnector* uuu = (SServiceConnector*) data;
const char* user_header;
const SSERV_Info* info;
assert(n != 0); /* paranoid assertion :-) */
if (uuu->net_info->firewall && !uuu->net_info->stateless)
return 0; /*cannot adjust firewall stateful client*/
for (;;) {
if (!(info = s_GetNextInfo(uuu)))
return 0/*false - not adjusted*/;
/* Skip any 'stateful_capable' or unconnectable entries here,
* which might have left behind by either a failed stateful
* dispatching with a fallback to stateless HTTP mode or
* a too relaxed server type selection */
if (!info->sful && info->type != fSERV_Dns)
break;
}
{{
char* iter_header = SERV_Print(uuu->iter, 0, 0);
switch (info->type) {
case fSERV_Ncbid:
user_header = "Connection-Mode: STATELESS\r\n"; /*default*/
user_header = s_AdjustNetParams(uuu->service, net_info,
eReqMethod_Post,
NCBID_WEBPATH,
SERV_NCBID_ARGS(&info->u.ncbid),
uuu->net_info->args,
user_header, info->mime_t,
info->mime_s, info->mime_e,
iter_header);
break;
case fSERV_Http:
case fSERV_HttpGet:
case fSERV_HttpPost:
user_header = "Client-Mode: STATELESS_ONLY\r\n"; /*default*/
user_header = s_AdjustNetParams(uuu->service, net_info,
info->type == fSERV_HttpGet
? eReqMethod_Get
: (info->type == fSERV_HttpPost
? eReqMethod_Post
: eReqMethod_Any),
SERV_HTTP_PATH(&info->u.http),
SERV_HTTP_ARGS(&info->u.http),
uuu->net_info->args,
user_header, info->mime_t,
info->mime_s, info->mime_e,
iter_header);
break;
case fSERV_Standalone:
case fSERV_Firewall:
user_header = "Client-Mode: STATELESS_ONLY\r\n"; /*default*/
user_header = s_AdjustNetParams(uuu->service, net_info,
eReqMethod_Post,
uuu->net_info->path, 0,
uuu->net_info->args,
user_header, info->mime_t,
info->mime_s, info->mime_e,
iter_header);
break;
default:
if (iter_header)
free(iter_header);
user_header = 0;
break;
}
}}
if (!user_header)
return 0/*false - not adjusted*/;
if (uuu->user_header) {
assert(*uuu->user_header);
ConnNetInfo_DeleteUserHeader(net_info, uuu->user_header);
free((void*) uuu->user_header);
}
if (*user_header) {
uuu->user_header = user_header;
if (!ConnNetInfo_OverrideUserHeader(net_info, user_header))
return 0/*false - not adjusted*/;
} else
uuu->user_header = 0;
if (info->type == fSERV_Ncbid || (info->type & fSERV_Http)) {
SOCK_ntoa(info->host, net_info->host, sizeof(net_info->host));
net_info->port = info->port;
} else {
strcpy(net_info->host, uuu->net_info->host);
net_info->port = uuu->net_info->port;
}
return 1/*true - adjusted*/;
}
