/**
* curl_global_cleanup() globally cleanups cURL, uses the value of
* "init_flags" to determine what needs to be cleaned up and what doesn't.
*/
void curl_global_cleanup(void)
{
if(!initialized)
return;
if(--initialized)
return;
Curl_global_host_cache_dtor();
if(init_flags & CURL_GLOBAL_SSL)
Curl_ssl_cleanup();
#ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP
ares_library_cleanup();
#endif
if(init_flags & CURL_GLOBAL_WIN32)
win32_cleanup();
#ifdef __AMIGA__
amiga_cleanup();
#endif
init_flags = 0;
}
~CAresLibInit()
{
if(init_)
{
init_ = false;
ares_library_cleanup();
}
}
void
resolv_shutdown(struct ev_loop *loop)
{
ares_cancel(default_ctx.channel);
ares_destroy(default_ctx.channel);
ares_library_cleanup();
}
int main (int argc, char *argv[]) {
struct ev_loop *loop = EV_DEFAULT;
if (argc < 2) { fprintf(stderr, "Usage:\n\t%s domain\n",argv[0]); return 1; }
char *hostname = argv[1];
char *jabber = calloc(1,strlen(argv[1]) + strlen(JSRV) + 1); // will be freed on exit ;)
strcat(jabber,JSRV);
strcat(jabber,argv[1]);
// Declare resolver struct;
ev_ares resolver;
printf("Resolving '%s'\n",hostname);
// Initialize ares library.
int status;
if ((status = ares_library_init(ARES_LIB_INIT_ALL) )!= ARES_SUCCESS) {
fprintf(stderr,"Ares error: %s\n",ares_strerror(status));
return 1;
}
//Initialize resolver with timeout 1.3
if (( status = ev_ares_init(&resolver, 1.3) ) != ARES_SUCCESS) {
fprintf(stderr,"Ares error: %s\n",ares_strerror(status));
return 1;
}
// hostname variable must not be freed until resolve callback, since it referenced as result->host
ev_ares_soa(loop,&resolver,hostname,0,callback_soa);
ev_ares_ns(loop,&resolver,hostname,0,callback_ns);
ev_ares_a(loop,&resolver,hostname,0,callback_a);
ev_ares_aaaa(loop,&resolver,hostname,0,callback_aaaa);
ev_ares_mx(loop,&resolver,hostname,0,callback_mx);
ev_ares_srv(loop,&resolver,jabber,0,callback_srv);
ev_ares_txt(loop,&resolver,hostname,0,callback_txt);
ev_ares_gethostbyaddr(loop,&resolver,"8.8.8.8", 0, callback_hba);
ev_ares_gethostbyaddr(loop,&resolver,"2a00:1450:4010:c04::66", 0,callback_hba);
// Raw PTR queries
ev_ares_ptr(loop,&resolver,"8.8.8.8.in-addr.arpa", 0,callback_ptr);
ev_ares_ptr(loop,&resolver,"a.8.0.0.0.0.0.0.0.0.0.0.0.0.0.0.4.0.c.0.0.1.0.4.0.5.4.1.0.0.a.2.ip6.arpa", 0,callback_ptr);
//This is the only NAPTR example i found ;)
ev_ares_naptr(loop,&resolver,"0.2.0.1.1.6.5.1.0.3.1.loligo.com.",0,callback_naptr);
// Run loop
ev_run (loop, 0);
free(jabber);
ev_ares_clean(&resolver);
ares_library_cleanup();
}
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;
}
int main(int argc, char *argv[]) {
g_assert(st_set_eventsys(ST_EVENTSYS_ALT) == 0);
st_init();
int status = ares_library_init(ARES_LIB_INIT_ALL);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
return 1;
}
int sock;
int n;
struct sockaddr_in serv_addr;
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket");
}
n = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&n, sizeof(n)) < 0) {
perror("setsockopt SO_REUSEADDR");
}
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(8080);
serv_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
perror("bind");
}
if (listen(sock, 10) < 0) {
perror("listen");
}
st_netfd_t server_nfd = st_netfd_open_socket(sock);
st_netfd_t client_nfd;
struct sockaddr_in from;
int fromlen = sizeof(from);
for (;;) {
client_nfd = st_accept(server_nfd,
(struct sockaddr *)&from, &fromlen, ST_UTIME_NO_TIMEOUT);
printf("accepted\n");
if (st_thread_create(handle_connection,
(void *)client_nfd, 0, 1024 * 1024) == NULL)
{
fprintf(stderr, "st_thread_create error\n");
}
}
ares_library_cleanup();
return EXIT_SUCCESS;
}
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);
}
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;
}
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;
}
}
int main(int argc, char *argv[]) {
int status;
st_init();
status = ares_library_init(ARES_LIB_INIT_ALL);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
return 1;
}
st_thread_t t = st_thread_create(do_lookup, (void *)"A", 1, 1024 * 128);
st_thread_t t2 = st_thread_create(do_lookup, (void *)"B", 1, 1024 * 128);
st_thread_join(t, NULL);
st_thread_join(t2, NULL);
ares_library_cleanup();
return 0;
}
void _mosquitto_net_cleanup(void)
{
#ifdef WITH_TLS
ERR_remove_state(0);
ENGINE_cleanup();
CONF_modules_unload(1);
ERR_free_strings();
EVP_cleanup();
CRYPTO_cleanup_all_ex_data();
#endif
#ifdef WITH_SRV
ares_library_cleanup();
#endif
#ifdef WIN32
WSACleanup();
#endif
}
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 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);
}
// 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];
}
int
ecore_con_info_init(void)
{
struct ares_options opts;
if (!info_init)
{
if (ares_library_init(ARES_LIB_INIT_ALL))
return 0;
opts.lookups = "fb"; /* hosts file then dns */
opts.sock_state_cb = _ecore_con_info_cares_state_cb;
if (ares_init_options(&info_channel, &opts,
ARES_OPT_LOOKUPS | ARES_OPT_SOCK_STATE_CB) != ARES_SUCCESS)
{
ares_library_cleanup();
return 0;
}
}
info_init++;
return info_init;
}
int main(int argc, char **argv)
{
struct ares_options options;
int optmask = 0;
ares_channel channel;
int status, nfds, c, addr_family = AF_INET;
fd_set read_fds, write_fds;
struct timeval *tvp, tv;
struct in_addr addr4;
struct ares_in6_addr addr6;
#ifdef USE_WINSOCK
WORD wVersionRequested = MAKEWORD(USE_WINSOCK,USE_WINSOCK);
WSADATA wsaData;
WSAStartup(wVersionRequested, &wsaData);
#endif
memset(&options, 0, sizeof(options));
status = ares_library_init(ARES_LIB_INIT_ALL);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_library_init: %s\n", ares_strerror(status));
return 1;
}
while ((c = ares_getopt(argc,argv,"dt:hs:")) != -1)
{
switch (c)
{
case 'd':
#ifdef WATT32
dbug_init();
#endif
break;
case 's':
optmask |= ARES_OPT_DOMAINS;
options.ndomains++;
options.domains = realloc(options.domains,
options.ndomains * sizeof(char *));
options.domains[options.ndomains - 1] = strdup(optarg);
break;
case 't':
if (!strcasecmp(optarg,"a"))
addr_family = AF_INET;
else if (!strcasecmp(optarg,"aaaa"))
addr_family = AF_INET6;
else if (!strcasecmp(optarg,"u"))
addr_family = AF_UNSPEC;
else
usage();
break;
case 'h':
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc < 1)
usage();
status = ares_init_options(&channel, &options, optmask);
if (status != ARES_SUCCESS)
{
fprintf(stderr, "ares_init: %s\n", ares_strerror(status));
return 1;
}
/* Initiate the queries, one per command-line argument. */
for ( ; *argv; argv++)
{
if (ares_inet_pton(AF_INET, *argv, &addr4) == 1)
{
ares_gethostbyaddr(channel, &addr4, sizeof(addr4), AF_INET, callback,
*argv);
}
else if (ares_inet_pton(AF_INET6, *argv, &addr6) == 1)
{
ares_gethostbyaddr(channel, &addr6, sizeof(addr6), AF_INET6, callback,
*argv);
}
else
{
ares_gethostbyname(channel, *argv, addr_family, callback, *argv);
}
}
/* Wait for all queries to complete. */
for (;;)
{
int res;
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);
res = select(nfds, &read_fds, &write_fds, NULL, tvp);
if (-1 == res)
break;
ares_process(channel, &read_fds, &write_fds);
}
ares_destroy(channel);
ares_library_cleanup();
#ifdef USE_WINSOCK
WSACleanup();
#endif
return 0;
}
/*
* Curl_resolver_global_cleanup()
*
* Called from curl_global_cleanup() to destroy global resolver environment.
* Deinitializes ares library.
*/
void Curl_resolver_global_cleanup(void)
{
#ifdef CARES_HAVE_ARES_LIBRARY_CLEANUP
ares_library_cleanup();
#endif
}
~TAres() {
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;
}
LLAres::~LLAres()
{
ares_destroy(chan_);
ares_library_cleanup();
}
/* Init function to start auth worker threads and adns thread.
It also initializes the c-ares library and c-ares channel*/
int auth_mgr_init(uint32_t init_flags)
{
int ret,flags;
NKN_MUTEX_INIT(&authreq_mutex, NULL, "authreq_mutex");
/***********************************************************
* We do not need this for now, but will eventually need
* to handle the auth taks, key management etcc..
***********************************************************/
if (init_flags & AUTH_MGR_INIT_START_WORKER_TH) {
int32_t i;
for (i=0; i<MAX_AM_THREADS; i++) {
DBG_LOG(MSG, MOD_AUTHMGR,
"Thread %d created for Auth Manager",i);
if(pthread_create(&auththr[i], NULL,
auth_mgr_input_handler_thread, (void *)&i) != 0) {
DBG_LOG(SEVERE, MOD_AUTHMGR,
"Failed to create authmgr threads %d",i);
DBG_ERR(SEVERE, "Failed to create authmgr threads %d",i);
return -1;
}
}
}
auth_htbl_list_init();
/*All the c-ares relates stuff goes in here*/
if (adnsd_enabled) {
return adns_client_init();
}
flags = ARES_LIB_INIT_ALL;
ares_library_cleanup();
ret = ares_library_init(flags);
if (ret != ARES_SUCCESS) {
DBG_LOG(SEVERE, MOD_AUTHMGR,"ares_library_init: %d %s", ret,
ares_strerror(ret));
return -1;
}
optmask = ARES_OPT_FLAGS|ARES_OPT_TIMEOUT|ARES_OPT_TRIES;
options.flags = ARES_FLAG_STAYOPEN|ARES_FLAG_IGNTC|ARES_FLAG_NOCHECKRESP;
options.timeout = DNS_MAX_TIMEOUT;
options.tries = DNS_MAX_RETRIES;
ret = ares_init_options(&channel, &options, optmask);
if (ret != ARES_SUCCESS) {
DBG_LOG(SEVERE, MOD_AUTHMGR,"ares_init: %d %s", ret,
ares_strerror(ret) );
return -1;
}
channel_ready = 1;
/* Additionally one more thread needs to handle all
the DNS queries, so starting it here*/
if (pthread_create(&adnsthr, NULL, auth_mgr_adns_handler_epoll, NULL) != 0) {
DBG_LOG(SEVERE, MOD_AUTHMGR,
"Failed to create adns thread");
DBG_ERR(SEVERE,"Failed to create adns thread");
return -1;
}
return 0;
}