/* Try SOCK_htonl(), SOCK_gethostbyname() and SOCK_gethostbyaddr()
*/
static void TEST_gethostby(void)
{
CORE_LOG(eLOG_Note, "===============================");
assert( SOCK_HostToNetLong(0) == 0 );
assert( SOCK_HostToNetLong(0xFFFFFFFF) == 0xFFFFFFFF );
assert( !TEST_gethostbyname(" ") );
assert( !TEST_gethostbyname("a1....b1") );
assert( !TEST_gethostbyname("boo.foo.bar.doo") );
(void) TEST_gethostbyname("localhost");
(void) TEST_gethostbyname("ncbi.nlm.nih.gov");
(void) TEST_gethostbyname("127.0.0.1");
(void) TEST_gethostbyname("130.14.25.1");
(void) TEST_gethostbyaddr(0);
(void) TEST_gethostbyaddr(SOCK_gethostbyname("127.0.0.1"));
(void) TEST_gethostbyaddr(SOCK_gethostbyname("130.14.25.1"));
(void) TEST_gethostbyaddr(SOCK_gethostbyname("234.234.234.234"));
(void) TEST_gethostbyaddr(0xFFFFFFFF);
CORE_LOG(eLOG_Note, "===============================");
}
static int/*bool*/ TEST_gethostbyaddr(unsigned int host)
{
const char* name;
char buf[1024];
CORE_LOG(eLOG_Note, "------------");
name = SOCK_gethostbyaddr(host, buf, sizeof(buf));
if ( name ) {
assert(name == buf);
assert(0 < strlen(buf) && strlen(buf) < sizeof(buf));
CORE_LOGF(eLOG_Note,
("SOCK_gethostbyaddr(0x%08X [%s]): \"%s\"",
(unsigned int) SOCK_NetToHostLong(host),
s_ntoa(host), name));
} else {
CORE_LOGF(eLOG_Note,
("SOCK_gethostbyaddr(0x%08X [%s]): <not found>",
(unsigned int) SOCK_NetToHostLong(host), s_ntoa(host)));
return 0/*false*/;
}
host = SOCK_gethostbyname(name);
CORE_LOGF(eLOG_Note,
("SOCK_gethostbyname(\"%s\"): 0x%08X [%s]",
name, (unsigned int) SOCK_NetToHostLong(host), s_ntoa(host)));
return 1/*true*/;
}
static unsigned int TEST_gethostbyname(const char* name)
{
char buf[256];
unsigned int host;
CORE_LOG(eLOG_Note, "------------");
host = SOCK_gethostbyname(name);
CORE_LOGF(eLOG_Note,
("SOCK_gethostbyname(\"%s\"): 0x%08X [%s]",
name, (unsigned int) SOCK_NetToHostLong(host), s_ntoa(host)));
if ( host ) {
name = SOCK_gethostbyaddr(host, buf, sizeof(buf));
if ( name ) {
assert(name == buf);
assert(0 < strlen(buf) && strlen(buf) < sizeof(buf));
CORE_LOGF(eLOG_Note,
("SOCK_gethostbyaddr(0x%08X [%s]): \"%s\"",
(unsigned int) SOCK_NetToHostLong(host), s_ntoa(host),
name));
} else {
CORE_LOGF(eLOG_Note,
("SOCK_gethostbyaddr(0x%08X [%s]): <not found>",
(unsigned int) SOCK_NetToHostLong(host), s_ntoa(host)));
}
}
return host;
}
static int/*bool*/ s_ParseHeader(const char* header,
void* data,
int server_error)
{
static const char kStateless[] = "TRY_STATELESS";
static const size_t klen = sizeof(kStateless) - 1;
SServiceConnector* uuu = (SServiceConnector*) data;
SERV_Update(uuu->iter, header, server_error);
if (server_error)
return 1/*parsed okay*/;
while (header && *header) {
if (strncasecmp(header, HTTP_CONNECTION_INFO,
sizeof(HTTP_CONNECTION_INFO) - 1) == 0) {
unsigned int i1, i2, i3, i4, ticket;
unsigned char o1, o2, o3, o4;
char ipaddr[40];
if (uuu->host)
break/*failed - duplicate connection info*/;
header += sizeof(HTTP_CONNECTION_INFO) - 1;
while (*header && isspace((unsigned char)(*header)))
header++;
if (strncasecmp(header, kStateless, klen) == 0 &&
(!header[klen] || isspace((unsigned char) header[klen]))) {
/* Special keyword for switching into stateless mode */
uuu->host = (unsigned int)(-1);
#if defined(_DEBUG) && !defined(NDEBUG)
if (uuu->net_info->debug_printout) {
CORE_LOGF_X(2, eLOG_Note,
("[%s] Fallback to stateless", uuu->service));
}
#endif /*_DEBUG && !NDEBUG*/
} else {
int n;
if (sscanf(header, "%u.%u.%u.%u %hu %x%n",
&i1, &i2, &i3, &i4, &uuu->port, &ticket, &n) < 6 ||
(header[n] && !isspace((unsigned char) header[n]))) {
break/*failed - unreadable connection info*/;
}
o1 = i1; o2 = i2; o3 = i3; o4 = i4;
sprintf(ipaddr, "%u.%u.%u.%u", o1, o2, o3, o4);
if (!(uuu->host = SOCK_gethostbyname(ipaddr)) || !uuu->port)
break/*failed - bad host:port in connection info*/;
uuu->ticket = SOCK_HostToNetLong(ticket);
}
}
if ((header = strchr(header, '\n')) != 0)
header++;
}
if (!header || !*header)
return 1/*success*/;
uuu->host = 0;
return 0/*failure*/;
}
struct hostent *gethostbyname(const char *name)
{ struct SocketSettings *lss;
switch (lss=_lx_get_socket_settings(),lss->lx_network_type) {
case LX_AS225:
return SOCK_gethostbyname(name);
case LX_AMITCP:
return TCP_GetHostByName(name);
default:
return NULL;
}
}
const char* DBLB_GetServer(const char* lb_name,
TDBLB_Flags flags,
const SDBLB_Preference* preference,
const char* const skip_servers[],
SDBLB_ConnPoint* conn_point,
char* server_name_buf,
size_t server_name_buflen,
EDBLB_Status* result)
{
static const char kPrefix[] = "DB_IP__";
size_t len, n, a_skip, n_skip;
SConnNetInfo* net_info;
int/*bool*/ failed;
unsigned int x_host;
unsigned short x_port;
double x_pref;
SSERV_InfoCPtr* skip;
SSERV_Info* info;
SDBLB_ConnPoint cp;
EDBLB_Status x;
const char* c;
if (!result)
result = &x;
if (server_name_buf) {
assert(server_name_buflen);
server_name_buf[0] = '\0';
}
if (!conn_point)
conn_point = &cp;
memset(conn_point, 0, sizeof(*conn_point));
if (!lb_name || !*lb_name) {
*result = eDBLB_BadName;
return 0/*failure*/;
}
*result = eDBLB_Success;
if (strchr(lb_name, '.')) {
cp.host = SOCK_gethostbyname(lb_name);
if (cp.host == SOCK_GetLoopbackAddress())
cp.host = /*FIXME?*/SERV_LOCALHOST;
} else
cp.host = 0;
skip = 0;
n_skip = 0;
a_skip = 0;
net_info = 0;
failed = 0/*false*/;
if (skip_servers) {
for (n = 0; !failed && skip_servers[n]; n++) {
const char* server = skip_servers[n];
SSERV_Info* info;
if (!(len = strlen(server))) {
continue;
}
if (strncasecmp(server, kPrefix, sizeof(kPrefix)-1) == 0
&& isdigit((unsigned char) server[sizeof(kPrefix)-1])) {
c = strstr(server + sizeof(kPrefix)-1, "__");
if (c) {
size_t i = (size_t)(c - server) - (sizeof(kPrefix)-1);
char* temp = strdup(server + sizeof(kPrefix)-1);
if (temp) {
char* s = temp + i;
*s++ = ':';
memmove(s, s + 1, strlen(s + 1) + 1);
server = temp;
while (++temp < s) {
if (*temp == '_')
*temp = '.';
}
len -= sizeof(kPrefix);
}
}
}
if (SOCK_StringToHostPort(server, &x_host, &x_port)
!= server + len) {
int/*bool*/ resolved = 0/*false*/;
const SSERV_Info* temp;
SERV_ITER iter;
if (!net_info)
net_info = ConnNetInfo_Create(lb_name);
iter = SERV_Open(skip_servers[n],
fSERV_Standalone | fSERV_Dns
| fSERV_Promiscuous,
0, net_info);
do {
SSERV_Info* dns;
temp = SERV_GetNextInfo(iter);
if (temp) {
x_host = temp->host;
if (x_host && s_IsSkipHost(x_host, cp.host)) {
failed = 1/*true*/;
break;
}
x_port = temp->port;
} else if (!resolved) {
x_host = 0;
x_port = 0;
} else
break;
if ((dns = SERV_CreateDnsInfo(x_host)) != 0) {
dns->port = x_port;
s_AddSkip(&skip, &a_skip, &n_skip, x_host
? dns
: SERV_CopyInfoEx(dns, skip_servers[n]));
if (!x_host)
free(dns);
}
resolved = 1/*true*/;
} while (temp);
SERV_Close(iter);
info = 0;
} else if (s_IsSkipHost(x_host, cp.host)) {
failed = 1/*true*/;
info = 0;
} else if (server != skip_servers[n]) {
info = SERV_CreateStandaloneInfo(x_host, x_port);
} else if ((info = SERV_CreateDnsInfo(x_host)) != 0)
info->port = x_port;
if (server != skip_servers[n])
free((void*) server);
if (info)
s_AddSkip(&skip, &a_skip, &n_skip, info);
}
}
if (!failed && !cp.host) {
if (preference) {
x_host = preference->host;
x_port = preference->port;
if ((x_pref = preference->pref) < 0.0)
x_pref = 0.0;
else if (x_pref >= 100.0)
x_pref = -1.0;
} else {
x_host = 0;
x_port = 0;
x_pref = 0.0;
}
if (!net_info)
net_info = ConnNetInfo_Create(lb_name);
info = SERV_GetInfoP(lb_name, fSERV_ReverseDns | fSERV_Standalone,
x_host, x_port, x_pref, net_info,
skip, n_skip, 0/*not external*/,
0, 0, 0); /* NCBI_FAKE_WARNING: GCC */
if (!info && (flags & fDBLB_AllowFallbackToStandby)) {
/*FIXME: eliminate second pass by fix in ordering in ncbi_lbsmd.c*/
info = SERV_GetInfoP(lb_name, fSERV_ReverseDns | fSERV_Standalone
| fSERV_IncludeSuppressed,
x_host, x_port, x_pref, net_info,
skip, n_skip, 0/*not external*/,
0, 0, 0); /* NCBI_FAKE_WARNING: GCC */
}
} else
info = 0;
if (!info) {
if (!failed) {
if (!cp.host) {
if (n_skip && (x_host = SOCK_gethostbyname(lb_name)) != 0) {
for (n = 0; n < n_skip; n++) {
if (x_host == skip[n]->host) {
failed = 1/*true*/;
break;
}
}
}
if (!failed && skip_servers) {
for (n = 0; (c = skip_servers[n]) != 0; n++) {
if (strcasecmp(c, lb_name) == 0) {
failed = 1/*true*/;
break;
}
}
}
} else if (conn_point != &cp) {
conn_point->host = cp.host;
conn_point->time = NCBI_TIME_INFINITE;
}
}
if (!failed && server_name_buf)
strncpy0(server_name_buf, lb_name, server_name_buflen - 1);
*result = eDBLB_NotFound;
} else {
if (info->type != fSERV_Dns) {
char* s, buf[80];
strncpy0(buf, kPrefix, sizeof(buf) - 1);
SOCK_HostPortToString(info->host, info->port,
buf + sizeof(kPrefix) - 1,
sizeof(buf) - sizeof(kPrefix));
len = strlen(buf);
if ((s = strchr(buf, ':')) != 0)
memmove(s + 1, s, strlen(s) + 1);
for (n = 0; n < len; n++) {
if (buf[n] == '.' || buf[n] == ':')
buf[n] = '_';
}
if (server_name_buf)
strncpy0(server_name_buf, buf, server_name_buflen - 1);
*result = eDBLB_NoDNSEntry;
} else if (info->host) {
c = SERV_NameOfInfo(info);
assert(c);
if (server_name_buf)
strncpy0(server_name_buf, c, server_name_buflen - 1);
} else {
failed = 1/*true*/;
*result = eDBLB_ServiceDown;
}
if (!failed) {
conn_point->host = info->host;
conn_point->port = info->port;
conn_point->time = info->time;
}
free(info);
}
for (n = 0; n < n_skip; n++)
free((void*) skip[n]);
if (skip)
free((void*) skip);
if (net_info)
ConnNetInfo_Destroy(net_info);
return failed ? 0 : (server_name_buf ? server_name_buf : lb_name);
}
