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; }