static void
bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,
void *arg)
{
struct bufferevent *bev = arg;
int r;
BEV_LOCK(bev);
bufferevent_unsuspend_write(bev, BEV_SUSPEND_LOOKUP);
bufferevent_unsuspend_read(bev, BEV_SUSPEND_LOOKUP);
if (result != 0) {
/* XXX Communicate the error somehow. */
_bufferevent_run_eventcb(bev, BEV_EVENT_ERROR);
_bufferevent_decref_and_unlock(bev);
if (ai)
evutil_freeaddrinfo(ai);
return;
}
/* XXX use the other addrinfos? */
r = bufferevent_socket_connect(bev, ai->ai_addr, ai->ai_addrlen);
_bufferevent_decref_and_unlock(bev);
evutil_freeaddrinfo(ai);
}
static void
bufferevent_connect_getaddrinfo_cb(int result, struct evutil_addrinfo *ai,
void *arg)
{
struct bufferevent *bev = arg;
struct bufferevent_private *bev_p =
EVUTIL_UPCAST(bev, struct bufferevent_private, bev);
int r;
BEV_LOCK(bev);
bufferevent_unsuspend_write_(bev, BEV_SUSPEND_LOOKUP);
bufferevent_unsuspend_read_(bev, BEV_SUSPEND_LOOKUP);
if (result != 0) {
bev_p->dns_error = result;
bufferevent_run_eventcb_(bev, BEV_EVENT_ERROR);
bufferevent_decref_and_unlock_(bev);
if (ai)
evutil_freeaddrinfo(ai);
return;
}
/* XXX use the other addrinfos? */
/* XXX use this return value */
r = bufferevent_socket_connect(bev, ai->ai_addr, (int)ai->ai_addrlen);
(void)r;
bufferevent_decref_and_unlock_(bev);
evutil_freeaddrinfo(ai);
}
static int
dns_lookup (const char *addr_str, struct sockaddr_in *sa, ev_socklen_t *sa_len)
{
struct evutil_addrinfo hints;
struct evutil_addrinfo *answer = NULL;
int err;
/* Build the hints to tell getaddrinfo how to act. */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET; /* only use IPv4 now. */
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP; /* We want a TCP socket */
/* Only return addresses we can use. */
hints.ai_flags = EVUTIL_AI_ADDRCONFIG;
/* Look up the hostname. */
err = evutil_getaddrinfo(addr_str, NULL, &hints, &answer);
if (err != 0) {
seaf_warning("Error while resolving '%s': %s\n",
addr_str, evutil_gai_strerror(err));
return -1;
}
*sa = *((struct sockaddr_in *)answer->ai_addr);
*sa_len = (ev_socklen_t)answer->ai_addrlen;
evutil_freeaddrinfo (answer);
return 0;
}
static void resolve_cb(int errcode,struct evutil_addrinfo *addr,void *priv) {
struct dnsreq *dr = (struct dnsreq *)priv;
struct evutil_addrinfo *ai;
char *s;
int n;
n = 0;
for(ai=addr;ai;ai=ai->ai_next) {
s = addrinfo_to_string(ai);
if(s)
n++;
free(s);
}
if(!n) {
// XXX log it
fprintf(stderr,"dns error='%s'\n",evutil_gai_strerror(errcode));
dr->cb(0,dr->priv);
} else {
n = rand()%n;
for(ai=addr;ai;ai=ai->ai_next) {
s = addrinfo_to_string(ai);
if(s && !n--)
dr->cb(s,dr->priv);
free(s);
}
}
if(addr) { evutil_freeaddrinfo(addr); }
free(dr);
}
static void *
dns_lookup (void *vdata)
{
DNSLookupData *data = vdata;
struct evutil_addrinfo hints;
struct evutil_addrinfo *answer = NULL;
int err;
void *addr;
char *addr_str;
socklen_t size;
/* Build the hints to tell getaddrinfo how to act. */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET; /* only use IPv4 now. */
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP; /* We want a TCP socket */
/* Only return addresses we can use. */
hints.ai_flags = EVUTIL_AI_ADDRCONFIG;
/* Look up the hostname. */
err = evutil_getaddrinfo(data->peer->public_addr, NULL, &hints, &answer);
if (err != 0) {
ccnet_warning("Error while resolving '%s': %s\n",
data->peer->public_addr, evutil_gai_strerror(err));
return vdata;
}
/* just use the first answer */
if (answer->ai_family == AF_INET) {
size = INET_ADDRSTRLEN;
addr = &((struct sockaddr_in *)(answer->ai_addr))->sin_addr;
} else if (answer->ai_family == AF_INET6) {
size = INET6_ADDRSTRLEN;
addr = &((struct sockaddr_in6 *)(answer->ai_addr))->sin6_addr;
} else
goto out;
addr_str = (char *)calloc(size, sizeof(char));
if (addr_str == NULL) {
ccnet_error("Out of memory\n");
goto out;
}
if (!inet_ntop(answer->ai_family, addr, addr_str, size)) {
ccnet_warning("Peer %s domain name %s lookup fail\n",
data->peer->name, data->peer->public_addr);
free(addr_str);
goto out;
}
data->addr_str = addr_str;
out:
evutil_freeaddrinfo (answer);
return vdata;
}
static void dns_cb(int errcode, struct evutil_addrinfo *addr, void *ptr)
{
struct evutil_addrinfo *ai;
struct timeval tv;
const char *host = ptr;
if (errcode) {
tmate_status_message("%s lookup failure. Retrying in %d seconds (%s)",
host, TMATE_DNS_RETRY_TIMEOUT,
evutil_gai_strerror(errcode));
tv.tv_sec = TMATE_DNS_RETRY_TIMEOUT;
tv.tv_usec = 0;
evtimer_assign(&tmate_session.ev_dns_retry, tmate_session.ev_base,
on_dns_retry, NULL);
evtimer_add(&tmate_session.ev_dns_retry, &tv);
return;
}
tmate_status_message("Connecting to %s...", host);
for (ai = addr; ai; ai = ai->ai_next) {
char buf[128];
const char *ip = NULL;
if (ai->ai_family == AF_INET) {
struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr;
ip = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, 128);
} else if (ai->ai_family == AF_INET6) {
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai->ai_addr;
ip = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, 128);
}
tmate_debug("Trying server %s", ip);
/*
* Note: We don't deal with the client list. Clients manage it
* and free client structs when necessary.
*/
(void)tmate_ssh_client_alloc(&tmate_session, ip);
}
evutil_freeaddrinfo(addr);
/*
* XXX For some reason, freeing the DNS resolver makes MacOSX flip out...
* not sure what's going on...
* evdns_base_free(tmate_session.ev_dnsbase, 0);
* tmate_session.ev_dnsbase = NULL;
*/
}
void EvdnsWrapper::on_remote_servername_resolved(int result, struct evutil_addrinfo *res,
void *arg) {
GetAddrCallBack *c = (GetAddrCallBack *)arg;
std::vector<MyAddrInfo> ret;
if (result == 0){
for (evutil_addrinfo *rp = res; rp != NULL; rp = rp->ai_next) {
ret.push_back(MyAddrInfo(rp));
}
evutil_freeaddrinfo(res);
}
c->on(result, ret);
c->release_shared();
}
void
hub_add_peer(struct hub *hub, char const *address)
{
int e;
char *hostname, *ptr, port[6];
struct evutil_addrinfo hints, *answer = NULL;
struct peer *peer;
if ((ptr = strchr(address, ':')))
{
hostname = calloc(ptr - address + 1, sizeof(*hostname));
if (!hostname) err(1, NULL);
strncpy(hostname, address, ptr - address);
strncpy(port, ptr + 1, sizeof(port));
}
else
{
hostname = (char *) address;
evutil_snprintf(port, sizeof(port), "%hi", hub->port);
}
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = EVUTIL_AI_ADDRCONFIG;
if ((e = evutil_getaddrinfo(hostname, port, &hints, &answer)) < 0)
{
fprintf(stderr, "Error while resolving '%s': %s", hostname,
evutil_gai_strerror(e));
return;
}
if (!answer)
return;
peer = calloc(1, sizeof(*peer));
if (!peer) err(1, NULL);
peer->name = address;
peer->addrlen = answer->ai_addrlen;
peer->addr = malloc(peer->addrlen);
if (!peer->addr) err(1, NULL);
memcpy(peer->addr, answer->ai_addr, peer->addrlen);
peer->next = hub->peers;
hub->peers = peer;
evutil_freeaddrinfo(answer);
}
static int
tcpip_open(const gchar *h, const gchar *p)
{
GRID_DEBUG("opening tcp ip connection");
struct evutil_addrinfo ai_hint, *ai_res = NULL;
int rc;
socklen_t ss_len;
struct sockaddr_storage ss;
int fd;
fd = socket(PF_INET, SOCK_STREAM, 0);
if (fd < 0) {
GRID_ERROR("accept error on fd=%d : %s", fd, strerror(errno));
return -1;
}
sock_set_linger_default(fd);
sock_set_reuseaddr(fd, TRUE);
bzero(&ai_hint, sizeof(ai_hint));
ai_hint.ai_flags = AI_NUMERICHOST;
ai_hint.ai_family = PF_INET;
ai_hint.ai_socktype = SOCK_STREAM;
rc = evutil_getaddrinfo(h, p, &ai_hint, &ai_res);
if (rc != 0) {
errno = rc;
return -1;
}
bzero(&ss, sizeof(ss));
ss_len = ai_res->ai_addrlen;
g_memmove(&ss, (ai_res->ai_addr), ss_len);
evutil_freeaddrinfo(ai_res);
switch (connect(fd, (struct sockaddr *) &ss, ss_len)) {
case 0:
return fd;
case -1:
if (errno==EALREADY || errno==EAGAIN || errno==EINPROGRESS || errno==EWOULDBLOCK) {
errno = 0;
return fd;
}
return -1;
default:/* unexpected */
return -1;
}
}
static void ts_dns_resolved(int errcode, struct evutil_addrinfo *addr, void *ptr) {
struct ts_session *session = ptr;
if (errcode) {
ts_log_e("dns resolve failed");
goto failed;
}
ts_conn_sockaddr(addr->ai_addr, addr->ai_addrlen, session);
evutil_freeaddrinfo(addr);
return;
failed:
ts_session_close(session);
}
void CDNSManager::LookupDNSCallback(int _errcode, struct evutil_addrinfo *_addr, void* _context)
{
DNS_RECORD_t* record = (DNS_RECORD_t*)_context;
if (_errcode)
{
LOG_ERROR_STREAM << "Fail to parse " << record->name << ": " << evutil_gai_strerror(_errcode);
}
else
{
record->address.clear();
record->visitTime = time(NULL);
record->status = MAIN_TABLE_RECORD_t::STATUS_e::STATUS_READY;
if (_addr->ai_canonname) record->cname = _addr->ai_canonname;
//
// get ip addresses
//
struct evutil_addrinfo *ai;
for (ai = _addr; ai; ai = ai->ai_next)
{
char buf[128] = { 0 };
const char* ipAddr = NULL;
if (ai->ai_family == AF_INET)
{
struct sockaddr_in* sin = (struct sockaddr_in *)ai->ai_addr;
ipAddr = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, sizeof(buf));
}
else if (ai->ai_family == AF_INET6)
{
struct sockaddr_in6* sin6 = (struct sockaddr_in6 *)ai->ai_addr;
ipAddr = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf, sizeof(buf));
}
if (ipAddr)
{
record->address += ipAddr;
record->address += ", ";
}
}
evutil_freeaddrinfo(_addr);
}
if (--s_pendingLookupCount == 0)
event_base_loopexit(CDNSManager::GetInstance()->m_evbase, NULL);
}
evutil_socket_t bind_socket_(const char* address, ev_uint16_t port, int reuse) {
evutil_socket_t fd;
struct evutil_addrinfo *aitop = NULL;
if (address == NULL && port == 0)
return bind_socket_ai_(NULL, 0);
aitop = make_addrinfo_(address, port);
if (aitop == NULL)
return -1;
fd = bind_socket_ai_(aitop, reuse);
evutil_freeaddrinfo(aitop);
return fd;
}
void dns_cb(int errcode, struct evutil_addrinfo *addr, void *ptr)
{
site_t *si = (site_t *) ptr;
const char *host = si->host;
if (errcode)
{
si->dns_state = ERROR_DNS;
statis.dns_err_sites++;
log_error("%s -> %s\n", host, evutil_gai_strerror(errcode));
}
else
{
struct evutil_addrinfo *ai;
if (addr->ai_canonname)
si->cname = strdup(addr->ai_canonname);
int i = 0;
for (ai = addr; ai; ai = ai->ai_next)
{
if (ai->ai_family == AF_INET)
{
if (i < MAX_ADDRS)
{
si->addr[i++] = *((struct sockaddr_in *)ai->ai_addr);
}
}
}
evutil_freeaddrinfo(addr);
if(i > 0)
{
si->dns_state = DONE_DNS;
si->next_call = (time_t)0;
statis.dns_ok_sites++;
if (!site_empty(si) && !si->in_ready_fifo)
{
ready_fifo_put(si);
}
}
}
statis.dns_calls--;
/* fetch_dns(); */
/* fetch_pages(); */
}
void Spider_Url_Rinse::dns_callback(int errcode, struct evutil_addrinfo *addr, void *ptr)
{
dns_cb_arg *arg = (dns_cb_arg *)ptr;
UrlPtr myurl = arg->url_ptr;
if (errcode)
{
LLOG(L_ERROR,"DNS parse error:%s -> %s\n", myurl->domain, evutil_gai_strerror(errcode));
}
else
{
struct evutil_addrinfo *ai=addr;
char buf[128];
const char *s = NULL;
if (addr->ai_family == AF_INET)
{
struct sockaddr_in *sin =(struct sockaddr_in *)ai->ai_addr;
s = evutil_inet_ntop(AF_INET, &sin->sin_addr, buf, 128); /*从套接口内部数据类型转换为点分十进制 */
}
else if (addr->ai_family == AF_INET6)
{
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai->ai_addr;
s = evutil_inet_ntop(AF_INET6, &sin6->sin6_addr, buf,128);
}
if (s)
{
myurl->ip=strdup(s);
arg->pthis->put_url_to_executor(myurl);
arg->pthis->m_dns_database[std::string(myurl->domain)] = std::string(myurl->ip);
arg->pthis->record_domain(myurl->domain);
}
evutil_freeaddrinfo(addr);
}
if (--g_pending_requests == 0)
{
event_base_loopexit(arg->pthis->m_evbase, NULL);
}
}
static void
test_getaddrinfo_async(void *arg)
{
struct basic_test_data *data = arg;
struct evutil_addrinfo hints, *a;
struct gai_outcome local_outcome;
struct gai_outcome a_out[12];
int i;
struct evdns_getaddrinfo_request *r;
char buf[128];
struct evdns_server_port *port = NULL;
ev_uint16_t dns_port = 0;
int n_dns_questions = 0;
struct evdns_base *dns_base = evdns_base_new(data->base, 0);
/* for localhost */
evdns_base_load_hosts(dns_base, NULL);
memset(a_out, 0, sizeof(a_out));
n_gai_results_pending = 10000; /* don't think about exiting yet. */
/* 1. Try some cases that will never hit the asynchronous resolver. */
/* 1a. Simple case with a symbolic service name */
memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
memset(&local_outcome, 0, sizeof(local_outcome));
r = evdns_getaddrinfo(dns_base, "1.2.3.4", "http",
&hints, gai_cb, &local_outcome);
tt_int_op(r,==,0);
if (!local_outcome.err) {
tt_ptr_op(local_outcome.ai,!=,NULL);
test_ai_eq(local_outcome.ai, "1.2.3.4:80", SOCK_STREAM, IPPROTO_TCP);
evutil_freeaddrinfo(local_outcome.ai);
local_outcome.ai = NULL;
} else {
void socks_resolvecb(int result, struct evutil_addrinfo *ai, void *arg)
{
struct conninfo *info = arg;
if (result) {
char buf[256];
evutil_snprintf(buf, sizeof(buf), "DNS Failure: %s",
evutil_gai_strerror(result));
finish_connection(info, 0, buf);
} else {
log_debug("conn: socks resolve %s",
format_addr(ai->ai_addr));
assert(ai->ai_addrlen <= sizeof(info->addr));
memcpy(&info->addr, ai->ai_addr, ai->ai_addrlen);
info->addr_len = ai->ai_addrlen;
bufferevent_socket_connect(info->bev,
(struct sockaddr*)&socks_addr,
socks_addr_len);
}
if (ai)
evutil_freeaddrinfo(ai);
}
int
conn_set_socks_server(const char *name, int port, enum socks_ver ver)
{
int ret;
int rv = -1;
struct evutil_addrinfo *ai = NULL;
struct evutil_addrinfo hint;
char portstr[NI_MAXSERV];
assert(ver != SOCKS_NONE);
evutil_snprintf(portstr, sizeof(portstr), "%d", port);
memset(&hint, 0, sizeof(hint));
hint.ai_family = AF_UNSPEC;
hint.ai_protocol = IPPROTO_TCP;
hint.ai_socktype = SOCK_STREAM;
hint.ai_flags = EVUTIL_AI_ADDRCONFIG;
ret = evutil_getaddrinfo(name, portstr, &hint, &ai);
if (!ret) {
rv = 0;
memset(&socks_addr, 0, sizeof(socks_addr));
memcpy(&socks_addr, ai->ai_addr, ai->ai_addrlen);
socks_addr_len = ai->ai_addrlen;
use_socks = ver;
log_notice("conn: socks server set to %s",
format_addr((struct sockaddr*)&socks_addr));
} else {
log_error("conn: can't resolve socks server %s: %s",
name, evutil_gai_strerror(ret));
}
if (ai)
evutil_freeaddrinfo(ai);
return rv;
}
/**
Given:
* comma-separated list of "<transport>-<bindaddr>" strings in 'all_bindaddrs'.
* comma-separated list of "<transport>" strings in 'all_transports'.
Return:
* 0, if
- all <transport> strings in 'all_bindaddrs' match with <transport>
strings in 'all_transports' (order matters).
AND
- if all <bindaddr> strings in 'all_bindaddrs' are valid addrports.
* -1, otherwise.
*/
int
validate_bindaddrs(const char *all_bindaddrs, const char *all_transports)
{
int ret,i,n_bindaddrs,n_transports;
struct evutil_addrinfo *bindaddr_test;
char *bindaddr = NULL;
char *transport = NULL;
/* a list of "<proto>-<bindaddr>" strings */
smartlist_t *bindaddrs = smartlist_create();
/* a list holding (<proto>, <bindaddr>) for each 'bindaddrs' entry */
smartlist_t *split_bindaddr = NULL;
/* a list of "<proto>" strings */
smartlist_t *transports = smartlist_create();
smartlist_split_string(bindaddrs, all_bindaddrs, ",",
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
smartlist_split_string(transports, all_transports, ",",
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
n_bindaddrs = smartlist_len(bindaddrs);
n_transports = smartlist_len(transports);
if (n_bindaddrs != n_transports)
goto err;
for (i=0;i<n_bindaddrs;i++) {
bindaddr = smartlist_get(bindaddrs, i);
transport = smartlist_get(transports, i);
split_bindaddr = smartlist_create();
smartlist_split_string(split_bindaddr, bindaddr, "-",
SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, -1);
/* (<proto>, <bindaddr>) */
if (smartlist_len(split_bindaddr) != 2)
goto err;
/* "all <transport> strings in 'all_bindaddrs' match with <transport>
strings in 'all_transports' (order matters)." */
if (strcmp(smartlist_get(split_bindaddr,0), transport))
goto err;
/* "if all <bindaddr> strings in 'all_bindaddrs' are valid addrports." */
bindaddr_test = resolve_address_port(smartlist_get(split_bindaddr, 1),
1, 1, NULL);
if (!bindaddr_test)
goto err;
evutil_freeaddrinfo(bindaddr_test);
SMARTLIST_FOREACH(split_bindaddr, char *, cp, free(cp));
smartlist_free(split_bindaddr);
split_bindaddr = NULL;
}
ret = 0;
goto done;
err:
ret = -1;
done:
SMARTLIST_FOREACH(bindaddrs, char *, cp, free(cp));
smartlist_free(bindaddrs);
SMARTLIST_FOREACH(transports, char *, cp, free(cp));
smartlist_free(transports);
if (split_bindaddr) {
SMARTLIST_FOREACH(split_bindaddr, char *, cp, free(cp));
smartlist_free(split_bindaddr);
}
return ret;
}
void CDNSResponse::clear()
{
if (m_ai != nullptr)
evutil_freeaddrinfo(m_ai);
m_ai = nullptr;
}
void dns_query_cb(int errcode, struct evutil_addrinfo *addr, void *ptr)
{
P_DNS_STRUCT p_dns = (P_DNS_STRUCT)ptr;
if (errcode)
{
printf("Query error for: %s -> %s\n", p_dns->hostname, evutil_gai_strerror(errcode));
}
else
{
struct evutil_addrinfo *ai;
struct sockaddr_in sin;
for (ai = addr; ai; ai = ai->ai_next)
{
if (ai->ai_family == AF_INET)
{
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr = ((struct sockaddr_in *)ai->ai_addr)->sin_addr;
sin.sin_port = p_dns->port;
st_d_print("REQUEST: %s:%d", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
int remote_socket = ss_connect_srv(&sin);
if (remote_socket == -1)
{
st_d_error("REQUEST: %s:%d FAILED!", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
continue;
}
evutil_make_socket_nonblocking(p_dns->p_c_item->socket);
struct bufferevent *new_bev =
bufferevent_socket_new(p_dns->p_threadobj->base, p_dns->p_c_item->socket, BEV_OPT_CLOSE_ON_FREE);
assert(new_bev);
bufferevent_setcb(new_bev, thread_bufferread_cb_enc, NULL, thread_bufferevent_cb, p_dns->p_trans);
bufferevent_enable(new_bev, EV_READ|EV_WRITE);
evutil_make_socket_nonblocking(remote_socket);
struct bufferevent *new_ext_bev =
bufferevent_socket_new(p_dns->p_threadobj->base, remote_socket , BEV_OPT_CLOSE_ON_FREE);
assert(new_ext_bev);
bufferevent_setcb(new_ext_bev, thread_bufferread_cb_enc, NULL, thread_bufferevent_cb, p_dns->p_trans);
bufferevent_enable(new_ext_bev, EV_READ|EV_WRITE);
p_dns->p_trans->bev_d = new_bev;
p_dns->p_trans->bev_u = new_ext_bev;
st_d_print("DDDDD: 当前活动连接数：[[[ %d ]]], 任务队列：[[ %d ]]",
slist_count(&p_dns->p_trans->p_activ_item->trans),
slist_count(&p_dns->p_threadobj->conn_queue));
st_d_print("SS5激活客户端Bufferevent使能！");
CTL_HEAD head;
memset(&head, 0, CTL_HEAD_LEN);
head.direct = USR_DAEMON;
head.cmd = HD_CMD_SS5_ACT;
head.extra_param = p_dns->p_trans->usr_lport;
head.mach_uuid = p_dns->p_trans->p_activ_item->mach_uuid;
bufferevent_write(p_dns->p_trans->p_activ_item->bev_daemon, &head, CTL_HEAD_LEN);
break;
}
st_d_print("ALL REQUEST FOR %s FAILED!", p_dns->hostname);
}
evutil_freeaddrinfo(addr);
}
free(p_dns->p_c_item);
free(p_dns);
return;
}
