int xioparsenetwork_ip4(const char *rangename, struct xiorange *range) {
struct hostent *maskaddr;
struct in_addr *netaddr_in = &range->netaddr.ip4.sin_addr;
struct in_addr *netmask_in = &range->netmask.ip4.sin_addr;
char *rangename1; /* a copy of rangename with writing allowed */
char *delimpos; /* absolute address of delimiter */
unsigned int bits; /* netmask bits */
if ((rangename1 = strdup(rangename)) == NULL) {
Error1("strdup(\"%s\"): out of memory", rangename);
return STAT_RETRYLATER;
}
if (delimpos = strchr(rangename1, '/')) {
char *endptr;
bits = strtoul(delimpos+1, &endptr, 10);
if (! ((*(delimpos+1) != '\0') && (*endptr == '\0'))) {
Error1("not a valid netmask in \"%s\"", rangename);
bits = 32; /* most secure selection */
} else if (bits > 32) {
Error1("netmask \"%s\" is too large", rangename);
bits = 32;
}
if (bits <= 0) {
netmask_in->s_addr = 0;
} else {
netmask_in->s_addr = htonl((0xffffffff << (32-bits)));
}
} else if (delimpos = strchr(rangename1, ':')) {
if ((maskaddr = Gethostbyname(delimpos+1)) == NULL) {
/* note: cast is req on AIX: */
Error2("gethostbyname(\"%s\"): %s", delimpos+1,
h_errno == NETDB_INTERNAL ? strerror(errno) :
(char *)hstrerror(h_errno));
return STAT_NORETRY;
}
netmask_in->s_addr = *(uint32_t *)maskaddr->h_addr_list[0];
} else {
Error1("xioparsenetwork_ip4(\"%s\",,): missing netmask delimiter", rangename);
free(rangename1);
return STAT_NORETRY;
}
{
struct hostent *nameaddr;
*delimpos = 0;
if ((nameaddr = Gethostbyname(rangename1)) == NULL) {
/* note: cast is req on AIX: */
Error2("gethostbyname(\"%s\"): %s", rangename1,
h_errno == NETDB_INTERNAL ? strerror(errno) :
(char *)hstrerror(h_errno));
free(rangename1);
return STAT_NORETRY;
}
netaddr_in->s_addr = *(uint32_t *)nameaddr->h_addr_list[0];
}
free(rangename1);
return STAT_OK;
}
// call(2, localhost)
int retrievesAndPrintsDNSHostEntry(int argc, char** argv) {
char** pp;
struct in_addr addr;
struct hostent *hostp;
if (argc != 2) {
fprintf(stderr, "usage: %s <domain name or dotted-decimal>\n", argv[0]);
exit(0);
}
if (inet_aton(argv[1], &addr) != 0) {
hostp = Gethostbyaddr((const char*)&addr, sizeof(addr), AF_INET);
} else {
hostp = Gethostbyname(argv[1]);
}
printf("official hostname: %s\n", hostp->h_name);
for (pp = hostp->h_aliases; *pp != NULL; pp++) {
printf("alias: %s\n", *pp);
}
for (pp = hostp->h_addr_list; *pp != NULL; pp++) {
addr.s_addr = ((struct in_addr *) *pp)->s_addr;
printf("address: %s\n", inet_ntoa(addr));
}
}
in_addr_t
InAddr_resolve ( const char *name )
{
ASSERT ( name != NULL );
{
struct in_addr x;
int retval = inet_pton ( AF_INET, name, &x );
if ( retval > 0 )
return x.s_addr;
}
{
struct hostent hp;
bool_t success;
in_addr_t retval;
success = Gethostbyname ( name, &hp );
if ( ! success )
return INADDR_NONE;
Mmove ( &retval, *hp.h_addr_list, sizeof ( in_addr_t ) );
return retval;
}
}
int main(int argc, char *argv[]) {
char **pp; /* cursor */
struct in_addr addr; /* holds the IP in integer form */
struct hostent *hostp; /* holds various info about the server */
if (argc != 2) {
fprintf(stderr, "usage: %s <domain name or dotted-decimal>\n", argv[0]);
return 0;
}
/*inet_aton will convert a dotted decimal into an in_addr. If the user has
given a named form, this will be 0, and we'll use Gethostbyname. */
if (inet_aton(argv[1], &addr) != 0)
hostp = Gethostbyaddr((const char*) &addr, sizeof(addr), AF_INET);
else
hostp = Gethostbyname(argv[1]);
printf("Official hostname: %s\n", hostp->h_name);
for (pp=hostp->h_aliases; *pp != NULL; ++pp)
printf("alias: %s\n", *pp);
for (pp = hostp->h_addr_list; *pp != NULL; ++pp) {
addr.s_addr = ((struct in_addr*)*pp)->s_addr;
printf("address: %s\n", inet_ntoa(addr));
}
return 0;
}
int
main(int argc, char **argv)
{
char *ptr, **pptr;
char str[INET_ADDRSTRLEN];
struct hostent *hptr;
while (--argc > 0) {
ptr = *++argv;
try {
hptr = Gethostbyname(ptr);
} catch (const std::exception &e) {
std::cout << e.what() << std::endl;
continue;
}
printf("official hostname: %s\n", hptr->h_name);
for (pptr = hptr->h_aliases; *pptr != NULL; pptr++)
printf("\talias: %s\n", *pptr);
switch (hptr->h_addrtype) {
case AF_INET:
pptr = hptr->h_addr_list;
for ( ; *pptr != NULL; pptr++)
printf("\taddress: %s\n",
inet_ntop(hptr->h_addrtype, *pptr, str, sizeof(str)));
break;
default:
perror("unknown address type");
break;
}
}
exit(0);
}
int main(int argc, char **argv)
{
char **pp;
struct in_addr addr;
struct hostent *hostp;
if (argc != 2) {
fprintf(stderr, "usage: %s <domain name or dotted-decimal>\n", argv[0]);
exit(0);
}
if (inet_aton(argv[1], &addr) != 0)
hostp = Gethostbyaddr((const char *)&addr, sizeof(addr), AF_INET); //AF_INET等于0,指的是使用IPV4
else
hostp = Gethostbyname(argv[1]);
printf("official hostname: %s\n", hostp->h_name);
for (pp = hostp->h_aliases; *pp != NULL; pp++) { //aliase->别名
printf("alias: %s\n", *pp);
}
for (pp = hostp->h_addr_list; *pp != NULL; pp++) {
//printf("%s\n", *pp);
addr.s_addr = ((struct in_addr *)*pp)->s_addr; //*pp 是 char *类型
/* expected ‘struct in_addr’ but argument is of type ‘struct in_addr *’ */
printf("address: %s\n", inet_ntoa(addr));
}
exit(0);
}
int xioparsenetwork_ip4(const char *rangename, struct xiorange *range) {
struct hostent *maskaddr;
struct in_addr *netaddr_in = &range->netaddr.ip4.sin_addr;
struct in_addr *netmask_in = &range->netmask.ip4.sin_addr;
char *rangename1; /* a copy of rangename with writing allowed */
char *delimpos; /* absolute address of delimiter */
int bits;
if ((rangename1 = strdup(rangename)) == NULL) {
Error1("strdup(\"%s\"): out of memory", rangename);
return STAT_RETRYLATER;
}
if (delimpos = strchr(rangename1, '/')) {
bits = strtoul(delimpos+1, NULL, 10);
netmask_in->s_addr = htonl((0xffffffff << (32-bits)));
} else if (delimpos = strchr(rangename1, ':')) {
if ((maskaddr = Gethostbyname(delimpos+1)) == NULL) {
/* note: cast is req on AIX: */
Error2("gethostbyname(\"%s\"): %s", delimpos+1,
h_errno == NETDB_INTERNAL ? strerror(errno) :
(char *)hstrerror(h_errno));
return STAT_NORETRY;
}
netmask_in->s_addr = *(uint32_t *)maskaddr->h_addr_list[0];
} else {
Error1("xioparsenetwork_ip4(\"%s\",,): missing netmask delimiter", rangename);
free(rangename1);
return STAT_NORETRY;
}
{
struct hostent *nameaddr;
*delimpos = 0;
if ((nameaddr = Gethostbyname(rangename1)) == NULL) {
/* note: cast is req on AIX: */
Error2("gethostbyname(\"%s\"): %s", rangename1,
h_errno == NETDB_INTERNAL ? strerror(errno) :
(char *)hstrerror(h_errno));
free(rangename1);
return STAT_NORETRY;
}
netaddr_in->s_addr = *(unsigned long *)nameaddr->h_addr_list[0];
}
free(rangename1);
return STAT_OK;
}
int
reverse(thread_pool_t *info, thread_ctx_t *thread_ctx, edict_t *edict)
{
chkresult_t *result;
struct hostent *canonicalhost, *reversehost;
grey_tuple_t *request;
const char *client_address;
char buf[INET_ADDRSTRLEN];
const char *ptr;
mseconds_t timelimit;
request = (grey_tuple_t *)edict->job;
client_address = request->client_address;
assert(client_address);
result = (chkresult_t *)Malloc(sizeof(chkresult_t));
memset(result, 0, sizeof(*result));
result->judgment = J_UNDEFINED;
result->checkname = "reverse";
timelimit = edict->timelimit;
reversehost = Gethostbyaddr_str(client_address, timelimit);
if (reversehost) {
logstr(GLOG_INSANE, "client_address (%s) has a PTR record (%s)",
client_address, reversehost->h_name);
canonicalhost = Gethostbyname(reversehost->h_name, timelimit);
if (canonicalhost) {
ptr = inet_ntop(AF_INET, canonicalhost->h_addr_list[0], buf, INET_ADDRSTRLEN);
assert(ptr);
logstr(GLOG_INSANE, "client_ip (%s) canonical (%s)",
client_address, buf);
if (strcmp(buf, client_address)) {
logstr(GLOG_DEBUG, "client_address (%s) not canonical (%s)",
client_address, buf);
result->judgment = J_SUSPICIOUS;
result->weight = 1; /* FIXME */
}
} else {
logstr(GLOG_DEBUG, "No A for PTR for client_ip (%s)", client_address);
result->judgment = J_SUSPICIOUS;
result->weight = 1;
}
} else {
logstr(GLOG_DEBUG, "client_ip (%s) has no PTR record", client_address);
result->judgment = J_SUSPICIOUS;
result->weight = 1;
}
send_result(edict, result);
logstr(GLOG_DEBUG, "reverse returning");
request_unlink(request);
return 0;
}
struct hostent *Gethostbyname(const char *name) {
struct hostent *hp;
if((hp = gethostbyname(name)) == NULL) {
switch(h_errno) {
case TRY_AGAIN: fprintf(stdout," Warning: Gethostbyname returned TRY_AGAIN.\n");
fflush(stdout); return Gethostbyname(name); break;
case NO_DATA: fprintf(stdout," Error: Gethostbyname(%s) returned NO_DATA.\n",name); break;
case NO_RECOVERY: fprintf(stdout," Error: Gethostbyname(%s) returned NO_RECOVERY.\n",name); break;
case HOST_NOT_FOUND: fprintf(stdout," Error: Gethostbyname(%s) returned HOST_NOT_FOUND.\n",name); break;
default: fprintf(stdout," Error: Gethostbyname(%s) returned an unknown error (%s).\n",name,DDI_Id()); break;
}
Fatal_error(911);
}
return hp;
}
int main(int argc, char **argv) {
int listenfd, connfd;
socklen_t clientlen = sizeof(struct sockaddr_in);
struct sockaddr_in clientaddr;
user* u;
/* Init node and set port accoriding to configue file */
init_node(argc, argv);
/* Init the linked list of channel and the table of user */
init_channel();
init_user();
/* Init server socket and set it as unblocked */
listenfd = init_unblocking_server_socket(curr_node_config_entry->irc_port);
/* connect to local daemon */
local_client_fd = socket_connect(curr_node_config_entry->ipaddr,curr_node_config_entry->local_port);
/* Init struct pool */
init_pool();
add_listen_fd(listenfd);
while (1) {
/* Wait for listening/connected descriptor(s) to become ready */
p.ready_set = p.read_set;
p.nready = Select(p.maxfd+1, &p.ready_set, NULL, NULL, NULL);
/* If listening descriptor ready, add new client to pool */
if (FD_ISSET(listenfd, &p.ready_set)) {
connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
/* create a user struct for the connect fd */
u = (user*) Calloc(1,sizeof(user));
user_table[connfd] = u;
/*set server_name and host_name for user */
u->host_name = strdup(Gethostbyaddr((const char*)&clientaddr.sin_addr,sizeof(clientaddr.sin_addr),AF_INET)->h_name);
u->server_name = strdup(Gethostbyname("localhost")->h_name);
add_client(connfd);
}
/* Echo a text line from each ready connected descriptor */
check_clients();
}
}
int _xioopen_proxy_prepare(struct proxyvars *proxyvars, struct opt *opts,
const char *targetname, const char *targetport) {
struct hostent *host;
retropt_bool(opts, OPT_IGNORECR, &proxyvars->ignorecr);
retropt_bool(opts, OPT_PROXY_RESOLVE, &proxyvars->doresolve);
retropt_string(opts, OPT_PROXY_AUTHORIZATION, &proxyvars->authstring);
if (proxyvars->doresolve) {
/* currently we only resolve to IPv4 addresses. This is in accordance to
RFC 2396; however once it becomes clear how IPv6 addresses should be
represented in CONNECT commands this code might be extended */
host = Gethostbyname(targetname);
if (host == NULL) {
int level = E_WARN;
/* note: cast is req on AIX: */
Msg2(level, "gethostbyname(\"%s\"): %s", targetname,
h_errno == NETDB_INTERNAL ? strerror(errno) :
(char *)hstrerror(h_errno)/*0 h_messages[h_errno-1]*/);
proxyvars->targetaddr = strdup(targetname);
} else {
#define LEN 16 /* www.xxx.yyy.zzz\0 */
if ((proxyvars->targetaddr = Malloc(LEN)) == NULL) {
return STAT_RETRYLATER;
}
snprintf(proxyvars->targetaddr, LEN, "%u.%u.%u.%u",
(unsigned char)host->h_addr_list[0][0],
(unsigned char)host->h_addr_list[0][1],
(unsigned char)host->h_addr_list[0][2],
(unsigned char)host->h_addr_list[0][3]);
#undef LEN
}
} else {
proxyvars->targetaddr = strdup(targetname);
}
proxyvars->targetport = htons(parseport(targetport, IPPROTO_TCP));
return STAT_OK;
}
/* $begin open_clientfd */
int open_clientfd(char* hostname, int port)
{
int clientfd;
struct hostent* hp;
struct sockaddr_in serveraddr;
if((clientfd = socket(AF_INET,SOCK_STREAM,0)) < 0)
return -1;/*Check errno for cause of error*/
/* Fill in the server's IP address and port*/
if((hp = Gethostbyname(hostname)) == NULL)
return -2;
bzero((char*)&serveraddr,sizeof(serveraddr));
serveraddr.sin_family = AF_INET;
bcopy((char*)hp->h_addr_list[0],(char*)&serveraddr.sin_addr.s_addr,hp->h_length);
serveraddr.sin_port = htons(port);
/* Establish a connection with the server*/
if(connect(clientfd,(SA*)&serveraddr,sizeof(serveraddr)) < 0)
return -1;
return clientfd;
}
/* the ultimate(?) socat resolver function
node: the address to be resolved; supported forms:
1.2.3.4 (IPv4 address)
[::2] (IPv6 address)
hostname (hostname resolving to IPv4 or IPv6 address)
hostname.domain (fq hostname resolving to IPv4 or IPv6 address)
service: the port specification; may be numeric or symbolic
family: PF_INET, PF_INET6, or PF_UNSPEC permitting both
socktype: SOCK_STREAM, SOCK_DGRAM
protocol: IPPROTO_UDP, IPPROTO_TCP
sau: an uninitialized storage for the resulting socket address
returns: STAT_OK, STAT_RETRYLATER
*/
int xiogetaddrinfo(const char *node, const char *service,
int family, int socktype, int protocol,
union sockaddr_union *sau, socklen_t *socklen,
unsigned long res_opts0, unsigned long res_opts1) {
int port = -1; /* port number in network byte order */
char *numnode = NULL;
size_t nodelen;
unsigned long save_res_opts = 0;
#if HAVE_GETADDRINFO
struct addrinfo hints = {0};
struct addrinfo *res = NULL;
#else /* HAVE_GETIPNODEBYNAME || nothing */
struct hostent *host;
#endif
int error_num;
#if HAVE_RESOLV_H
if (res_opts0 | res_opts1) {
if (!(_res.options & RES_INIT)) {
Res_init(); /*!!! returns -1 on error */
}
save_res_opts = _res.options;
_res.options &= ~res_opts0;
_res.options |= res_opts1;
Debug2("changed _res.options from 0x%lx to 0x%lx",
save_res_opts, _res.options);
}
#endif /* HAVE_RESOLV_H */
memset(sau, 0, *socklen);
sau->soa.sa_family = family;
/* if service is numeric we don't want to have a lookup (might take long
with NIS), so we handle this specially */
if (service && isdigit(service[0]&0xff)) {
char *extra;
port = htons(strtoul(service, &extra, 0));
if (*extra != '\0') {
Warn2("xiogetaddrinfo(, \"%s\", ...): extra trailing data \"%s\"",
service, extra);
}
service = NULL;
}
/* the resolver functions might handle numeric forms of node names by
reverse lookup, that's not what we want.
So we detect these and handle them specially */
if (node && isdigit(node[0]&0xff)) {
#if HAVE_GETADDRINFO
hints.ai_flags |= AI_NUMERICHOST;
#endif /* HAVE_GETADDRINFO */
if (family == PF_UNSPEC) {
family = PF_INET;
#if HAVE_GETADDRINFO
} else if (family == PF_INET6) {
/* map "explicitely" into IPv6 address space; getipnodebyname() does
this with AI_V4MAPPED, but not getaddrinfo() */
if ((numnode = Malloc(strlen(node)+7+1)) == NULL) {
#if HAVE_RESOLV_H
if (res_opts0 | res_opts1) {
_res.options = (_res.options & (~res_opts0&~res_opts1) |
save_res_opts& ( res_opts0| res_opts1));
}
#endif
return STAT_NORETRY;
}
sprintf(numnode, "::ffff:%s", node);
node = numnode;
hints.ai_flags |= AI_NUMERICHOST;
#endif /* HAVE_GETADDRINFO */
}
#if WITH_IP6
} else if (node && node[0] == '[' && node[(nodelen=strlen(node))-1]==']') {
if ((numnode = Malloc(nodelen-1)) == NULL) {
#if HAVE_RESOLV_H
if (res_opts0 | res_opts1) {
_res.options = (_res.options & (~res_opts0&~res_opts1) |
save_res_opts& ( res_opts0| res_opts1));
}
#endif
return STAT_NORETRY;
}
strncpy(numnode, node+1, nodelen-2);
numnode[nodelen-2] = '\0';
node = numnode;
#if HAVE_GETADDRINFO
hints.ai_flags |= AI_NUMERICHOST;
#endif /* HAVE_GETADDRINFO */
if (family == PF_UNSPEC) family = PF_INET6;
#endif /* WITH_IP6 */
}
#if HAVE_GETADDRINFO
if (node != NULL || service != NULL) {
struct addrinfo *record;
if (socktype != SOCK_STREAM && socktype != SOCK_DGRAM) {
/* actual socket type value is not supported - fallback to a good one */
socktype = SOCK_DGRAM;
}
if (protocol != IPPROTO_TCP && protocol != IPPROTO_UDP) {
/* actual protocol value is not supported - fallback to a good one */
if (socktype == SOCK_DGRAM) {
protocol = IPPROTO_UDP;
} else {
protocol = IPPROTO_TCP;
}
}
hints.ai_flags |= AI_PASSIVE;
hints.ai_family = family;
hints.ai_socktype = socktype;
hints.ai_protocol = protocol;
hints.ai_addrlen = 0;
hints.ai_addr = NULL;
hints.ai_canonname = NULL;
hints.ai_next = NULL;
if ((error_num = Getaddrinfo(node, service, &hints, &res)) != 0) {
Error7("getaddrinfo(\"%s\", \"%s\", {%d,%d,%d,%d}, {}): %s",
node, service, hints.ai_flags, hints.ai_family,
hints.ai_socktype, hints.ai_protocol,
(error_num == EAI_SYSTEM)?
strerror(errno):gai_strerror(error_num));
if (res != NULL) freeaddrinfo(res);
if (numnode) free(numnode);
#if HAVE_RESOLV_H
if (res_opts0 | res_opts1) {
_res.options = (_res.options & (~res_opts0&~res_opts1) |
save_res_opts& ( res_opts0| res_opts1));
}
#endif
return STAT_RETRYLATER;
}
service = NULL; /* do not resolve later again */
record = res;
if (family == PF_UNSPEC && xioopts.preferred_ip == '0') {
/* we just take the first result */
family = res[0].ai_addr->sa_family;
}
if (family == PF_UNSPEC) {
int trypf;
trypf = (xioopts.preferred_ip=='6'?PF_INET6:PF_INET);
/* we must look for a matching entry */
while (record != NULL) {
if (record->ai_family == trypf) {
family = trypf;
break; /* family and record set accordingly */
}
record = record->ai_next;
}
if (record == NULL) {
/* we did not find a "preferred" entry, take the first */
record = res;
family = res[0].ai_addr->sa_family;
}
}
switch (family) {
#if WITH_IP4
case PF_INET:
if (*socklen > record->ai_addrlen) {
*socklen = record->ai_addrlen;
}
memcpy(&sau->ip4, record->ai_addr, *socklen);
break;
#endif /* WITH_IP4 */
#if WITH_IP6
case PF_INET6:
#if _AIX
/* older AIX versions pass wrong length, so we correct it */
record->ai_addr->sa_len = sizeof(struct sockaddr_in6);
#endif
if (*socklen > record->ai_addrlen) {
*socklen = record->ai_addrlen;
}
memcpy(&sau->ip6, record->ai_addr, *socklen);
break;
#endif /* WITH_IP6 */
default:
Error1("address resolved to unknown protocol family %d",
record->ai_addr->sa_family);
break;
}
freeaddrinfo(res);
} else {
switch (family) {
#if WITH_IP4
case PF_INET: *socklen = sizeof(sau->ip4); break;
#endif /* WITH_IP4 */
#if WITH_IP6
case PF_INET6: *socklen = sizeof(sau->ip6); break;
#endif /* WITH_IP6 */
}
}
#elif HAVE_GETIPNODEBYNAME /* !HAVE_GETADDRINFO */
if (node != NULL) {
/* first fallback is getipnodebyname() */
if (family == PF_UNSPEC) {
#if WITH_IP4 && WITH_IP6
family = xioopts.default_ip=='6'?PF_INET6:PF_INET;
#elif WITH_IP6
family = PF_INET6;
#else
family = PF_INET;
#endif
}
host = Getipnodebyname(node, family, AI_V4MAPPED, &error_num);
if (host == NULL) {
const static char ai_host_not_found[] = "Host not found";
const static char ai_no_address[] = "No address";
const static char ai_no_recovery[] = "No recovery";
const static char ai_try_again[] = "Try again";
const char *error_msg = "Unknown error";
switch (error_num) {
case HOST_NOT_FOUND: error_msg = ai_host_not_found; break;
case NO_ADDRESS: error_msg = ai_no_address;
case NO_RECOVERY: error_msg = ai_no_recovery;
case TRY_AGAIN: error_msg = ai_try_again;
}
Error2("getipnodebyname(\"%s\", ...): %s", node, error_msg);
} else {
switch (family) {
#if WITH_IP4
case PF_INET:
*socklen = sizeof(sau->ip4);
sau->soa.sa_family = PF_INET;
memcpy(&sau->ip4.sin_addr, host->h_addr_list[0], 4);
break;
#endif
#if WITH_IP6
case PF_INET6:
*socklen = sizeof(sau->ip6);
sau->soa.sa_family = PF_INET6;
memcpy(&sau->ip6.sin6_addr, host->h_addr_list[0], 16);
break;
#endif
}
}
freehostent(host);
}
#else /* !HAVE_GETIPNODEBYNAME */
if (node != NULL) {
/* this is not a typical IP6 resolver function - but Linux
"man gethostbyname" says that the only supported address type with
this function is AF_INET _at present_, so maybe this fallback will
be useful somewhere sometimesin a future even for IP6 */
if (family == PF_UNSPEC) {
#if WITH_IP4 && WITH_IP6
family = xioopts.default_ip=='6'?PF_INET6:PF_INET;
#elif WITH_IP6
family = PF_INET6;
#else
family = PF_INET;
#endif
}
/*!!! try gethostbyname2 for IP6 */
if ((host = Gethostbyname(node)) == NULL) {
Error2("gethostbyname(\"%s\"): %s", node,
h_errno == NETDB_INTERNAL ? strerror(errno) :
hstrerror(h_errno));
#if HAVE_RESOLV_H
if (res_opts0 | res_opts1) {
_res.options = (_res.options & (~res_opts0&~res_opts1) |
save_res_opts& ( res_opts0| res_opts1));
}
#endif
return STAT_RETRYLATER;
}
if (host->h_addrtype != family) {
Error2("xioaddrinfo(): \"%s\" does not resolve to %s",
node, family==PF_INET?"IP4":"IP6");
} else {
switch (family) {
#if WITH_IP4
case PF_INET:
*socklen = sizeof(sau->ip4);
sau->soa.sa_family = PF_INET;
memcpy(&sau->ip4.sin_addr, host->h_addr_list[0], 4);
break;
#endif /* WITH_IP4 */
#if WITH_IP6
case PF_INET6:
*socklen = sizeof(sau->ip6);
sau->soa.sa_family = PF_INET6;
memcpy(&sau->ip6.sin6_addr, host->h_addr_list[0], 16);
break;
#endif /* WITH_IP6 */
}
}
}
#endif
#if WITH_TCP || WITH_UDP
if (service) {
port = parseport(service, protocol);
}
if (port >= 0) {
switch (family) {
#if WITH_IP4
case PF_INET: sau->ip4.sin_port = port; break;
#endif /* WITH_IP4 */
#if WITH_IP6
case PF_INET6: sau->ip6.sin6_port = port; break;
#endif /* WITH_IP6 */
}
}
#endif /* WITH_TCP || WITH_UDP */
if (numnode) free(numnode);
#if HAVE_RESOLV_H
if (res_opts0 | res_opts1) {
_res.options = (_res.options & (~res_opts0&~res_opts1) |
save_res_opts& ( res_opts0| res_opts1));
}
#endif /* HAVE_RESOLV_H */
return STAT_OK;
}
int
helo(thread_pool_t *info, thread_ctx_t *thread_ctx, edict_t *edict)
{
chkresult_t *result;
struct hostent *host, *reversehost;
grey_tuple_t *request;
const char *helostr;
const char *client_address;
char addrstrbuf[INET_ADDRSTRLEN];
const char *ptr;
mseconds_t timelimit;
request = (grey_tuple_t *)edict->job;
helostr = request->helo_name;
client_address = request->client_address;
assert(helostr);
assert(client_address);
result = (chkresult_t *)Malloc(sizeof(chkresult_t));
memset(result, 0, sizeof(*result));
result->judgment = J_UNDEFINED;
result->checkname = "helo";
timelimit = edict->timelimit;
/* check the validity of helo string */
if (check_helo(helostr)) {
logstr(GLOG_DEBUG, "Syntactically suspicious helo name");
/* one for invalid helo string AND one for not matching the client ip */
result->weight += 2; /* FIXME */
/* no point in doing dns queries as invalid helo wouldn't match the client ip */
goto FINISH;
}
/* check if helo resolves to client ip */
host = Gethostbyname(helostr, timelimit);
if (host) {
ptr = inet_ntop(AF_INET, host->h_addr_list[0], addrstrbuf, INET_ADDRSTRLEN);
if (NULL == ptr) {
/* this should never happen */
logstr(GLOG_ERROR, "helo_name resolved to an invalid ip");
goto FINISH;
}
logstr(GLOG_INSANE, "client_address (%s), helo (%s)",
client_address, addrstrbuf); /* FIXME */
if (strcmp(addrstrbuf, client_address)) {
logstr(GLOG_DEBUG, "helo name (%s) does not resolve to client address (%s)",
helostr, client_address);
result->weight += 1; /* FIXME */
}
} else {
logstr(GLOG_DEBUG, "helo_name not resolvable");
result->weight += 1; /* FIXME */
}
/* check if client's PTR record match helo */
reversehost = Gethostbyaddr_str(client_address, timelimit);
if (reversehost) {
logstr(GLOG_INSANE, "client_address (%s) has a PTR record (%s)",
client_address, reversehost->h_name);
if (strcmp(reversehost->h_name, helostr)) {
logstr(GLOG_DEBUG, "PTR for client_address (%s) differs from helo_name (%s)",
reversehost->h_name, helostr);
result->weight += 1; /* FIXME */
}
} else {
logstr(GLOG_INSANE, "client_address (%s) does not have a PTR record");
result->weight += 1; /* FIXME */
}
FINISH:
if (result->weight > 0)
result->judgment = J_SUSPICIOUS;
send_result(edict, result);
logstr(GLOG_DEBUG, "helo returning");
request_unlink(request);
return 0;
}
