vector<TSrvRecord> GetRecords(const string& host) const {
ares_channel channel;
int status;
status = ares_init(&channel);
if(status != ARES_SUCCESS) {
throw UException(std::string("Failed to init ares channel: ") + ares_strerror(status));
}
TCallbackInfo info;
ares_query(channel, host.c_str(), ns_c_in, ns_t_srv, callback, &info);
wait_ares(channel);
ares_destroy(channel);
if (info.Status != ARES_SUCCESS) {
throw UException(std::string("Failed to make ares request: ") + ares_strerror(info.Status));
}
struct ares_srv_reply* reply;
status = ares_parse_srv_reply((const unsigned char*)info.Data.data(), info.Data.length(), &reply);
if (info.Status != ARES_SUCCESS) {
throw UException(std::string("Failed to parse response: ") + ares_strerror(status));
}
vector<TSrvRecord> records;
struct ares_srv_reply* next = reply;
while (next != NULL) {
TSrvRecord record;
record.Host = next->host;
record.Port = next->port;
record.Priority = next->priority;
record.Weight = next->weight;
records.push_back(record);
next = next->next;
}
ares_free_data(reply);
return records;
}
/* release memory */
void uv_ares_destroy(uv_loop_t* loop, ares_channel channel) {
/* only allow destroy if did init */
if (loop->ares_chan != NULL) {
ares_destroy(channel);
loop->ares_chan = NULL;
}
}
static void free_chan(ph_dns_channel_t *chan)
{
ares_destroy(chan->chan);
ph_ht_destroy(&chan->sock_map);
pthread_mutex_destroy(&chan->chanlock);
ph_mem_free(mt.chan, chan);
}
/* Finds the SRV records for the given host. It returns the target IP
* address and fills the port and transport if a suitable SRV record
* exists. Otherwise it returns 0. The function follows 3263: first
* TLS, then TCP and finally UDP. */
unsigned long getsrvadr(char *host, int *port, unsigned int *transport) {
unsigned long adr = 0;
#ifdef HAVE_SRV
int srvport = 5060;
#ifdef HAVE_CARES_H
int status;
int optmask = ARES_OPT_FLAGS;
struct ares_options options;
options.flags = ARES_FLAG_NOCHECKRESP;
options.servers = NULL;
options.nservers = 0;
status = ares_init_options(&channel, &options, optmask);
if (status != ARES_SUCCESS) {
printf("error: failed to initialize ares\n");
exit_code(2);
}
#endif
#ifdef WITH_TLS_TRANSP
adr = getsrvaddress(host, &srvport, SRV_SIP_TLS);
if (adr != 0) {
*transport = SIP_TLS_TRANSPORT;
if (verbose > 1)
printf("using SRV record: %s.%s:%i\n", SRV_SIP_TLS, host, srvport);
printf("TLS transport not yet supported\n");
exit_code(2);
}
else {
#endif
adr = getsrvaddress(host, &srvport, SRV_SIP_TCP);
if (adr != 0) {
*transport = SIP_TCP_TRANSPORT;
if (verbose > 1)
printf("using SRV record: %s.%s:%i\n", SRV_SIP_TCP, host, srvport);
}
else {
adr = getsrvaddress(host, &srvport, SRV_SIP_UDP);
if (adr != 0) {
*transport = SIP_UDP_TRANSPORT;
if (verbose > 1)
printf("using SRV record: %s.%s:%i\n", SRV_SIP_UDP, host, srvport);
}
}
#ifdef WITH_TLS_TRANSP
}
#endif
#ifdef HAVE_CARES_H
ares_destroy(channel);
#endif
*port = srvport;
#endif // HAVE_SRV
return adr;
}
/* TODO share this with windows? */
void uv_ares_destroy(uv_loop_t* loop, ares_channel channel) {
/* only allow destroy if did init */
if (loop->channel) {
uv__ares_timer_stop(loop);
ares_destroy(channel);
loop->channel = NULL;
}
}
/* TODO share this with windows? */
void uv_ares_destroy(ares_channel channel) {
/* only allow destroy if did init */
if (ares_data.channel != NULL) {
ev_timer_stop(EV_DEFAULT_UC_ &ares_data.timer);
ares_destroy(channel);
ares_data.channel = NULL;
}
}
void
resolv_shutdown(struct ev_loop *loop)
{
ares_cancel(default_ctx.channel);
ares_destroy(default_ctx.channel);
ares_library_cleanup();
}
static PyObject *
Channel_func_destroy(Channel *self)
{
CHECK_CHANNEL(self);
ares_destroy(self->channel);
self->channel = NULL;
Py_RETURN_NONE;
}
int main(void) {
ares_channel channelptr;
ares_init(&channelptr);
ares_destroy(channelptr);
return 0;
}
struct hostent *nssrs_resolver_by_servers(char *name, char *nameserver) {
ares_channel channel = NULL;
int status, optmask = 0;
struct ares_options options;
struct hostent *results;
status = ares_library_init(ARES_LIB_INIT_ALL);
if (status != ARES_SUCCESS) {
debug("ares_library_init: %s\n", ares_strerror(status));
return NULL;
}
optmask = ARES_OPT_SERVERS | ARES_OPT_UDP_PORT;
options.servers = NULL;
options.nservers = 0;
options.flags = ARES_FLAG_NOCHECKRESP;
status = ares_init_options(&channel, &options, optmask);
if(status != ARES_SUCCESS) {
debug("ares_init_options: %s\n", ares_strerror(status));
return NULL;
}
status = ares_set_servers_csv(channel, nameserver);
if (status != ARES_SUCCESS) {
debug("ares_set_servers_csv: %s\n", ares_strerror(status));
ares_destroy(channel);
ares_library_cleanup();
return NULL;
}
// Wait resolver
results = malloc(sizeof(struct hostent));
ares_gethostbyname(channel, name, AF_INET, &callback, results);
wait_ares(channel);
ares_destroy(channel);
ares_library_cleanup();
if (results->h_name != NULL) {
return results;
}
free(results);
return NULL;
}
Resolver::~Resolver()
{
TORNADO_LOG_DEBUG_STR("---------------------------~Resolver");
if(channel_)
{
ares_destroy(channel_);
channel_ = nullptr;
}
cb_ = nullptr;
}
/* the cleanup routine */
int
cleanup_dnsblc(void *state)
{
ares_channel *channel;
channel = (ares_channel *)state;
ares_destroy(*channel);
Free(channel);
return 0;
}
static void
Channel_tp_dealloc(Channel *self)
{
if (self->channel) {
ares_destroy(self->channel);
self->channel = NULL;
}
if (self->lib_initialized) {
ares_library_cleanup();
}
Channel_tp_clear(self);
Py_TYPE(self)->tp_free((PyObject *)self);
}
void got_error() {
if( curl )
curl_easy_cleanup(curl);
curl = 0;
if( ares )
ares_destroy( ares );
ares = 0;
if( headers ) {
curl_slist_free_all(headers);
}
headers = 0;
canceling = false;
relocating = false;
state = kError;
}
void OnEventDNSTask(int fd, short event, void *arg) {
struct DNSTask *dnstask = (struct DNSTask *) arg;
debug("event:%s, LobjId:%d, Hostname %s", getActionText(event), dnstask->task->LObjId, dnstask->task->Record.HostName);
if (event & EV_READ) {
ares_process_fd(dnstask->channel, fd, ARES_SOCKET_BAD);
} else if (event & EV_TIMEOUT) {
dnstask->task->code = STATE_TIMEOUT;
dnstask->task->callback(dnstask->task);
}
if (!dnstask->isNeed) {
ares_destroy(dnstask->channel);
event_del(&dnstask->ev);
}
}
int
ecore_con_info_shutdown(void)
{
info_init--;
if (info_init == 0)
{
/* Cancel all ongoing request */
ares_cancel(info_channel);
ares_destroy(info_channel);
/* Shutdown ares */
ares_library_cleanup();
}
return info_init;
}
void dns_finish_queries(listhead_t *activelist)
{
listitem_t *walk;
for (walk = activelist->head; (walk); walk = walk->next) {
myconn_t *rec = (myconn_t *)walk->data;
if (rec->talkprotocol != TALK_PROTO_DNSQUERY) continue;
if (rec->dnsstatus != DNS_QUERY_COMPLETED) continue;
dbgprintf("DNS query %s cleanup\n", rec->testspec);
ares_destroy(*((ares_channel *)rec->dnschannel));
xfree(rec->dnschannel);
rec->dnsstatus = DNS_FINISHED;
}
/* Nothing to do for the lookup channel */
}
DNSHandler::DNSHandler (PanicType panic) : stop(false), panic(std::move(panic)) {
// Setup the completion callback
complete=[this] (Query * q, bool) mutable noexcept {
lock.Execute([&] () mutable { queries.erase(q); });
};
// Check panic callback, if it's empty,
// default it to std::abort
if (!panic) panic=[] (std::exception_ptr) { std::abort(); };
// Initialize libcares
auto result=ares_library_init(ARES_LIB_INIT_ALL);
if (result!=0) raise(result);
try {
// Prepare an asynchronous resolver
// channel
if ((result=ares_init(&channel))!=0) raise(result);
try {
// Create worker thread
thread=Thread([this] () mutable { worker_func(); });
} catch (...) {
ares_destroy(channel);
throw;
}
} catch (...) {
ares_library_cleanup();
throw;
}
}
void start_resolve() {
if( ares ) {
ares_destroy(ares);
ares = 0;
}
state = kResolving;
std::string actual_url = redirect_url.size() ? redirect_url:url;
std::string host = extract_host(actual_url);
std::string res = dns_cache->get_ent(host);
if( !res.size() ) {
ares_init(&ares);
ares_gethostbyname(ares,host.c_str(),AF_INET,Request::GotResolveStatic,this);
} else {
char buf[1024];
sprintf(buf,"%d.%d.%d.%d",res[0],res[1],res[2],res[3]);
direct_ip = buf;
state = kStartDownload;
}
}
void cleanup() {
if( curl ) {
curl_easy_cleanup(curl);
}
curl = 0;
if( ares )
ares_destroy( ares );
ares = 0;
if( headers ) {
curl_slist_free_all(headers);
}
headers = 0;
errmsg = "";
content = "";
url = "";
state = kNone;
canceling = false;
relocating = false;
}
DNSHandler::~DNSHandler () noexcept {
// Shutdown the worker
try {
issue_command(true);
} catch (...) {
try {
panic(std::current_exception());
} catch (...) { }
// If the panic function returns,
// we can't do anything constructive
// at this point, so kill the whole
// process.
std::abort();
}
lock.Execute([&] () mutable {
stop=true;
wait.WakeAll();
});
thread.Join();
// Cleanup the asynchronous resolver channel
ares_destroy(channel);
// Cleanup libcares
ares_library_cleanup();
}
void got_done() {
if( curl )
curl_easy_cleanup(curl);
curl = 0;
if( ares )
ares_destroy( ares );
ares = 0;
if( headers ) {
curl_slist_free_all(headers);
}
headers = 0;
if( relocating ) {
relocating = false;
state = kStarting;
start(curlm,curlsh,dns_cache);
} else {
state = kOK;
canceling = false;
relocating = false;
}
}
// Bad synchronous gethostbyname demo
uint32_t tm__sync_gethostbyname (const char *domain)
{
ares_channel channel;
int status;
struct ares_options options;
int optmask = 0;
ipaddr[0] = ipaddr[1] = ipaddr[2] = ipaddr[3] = 0;
struct in_addr ns1;
inet_aton("8.8.8.8",&ns1);
status = ares_library_init(ARES_LIB_INIT_ALL);
if (status != ARES_SUCCESS){
printf("ares_library_init: %s\n", ares_strerror(status));
return 1;
}
options.servers = &ns1;
options.nservers = 1;
optmask |= ARES_OPT_SERVERS;
options.sock_state_cb = state_cb;
// options.sock_state_cb_data;
optmask |= ARES_OPT_SOCK_STATE_CB;
status = ares_init_options(&channel, &options, optmask);
if(status != ARES_SUCCESS) {
printf("ares_init_options: %s\n", ares_strerror(status));
return 1;
}
ares_gethostbyname(channel, domain, AF_INET, callback, NULL);
wait_ares(channel);
ares_destroy(channel);
ares_library_cleanup();
// printf("fin\n");
// printf("result => %d.%d.%d.%d\n", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
return (ipaddr[0] << 24) | (ipaddr[1] << 16) | (ipaddr[2] << 8) | ipaddr[3];
}
void APE_destroy(ape_global *ape)
{
// destroying dns
struct _ares_sockets *as;
size_t i;
ares_cancel(ape->dns.channel);
as = ape->dns.sockets.list;
for (i = 0; i < ape->dns.sockets.size; i++) {
events_del(as->s.fd, ape);
as++;
}
free(ape->dns.sockets.list);
ape->dns.sockets.size = 0;
ape->dns.sockets.used = 0;
ares_destroy(ape->dns.channel);
ares_library_cleanup();
// destroying events
events_destroy(&ape->events);
// destroying timers
APE_timers_destroy_all(ape);
if (ape->ssl_global_ctx) {
ape_ssl_shutdown(ape->ssl_global_ctx);
ape_ssl_destroy(ape->ssl_global_ctx);
}
ape_ssl_library_destroy();
close(ape->urandom_fd);
if (ape->logger.cleanup) {
ape->logger.cleanup(ape->logger.ctx, ape->logger.cb_args);
}
// destroying rest
free(ape);
pthread_setspecific(g_APEThreadContextKey, NULL);
}
eNextState ShutDownCLient(AsyncIO *IO)
{
CitContext *Ctx =IO->CitContext;
SetEVState(IO, eExit);
become_session(Ctx);
EVM_syslog(LOG_DEBUG, "EVENT Terminating \n");
StopClientWatchers(IO, 1);
if (IO->DNS.Channel != NULL) {
ares_destroy(IO->DNS.Channel);
EV_DNS_LOG_STOP(DNS.recv_event);
EV_DNS_LOG_STOP(DNS.send_event);
ev_io_stop(event_base, &IO->DNS.recv_event);
ev_io_stop(event_base, &IO->DNS.send_event);
IO->DNS.Channel = NULL;
}
assert(IO->Terminate);
return IO->Terminate(IO);
}
void tt_dns_destroy_ntv(IN ares_channel ch)
{
__dskt_t *dskt = (__dskt_t *)ch->sock_create_cb_data;
int n = __DSKT_NUM(ch);
// ares_destroy() need access dskt array as it would close
// all sockets. so ares_destroy() must be called before
// __dskt_destroy()
ares_destroy(ch);
if (dskt != NULL) {
int i;
for (i = 0; i < n; ++i) {
// no matter whether the dskt is in reading or writing
// as this function is generally called when io poller
// thread is terminated, __do_read/write/connect won't
// be called
__dskt_destroy(&dskt[i]);
}
tt_free(dskt);
}
}
void step() {
if( state == kResolving ) {
if( ares ) {
if( canceling ) {
ares_cancel(ares);
}
int nfds, count;
fd_set readers, writers;
struct timeval tv, maxtv, *tvp;
FD_ZERO(&readers);
FD_ZERO(&writers);
nfds = ares_fds(ares, &readers, &writers);
maxtv.tv_sec = 0;
maxtv.tv_usec = 1000;
if (nfds == 0) {
ares_process(ares, NULL, NULL);
} else {
tvp = ares_timeout(ares, &maxtv, &tv);
count = select(nfds, &readers, &writers, NULL, tvp);
ares_process(ares, &readers, &writers);
}
}
}
if( state == kStartDownload ) {
if( ares )
ares_destroy( ares );
ares = 0;
start_curl();
}
if( state == kFinishingOK ) {
got_done();
}
if( state == kFinishingError ) {
got_error();
}
// Nothing to do with other states
}
/*
* Curl_resolver_cleanup()
*
* Called from curl_easy_cleanup() -> Curl_close() to cleanup resolver
* URL-state specific environment ('resolver' member of the UrlState
* structure). Destroys the ares channel.
*/
void Curl_resolver_cleanup(void *resolver)
{
ares_destroy((ares_channel)resolver);
}
LLAres::~LLAres()
{
ares_destroy(chan_);
ares_library_cleanup();
}
int main(int argc, char **argv)
{
ares_channel channel;
int c, i, optmask = ARES_OPT_FLAGS, dnsclass = C_IN, type = T_A;
int status, nfds, count;
struct ares_options options;
struct hostent *hostent;
fd_set read_fds, write_fds;
struct timeval *tvp, tv;
struct ares_addr_node *srvr, *servers = NULL;
#ifdef USE_WINSOCK
WORD wVersionRequested = MAKEWORD(USE_WINSOCK,USE_WINSOCK);
WSADATA wsaData;
WSAStartup(wVersionRequested, &wsaData);
#endif
status = ares_library_init(ARES_LIB_INIT_ALL);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
return 1;
}
options.flags = ARES_FLAG_NOCHECKRESP;
options.servers = NULL;
options.nservers = 0;
while ((c = ares_getopt(argc, argv, "df:s:c:t:T:U:")) != -1)
{
switch (c)
{
case 'd':
#ifdef WATT32
dbug_init();
#endif
break;
case 'f':
/* Add a flag. */
for (i = 0; i < nflags; i++)
{
if (strcmp(flags[i].name, optarg) == 0)
break;
}
if (i < nflags)
options.flags |= flags[i].value;
else
usage();
break;
case 's':
/* User-specified name servers override default ones. */
srvr = malloc(sizeof(struct ares_addr_node));
if (!srvr)
{
fprintf(stderr, "Out of memory!\n");
destroy_addr_list(servers);
return 1;
}
append_addr_list(&servers, srvr);
if (ares_inet_pton(AF_INET, optarg, &srvr->addr.addr4) > 0)
srvr->family = AF_INET;
else if (ares_inet_pton(AF_INET6, optarg, &srvr->addr.addr6) > 0)
srvr->family = AF_INET6;
else
{
hostent = gethostbyname(optarg);
if (!hostent)
{
fprintf(stderr, "adig: server %s not found.\n", optarg);
destroy_addr_list(servers);
return 1;
}
switch (hostent->h_addrtype)
{
case AF_INET:
srvr->family = AF_INET;
memcpy(&srvr->addr.addr4, hostent->h_addr,
sizeof(srvr->addr.addr4));
break;
case AF_INET6:
srvr->family = AF_INET6;
memcpy(&srvr->addr.addr6, hostent->h_addr,
sizeof(srvr->addr.addr6));
break;
default:
fprintf(stderr,
"adig: server %s unsupported address family.\n", optarg);
destroy_addr_list(servers);
return 1;
}
}
/* Notice that calling ares_init_options() without servers in the
* options struct and with ARES_OPT_SERVERS set simultaneously in
* the options mask, results in an initialization with no servers.
* When alternative name servers have been specified these are set
* later calling ares_set_servers() overriding any existing server
* configuration. To prevent initial configuration with default
* servers that will be discarded later, ARES_OPT_SERVERS is set.
* If this flag is not set here the result shall be the same but
* ares_init_options() will do needless work. */
optmask |= ARES_OPT_SERVERS;
break;
case 'c':
/* Set the query class. */
for (i = 0; i < nclasses; i++)
{
if (strcasecmp(classes[i].name, optarg) == 0)
break;
}
if (i < nclasses)
dnsclass = classes[i].value;
else
usage();
break;
case 't':
/* Set the query type. */
for (i = 0; i < ntypes; i++)
{
if (strcasecmp(types[i].name, optarg) == 0)
break;
}
if (i < ntypes)
type = types[i].value;
else
usage();
break;
case 'T':
/* Set the TCP port number. */
if (!ISDIGIT(*optarg))
usage();
options.tcp_port = (unsigned short)strtol(optarg, NULL, 0);
optmask |= ARES_OPT_TCP_PORT;
break;
case 'U':
/* Set the UDP port number. */
if (!ISDIGIT(*optarg))
usage();
options.udp_port = (unsigned short)strtol(optarg, NULL, 0);
optmask |= ARES_OPT_UDP_PORT;
break;
}
}
argc -= optind;
argv += optind;
if (argc == 0)
usage();
status = ares_init_options(&channel, &options, optmask);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_init_options: %s\n",
ares_strerror(status));
return 1;
}
if(servers)
{
status = ares_set_servers(channel, servers);
destroy_addr_list(servers);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_init_options: %s\n",
ares_strerror(status));
return 1;
}
}
/* Initiate the queries, one per command-line argument. If there is
* only one query to do, supply NULL as the callback argument;
* otherwise, supply the query name as an argument so we can
* distinguish responses for the user when printing them out.
*/
if (argc == 1)
ares_query(channel, *argv, dnsclass, type, callback, (char *) NULL);
else
{
for (; *argv; argv++)
ares_query(channel, *argv, dnsclass, type, callback, *argv);
}
/* Wait for all queries to complete. */
for (;;)
{
FD_ZERO(&read_fds);
FD_ZERO(&write_fds);
nfds = ares_fds(channel, &read_fds, &write_fds);
if (nfds == 0)
break;
tvp = ares_timeout(channel, NULL, &tv);
count = select(nfds, &read_fds, &write_fds, NULL, tvp);
if (count < 0 && SOCKERRNO != EINVAL)
{
perror("select");
return 1;
}
ares_process(channel, &read_fds, &write_fds);
}
ares_destroy(channel);
ares_library_cleanup();
#ifdef USE_WINSOCK
WSACleanup();
#endif
return 0;
}
