/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
int CWsHook::getaddrinfo(PCSTR pNodeName, PCSTR pServiceName, const ADDRINFOA * pHints, PADDRINFOA * ppResult)
{
int ret = WSAEINVAL;
bool overrideDNS = false;
void * context = NULL;
CString name = CA2T(pNodeName);
CAtlArray<DWORD> addresses;
if( dlg )
overrideDNS = dlg->DnsLookupStart( name, context, addresses );
if( _getaddrinfo && !overrideDNS )
ret = _getaddrinfo(CT2A((LPCTSTR)name), pServiceName, pHints, ppResult);
else if( overrideDNS ) {
if( addresses.IsEmpty() )
ret = EAI_NONAME;
else {
// build the response structure with the addresses we looked up
ret = 0;
DWORD count = addresses.GetCount();
ADDRINFOA_ADDR * result = (ADDRINFOA_ADDR *)malloc(sizeof(ADDRINFOA_ADDR) * count);
for (DWORD i = 0; i < count; i++) {
memset( &result[i], 0, sizeof(ADDRINFOA_ADDR) );
result->info.ai_family = AF_INET;
result->info.ai_addrlen = sizeof(struct sockaddr_in);
result->info.ai_addr = (struct sockaddr *)&(result->addr);
result->addr.sin_family = AF_INET;
result->addr.sin_addr.S_un.S_addr = addresses[i];
if( i < count - 1 )
result->info.ai_next = (PADDRINFOA)&result[i+1];
}
addrInfo.AddTail(result);
*ppResult = (PADDRINFOA)result;
}
}
if (!ret && dlg) {
PADDRINFOA addr = *ppResult;
while (addr) {
if (addr->ai_canonname)
dlg->DnsLookupAlias(name, (LPCTSTR)CA2T(addr->ai_canonname));
if (context &&
addr->ai_addrlen >= sizeof(struct sockaddr_in) &&
addr->ai_family == AF_INET) {
struct sockaddr_in * ipName = (struct sockaddr_in *)addr->ai_addr;
dlg->DnsLookupAddress(context, ipName->sin_addr);
}
addr = addr->ai_next;
}
if (context)
dlg->DnsLookupDone(context);
}
return ret;
}
SocketAddress*
SocketAddress::getaddrinfo(
const char* nodename,
const char* servname
) {
addrinfo* addrinfo_ = _getaddrinfo(nodename, servname);
if (addrinfo_ != NULL) {
SocketAddress* socket_address = new SocketAddress(*addrinfo_);
freeaddrinfo(addrinfo_);
return socket_address;
} else {
return NULL;
}
}
int socket_create_server(char *bindaddr, int port)
{
int s = -1;
struct addrinfo *p, *servinfo;
if (_getaddrinfo(bindaddr, port, &servinfo, SOCK_STREAM) == CORVUS_ERR) {
LOG(ERROR, "socket_create_server: fail to get address info");
return CORVUS_ERR;
}
for (p = servinfo; p != NULL; p = p->ai_next) {
if ((s = _socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
continue;
}
break;
}
if (p == NULL || s == -1) {
freeaddrinfo(servinfo);
return CORVUS_ERR;
}
if (socket_set_nonblocking(s) == -1) {
close(s);
freeaddrinfo(servinfo);
return CORVUS_ERR;
}
if (set_reuseaddr(s) == -1) {
close(s);
freeaddrinfo(servinfo);
return CORVUS_ERR;
}
if (set_reuseport(s) == -1) {
close(s);
freeaddrinfo(servinfo);
return CORVUS_ERR;
}
if (_listen(s, p->ai_addr, p->ai_addrlen, 1024) == -1) {
close(s);
freeaddrinfo(servinfo);
return CORVUS_ERR;
}
freeaddrinfo(servinfo);
return s;
}
void
SocketAddress::init(
const char* nodename,
const char* servname
)
throw(Exception) {
addrinfo* addrinfo_ = _getaddrinfo(nodename, servname);
if (addrinfo_ != NULL) {
next_socket_address = NULL;
assign(*addrinfo_);
freeaddrinfo(addrinfo_);
} else {
throw Exception();
}
}
int socket_get_sockaddr(char *addr, int port, struct sockaddr_in *dest, int socktype)
{
struct addrinfo *addrs;
if (_getaddrinfo(addr, port, &addrs, socktype) == CORVUS_ERR) {
LOG(ERROR, "socket_get_sockaddr: fail to get address info");
return CORVUS_ERR;
}
if (addrs == NULL) {
LOG(ERROR, "socket_get_sockaddr: fail to get address");
return CORVUS_ERR;
}
memcpy(dest, addrs->ai_addr, addrs->ai_addrlen);
freeaddrinfo(addrs);
return CORVUS_OK;
}
int socket_connect(int fd, char *addr, int port)
{
int status = CORVUS_ERR;
struct addrinfo *p, *addrs;
if (_getaddrinfo(addr, port, &addrs, SOCK_STREAM) == CORVUS_ERR) {
LOG(ERROR, "socket_connect: fail to get address info");
return CORVUS_ERR;
}
for (p = addrs; p != NULL; p = p->ai_next) {
status = _connect(fd, p->ai_addr, p->ai_addrlen);
if (status == CORVUS_ERR) continue;
break;
}
freeaddrinfo(addrs);
return status;
}
