void TS3::telnetClientThread(TS3 * parent, std::string server)
{
int port = 10011;
parent->_base = event_base_new();
parent->_dns_base = evdns_base_new(parent->_base, 1);
evthread_use_pthreads();
evthread_make_base_notifiable(parent->_base);
parent->_msg_event = event_new(parent->_base, -1, EV_READ, sendTS3message, parent);
event_add(parent->_msg_event, nullptr);
parent->_bev = bufferevent_socket_new(parent->_base, -1, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(parent->_bev, telnetMessage, nullptr, telnetEvent, parent);
bufferevent_enable(parent->_bev, EV_READ|EV_WRITE);
timeval t;
t.tv_sec = 60;
t.tv_usec = 0;
bufferevent_set_timeouts(parent->_bev, &t, nullptr);
bufferevent_socket_connect_hostname(
parent->_bev, parent->_dns_base, AF_UNSPEC, server.c_str(), port);
// FIXME needs a reliable restart mechanism
auto result = event_base_dispatch(parent->_base);
if (result == -1)
LOG(ERROR) << "Failed to start event loop";
}
bufferevent * connect_by_host(struct event_base *base, const char * host,int port)
{
bufferevent * bev =NULL;
do
{
struct evdns_base *dns_base = evdns_base_new(base, 1);
char * fname = evdns_get_default_hosts_filename();
if (0!=evdns_base_load_hosts(dns_base, fname))
{
printf("evdns_base_load_hosts failed! \n");
}
if (fname)
free(fname);
bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
if (NULL==bev)
{
printf("bufferevent_socket_new failed! \n");
break;
}
printf("++++ bufferevent_socket_new %p \n", bev);
bufferevent_setcb(bev, readcb, writecb, eventcb, NULL);
bufferevent_enable(bev, EV_READ|EV_WRITE);
connected =0;
int rt =bufferevent_socket_connect_hostname(bev, NULL, AF_INET, host, port);
} while (0);
return bev;
}
int
main(int argc, char** argv) {
LIST_INIT(&search_list);
search_add(&search_list, "123", 3);
base = event_base_new();
if (base) {
dnsbase = evdns_base_new(base, 1);
if (dnsbase) {
create_request("http://yandex.ru/");
event_base_dispatch(base);
evdns_base_free(dnsbase, 0);
} else {
fprintf(stderr, "evdns_base_new() failed\n");
}
event_base_free(base);
} else {
perror("event_base_new()");
}
search_clear(&search_list);
return (EXIT_SUCCESS);
}
void launch_push_queries(char* address, void* context, struct email* email)
{ /* SELECT push_id, push_type FROM push_ids WHERE email = '*****@*****.**'; */
size_t email_len = strlen(address); /* I am aware that I should escape this right here.. */
size_t output_len = email_len + 55 + 2 + 1; /* Sadly that requires a PGconn* object, which I don't have here. */
char buffer[output_len]; //TODO escape this query properly
snprintf(buffer, sizeof(buffer), "SELECT push_id, push_type FROM push_ids WHERE email = '%s';", address);
char* query = malloc(output_len);
strcpy(query, buffer);
struct push_info* push_info = malloc(sizeof(struct push_info));
if (email->subject) {
push_info->subject = malloc(strlen(email->subject));
strcpy(push_info->subject, email->subject);
} else
push_info->subject = NULL;
if (email->data) {
push_info->data = malloc(strlen(email->data));
strcpy(push_info->data, email->data);
} else
push_info = NULL;
if (email->from) {
push_info->sender = malloc(strlen(email->from));
strcpy(push_info->sender, email->from);
} else
push_info->sender = NULL;
push_info->event_base = (struct event_base*) context;
if (!dns)
dns = evdns_base_new(push_info->event_base, 1);
databaseQuery(query, push_query_result, push_info);
}
int main(int argc, char **argv)
{
struct event_base *base;
struct evdns_base *dns_base;
struct bufferevent *bev;
if (argc != 3) {
printf("Trivial HTTP 0.x client\n"
"Syntax: %s [hostname] [resource]\n"
"Example: %s www.google.com /\n", argv[0], argv[0]);
return 1;
}
base = event_base_new();
dns_base = evdns_base_new(base, 1);
bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(bev, readcb, NULL, eventcb, base);
bufferevent_enable(bev, EV_READ | EV_WRITE);
evbuffer_add_printf(bufferevent_get_output(bev), "GET %s\r\n",
argv[2]);
bufferevent_socket_connect_hostname(bev, dns_base, AF_UNSPEC,
argv[1], 80);
event_base_dispatch(base);
return 0;
}
static void
dns_resolve_reverse(void *ptr)
{
struct in_addr in;
struct event_base *base = event_base_new();
struct evdns_base *dns = evdns_base_new(base, 1/* init name servers */);
struct evdns_request *req = NULL;
tt_assert(base);
tt_assert(dns);
in.s_addr = htonl(0x7f000001ul); /* 127.0.0.1 */
dns_ok = 0;
req = evdns_base_resolve_reverse(
dns, &in, 0, dns_gethostbyname_cb, base);
tt_assert(req);
event_base_dispatch(base);
tt_int_op(dns_ok, ==, DNS_PTR);
end:
if (dns)
evdns_base_free(dns, 0);
if (base)
event_base_free(base);
}
int
main(int argc, char ** argv) {
struct evdns_base * dns_base;
struct timeval tv;
if (parse_args(argc, argv) < 0) {
exit(1);
}
tv.tv_sec = sec;
tv.tv_usec = usec;
evbase = event_base_new();
dns_base = evdns_base_new(evbase, 1);
bev = bufferevent_socket_new(evbase, -1, BEV_OPT_CLOSE_ON_FREE);
sev = evtimer_new(evbase, send_byte, bev);
bufferevent_setcb(bev, readcb, NULL, eventcb, evbase);
bufferevent_enable(bev, EV_READ | EV_WRITE);
bufferevent_socket_connect_hostname(bev, dns_base, AF_UNSPEC, addr, port);
event_base_loop(evbase, 0);
while (fread(&fbyte, 1, 1, input_file) == 1) {
fprintf(stdout, "sending: '%c' (%x)\n", isprint(fbyte) ? fbyte : ' ', fbyte);
}
return 0;
}
int main(int argc, char **argv)
{
struct evdns_base *dns;
struct event_base *base;
struct bufferevent *bev;
struct url *socks, *host;
int s4;
base = event_base_new();
dns = evdns_base_new(base, 1);
log_set_file(NULL);
log_set_min_level(LOG_DEBUG);
if (argc >= 3) {
socks = url_tokenize(argv[2]);
s4 = !evutil_ascii_strcasecmp("socks4", socks->scheme);
if (conn_set_socks_server(socks->host, socks->port, s4?
SOCKS_4 : SOCKS_4a) < 0)
return 0;
}
host = url_connect_tokenize(argv[1]);
bev = bufferevent_socket_new(base, -1, BEV_OPT_CLOSE_ON_FREE);
conn_connect_bufferevent(bev, dns, AF_INET, host->host, host->port,
do_connect, NULL);
event_base_dispatch(base);
return 0;
}
static int
cert_updater_update(ProxyContext * const proxy_context)
{
CertUpdater *cert_updater = &proxy_context->cert_updater;
DNSCRYPT_PROXY_CERTS_UPDATE_START();
if (cert_updater->evdns_base != NULL) {
evdns_base_free(cert_updater->evdns_base, 0);
}
if ((cert_updater->evdns_base =
evdns_base_new(proxy_context->event_loop, 0)) == NULL) {
return -1;
}
if (evdns_base_nameserver_sockaddr_add(cert_updater->evdns_base,
(struct sockaddr *)
&proxy_context->resolver_sockaddr,
proxy_context->resolver_sockaddr_len,
DNS_QUERY_NO_SEARCH) != 0) {
return -1;
}
if (proxy_context->tcp_only != 0) {
(void) evdns_base_nameserver_ip_add(cert_updater->evdns_base,
proxy_context->resolver_ip);
}
if (evdns_base_resolve_txt(cert_updater->evdns_base,
proxy_context->provider_name,
DNS_QUERY_NO_SEARCH,
cert_query_cb,
proxy_context) == NULL) {
return -1;
}
return 0;
}
/* Initializes |session_data| */
static http2_session_data *
create_http2_session_data(struct event_base *evbase) {
http2_session_data *session_data = malloc(sizeof(http2_session_data));
memset(session_data, 0, sizeof(http2_session_data));
session_data->dnsbase = evdns_base_new(evbase, 1);
return session_data;
}
virtual void SetUp() {
handler_.reset(new HTTPHandler(&DoMyFunc));
base_ = event_base_new();
dnsbase_ = evdns_base_new(base_, 1);
connection_ = evhttp_connection_base_new(base_, dnsbase_, "0.0.0.0", 8080);
request_ = evhttp_request_new(NULL, NULL);
evhttp_make_request(connection_, request_, EVHTTP_REQ_GET, "");
}
static void
dns_search_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_base *dns = NULL;
ev_uint16_t portnum = 0;
char buf[64];
struct generic_dns_callback_result r[8];
tt_assert(regress_dnsserver(base, &portnum, search_table));
evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
dns = evdns_base_new(base, 0);
tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
evdns_base_search_add(dns, "a.example.com");
evdns_base_search_add(dns, "b.example.com");
evdns_base_search_add(dns, "c.example.com");
n_replies_left = sizeof(r)/sizeof(r[0]);
exit_base = base;
evdns_base_resolve_ipv4(dns, "host", 0, generic_dns_callback, &r[0]);
evdns_base_resolve_ipv4(dns, "host2", 0, generic_dns_callback, &r[1]);
evdns_base_resolve_ipv4(dns, "host", DNS_NO_SEARCH, generic_dns_callback, &r[2]);
evdns_base_resolve_ipv4(dns, "host2", DNS_NO_SEARCH, generic_dns_callback, &r[3]);
evdns_base_resolve_ipv4(dns, "host3", 0, generic_dns_callback, &r[4]);
evdns_base_resolve_ipv4(dns, "hostn.a.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[5]);
evdns_base_resolve_ipv4(dns, "hostn.b.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[6]);
evdns_base_resolve_ipv4(dns, "hostn.c.example.com", DNS_NO_SEARCH, generic_dns_callback, &r[7]);
event_base_dispatch(base);
tt_int_op(r[0].type, ==, DNS_IPv4_A);
tt_int_op(r[0].count, ==, 1);
tt_int_op(((ev_uint32_t*)r[0].addrs)[0], ==, htonl(0x0b16212c));
tt_int_op(r[1].type, ==, DNS_IPv4_A);
tt_int_op(r[1].count, ==, 1);
tt_int_op(((ev_uint32_t*)r[1].addrs)[0], ==, htonl(0xc8640064));
tt_int_op(r[2].result, ==, DNS_ERR_NOTEXIST);
tt_int_op(r[3].result, ==, DNS_ERR_NOTEXIST);
tt_int_op(r[4].result, ==, DNS_ERR_NOTEXIST);
tt_int_op(r[5].result, ==, DNS_ERR_NODATA);
tt_int_op(r[5].ttl, ==, 42);
tt_int_op(r[6].result, ==, DNS_ERR_NOTEXIST);
tt_int_op(r[6].ttl, ==, 42);
tt_int_op(r[7].result, ==, DNS_ERR_NODATA);
tt_int_op(r[7].ttl, ==, 0);
end:
if (dns)
evdns_base_free(dns, 0);
regress_clean_dnsserver();
}
Global::Global() {
SSL_library_init();
ERR_load_CRYPTO_strings();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
RAND_poll();
event_base = event_base_new();
dns_base = evdns_base_new(event_base, 1);
};
// Initializes TCP and LibEvent, then listens for connections on port
// and calls accept_cb when they occur. Terminates cleanly on SIGINT.
// Returns 0 on clean shutdown; otherwise nonzero
int InitAndListenLoop(int port, evconnlistener_cb accept_cb, struct telex_conf *conf)
{
#ifdef WIN32
WSADATA WSAData;
WSAStartup(0x101, &WSAData);
#endif
struct event_base *base;
base = event_base_new();
if (!base) {
LogFatal("listener", "Could not initialize libevent");
return 1;
}
//void event_enable_debug_mode(void);
conf->dns_base = evdns_base_new(base, 1);
if (!conf->dns_base) {
LogFatal("listener", "Could not initialize dns");
return 1;
}
struct evconnlistener *listener;
listener = listener_init_local(base, port, accept_cb, conf, NULL);
if (!listener) {
LogFatal("listener", "Could not create listener");
return 1;
}
struct event *signal_event;
signal_event = evsignal_new(base, SIGINT, sigint_cb, (void *)base);
if (!signal_event || event_add(signal_event, NULL)<0) {
LogFatal("listener", "Could not create/add signal event");
return 1;
}
struct event *sigpipe_event;
sigpipe_event = evsignal_new(base, SIGPIPE, sigpipe_cb, (void *)base);
if (!sigpipe_event || event_add(sigpipe_event, NULL)<0) {
LogFatal("listener", "Could not create/add signal event");
return 1;
}
// handle events ...
LogTrace("listener", "Starting dispatch");
event_base_dispatch(base);
evconnlistener_free(listener);
event_free(signal_event);
event_free(sigpipe_event);
event_base_free(base);
LogInfo("listener", "Shutdown complete");
return 0;
}
static void
dns_reissue_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_server_port *port1 = NULL, *port2 = NULL;
struct evdns_base *dns = NULL;
struct generic_dns_callback_result r1;
ev_uint16_t portnum1 = 0, portnum2=0;
char buf1[64], buf2[64];
port1 = regress_get_dnsserver(base, &portnum1, NULL,
regress_dns_server_cb, internal_error_table);
tt_assert(port1);
port2 = regress_get_dnsserver(base, &portnum2, NULL,
regress_dns_server_cb, reissue_table);
tt_assert(port2);
evutil_snprintf(buf1, sizeof(buf1), "127.0.0.1:%d", (int)portnum1);
evutil_snprintf(buf2, sizeof(buf2), "127.0.0.1:%d", (int)portnum2);
dns = evdns_base_new(base, 0);
tt_assert(!evdns_base_nameserver_ip_add(dns, buf1));
tt_assert(! evdns_base_set_option(dns, "timeout:", "0.3"));
tt_assert(! evdns_base_set_option(dns, "max-timeouts:", "2"));
tt_assert(! evdns_base_set_option(dns, "attempts:", "5"));
memset(&r1, 0, sizeof(r1));
evdns_base_resolve_ipv4(dns, "foof.example.com", 0,
generic_dns_callback, &r1);
/* Add this after, so that we are sure to get a reissue. */
tt_assert(!evdns_base_nameserver_ip_add(dns, buf2));
n_replies_left = 1;
exit_base = base;
event_base_dispatch(base);
tt_int_op(r1.result, ==, DNS_ERR_NONE);
tt_int_op(r1.type, ==, DNS_IPv4_A);
tt_int_op(r1.count, ==, 1);
tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0xf00ff00f));
/* Make sure we dropped at least once. */
tt_int_op(internal_error_table[0].seen, >, 0);
end:
if (dns)
evdns_base_free(dns, 0);
if (port1)
evdns_close_server_port(port1);
if (port2)
evdns_close_server_port(port2);
}
void IoEvDNS_rawInitIfNeeded(IoEvDNS *self)
{
if (!DNS(self))
{
IoEventManager *em = IoObject_getSlot_(self, IOSYMBOL("eventManager"));
IOASSERT(ISEEVENTMANAGER(em), "eventManager slot not set properly");
struct event_base *base = evhttp_new(IoEventManager_rawBase(em);
int initialize_nameservers = 1;
struct evdns_base *dnsBase = evdns_base_new(base, initialize_nameservers);
IoObject_setDataPointer_(self, dnsBase);
}
void dispatch_config(struct event_base* base) {
dns = evdns_base_new(base, 1);
struct server* node = global_config.servers;
while (node) {
struct timeval tv;
tv.tv_sec = node->interval;
tv.tv_usec = 0;
node->timer = event_new(base, -1, EV_PERSIST, timer_callback, node);
event_add(node->timer, &tv);
node = node->next;
};
};
Global::Global() {
SSL_library_init();
ERR_load_CRYPTO_strings();
SSL_load_error_strings();
OpenSSL_add_all_algorithms();
RAND_poll();
#ifndef _NO_LIBEVENT_THREADS
evthread_use_pthreads();
#endif
event_base = event_base_new();
dns_base = evdns_base_new(event_base, 1);
};
HttpClient_YPL::HttpClient_YPL()
{
m_base = event_base_new();
m_dnsbase = evdns_base_new(m_base, 1);
//URL=http\://14.23.90.103/api/service
m_host = "14.23.90.103";
m_port = 80;
//m_host = "222.76.151.10";
//m_port = 51010;
m_conn = evhttp_connection_base_new(m_base, m_dnsbase, m_host.c_str(), m_port);
m_buffer = NULL;
m_bufferSize = 0;
}
int
main(int argc, char **argv)
{
struct event_base *base;
struct evdns_base *dns = NULL;
int opt;
const char *laddr, *lport;
init_socket_stuff();
base = event_base_new();
#ifndef DISABLE_DIRECT_CONNECTIONS
dns = evdns_base_new(base, 1);
#endif
log_set_file(NULL);
laddr = DEFAULT_LISTEN_ADDR;
lport = DEFAULT_LISTEN_PORT;
while ((opt = getopt(argc, argv, "l:p:Vvq")) >= 0) {
switch (opt) {
case 'l':
laddr = optarg;
break;
case 'p':
lport = optarg;
break;
case 'V':
printf("%s\n", PACKAGE_STRING);
exit(1);
case 'v':
increase_log_verbosity();
break;
case 'q':
decrease_log_verbosity();
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc)
set_socks_server(argv[0]);
start_listening(base, dns, laddr, lport);
event_base_dispatch(base);
return 0;
}
void init_ev()
{
main_base = event_base_new();
dns_base = evdns_base_new(main_base, 1);
ready_sites_fifo = fifo_new(NULL);
wait_sites_fifo = fifo_new(NULL);
/* set timer */
struct event *ev;
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 50000; /* 30 milliseconds */
ev = event_new(main_base, -1, EV_TIMEOUT | EV_PERSIST, timer_cb, NULL);
event_add(ev, &tv);
}
int proxy_init(void)
{
dbg_err_if ((g_ctx.base = event_base_new()) == NULL);
dbg_err_if ((g_ctx.dns = evdns_base_new(g_ctx.base, 1)) == NULL);
dbg_err_if ((g_ctx.coap = ec_init(g_ctx.base, g_ctx.dns)) == NULL);
dbg_err_if ((g_ctx.cache = ec_filesys_create(false)) == NULL);
if (g_ctx.block_sz)
dbg_err_if(ec_set_block_size(g_ctx.coap, g_ctx.block_sz));
return 0;
err:
proxy_term();
return -1;
}
int server_init(void)
{
dbg_err_if((g_ctx.base = event_base_new()) == NULL);
dbg_err_if((g_ctx.dns = evdns_base_new(g_ctx.base, 1)) == NULL);
dbg_err_if((g_ctx.coap = ec_init(g_ctx.base, g_ctx.dns)) == NULL);
dbg_err_if((g_ctx.fs = ec_filesys_create(g_ctx.rel_refs)) == NULL);
if (g_ctx.bsz)
dbg_err_if(ec_set_block_size(g_ctx.coap, g_ctx.bsz));
return 0;
err:
server_term();
return -1;
}
bool HttpService::Init()
{
bool ret = false;
do
{
evthread_use_pthreads();
base_ = event_base_new();
if (!base_)
{
LOG_ERROR("create event base failed!");
break;
}
dnsbase_ = evdns_base_new(base_, 1);
if (!dnsbase_)
{
LOG_ERROR("create dnsbase failed!");
break;
}
http_server_ = evhttp_new(base_);
if (!http_server_)
{
LOG_ERROR("create evhttp failed!");
break;
}
evhttp_set_allowed_methods(http_server_,
EVHTTP_REQ_CONNECT |
EVHTTP_REQ_GET |
EVHTTP_REQ_POST |
EVHTTP_REQ_HEAD |
EVHTTP_REQ_PUT |
EVHTTP_REQ_DELETE);
if (evhttp_accept_socket(http_server_, sock_) != 0)
{
LOG_ERROR("accept socket failed!");
break;
}
evhttp_set_gencb(http_server_, HttpGenericCallback, this);
ret = true;
} while(0);
return ret;
}
static void
dns_search_test(void *arg)
{
struct basic_test_data *data = arg;
struct event_base *base = data->base;
struct evdns_base *dns = NULL;
ev_uint16_t portnum = 0;
char buf[64];
struct generic_dns_callback_result r1, r2, r3, r4, r5;
tt_assert(regress_dnsserver(base, &portnum, search_table));
evutil_snprintf(buf, sizeof(buf), "127.0.0.1:%d", (int)portnum);
dns = evdns_base_new(base, 0);
tt_assert(!evdns_base_nameserver_ip_add(dns, buf));
evdns_base_search_add(dns, "a.example.com");
evdns_base_search_add(dns, "b.example.com");
evdns_base_search_add(dns, "c.example.com");
n_replies_left = 5;
exit_base = base;
evdns_base_resolve_ipv4(dns, "host", 0, generic_dns_callback, &r1);
evdns_base_resolve_ipv4(dns, "host2", 0, generic_dns_callback, &r2);
evdns_base_resolve_ipv4(dns, "host", DNS_NO_SEARCH, generic_dns_callback, &r3);
evdns_base_resolve_ipv4(dns, "host2", DNS_NO_SEARCH, generic_dns_callback, &r4);
evdns_base_resolve_ipv4(dns, "host3", 0, generic_dns_callback, &r5);
event_base_dispatch(base);
tt_int_op(r1.type, ==, DNS_IPv4_A);
tt_int_op(r1.count, ==, 1);
tt_int_op(((ev_uint32_t*)r1.addrs)[0], ==, htonl(0x0b16212c));
tt_int_op(r2.type, ==, DNS_IPv4_A);
tt_int_op(r2.count, ==, 1);
tt_int_op(((ev_uint32_t*)r2.addrs)[0], ==, htonl(0xc8640064));
tt_int_op(r3.result, ==, DNS_ERR_NOTEXIST);
tt_int_op(r4.result, ==, DNS_ERR_NOTEXIST);
tt_int_op(r5.result, ==, DNS_ERR_NOTEXIST);
end:
if (dns)
evdns_base_free(dns, 0);
regress_clean_dnsserver();
}
int jsonrpc_io_child_process(int cmd_pipe)
{
struct event* pipe_ev = NULL;
global_ev_base = event_base_new();
global_evdns_base = evdns_base_new(global_ev_base, 1);
set_non_blocking(cmd_pipe);
pipe_ev = event_new(global_ev_base, cmd_pipe,
EV_READ | EV_PERSIST, cmd_pipe_cb, NULL);
if(!pipe_ev) {
ERR("Failed to create pipe event\n");
return -1;
}
if(event_add(pipe_ev, NULL)<0) {
ERR("Failed to start pipe event\n");
return -1;
}
connect_servers(global_server_group);
#if 0
/* attach shutdown signal handler */
/* The shutdown handler are intended to clean up the remaining memory
* in the IO process. However, catching the signals causes unpreditable
* behavior in the Kamailio shutdown process, so this should be disabled
* except when doing memory debugging. */
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sa.sa_handler = io_shutdown;
if(sigaction(SIGTERM, &sa, NULL) == -1) {
ERR("Failed to attach IO shutdown handler to SIGTERM\n");
} else if(sigaction(SIGINT, NULL, &sa) == -1) {
ERR("Failed to attach IO shutdown handler to SIGINT\n");
}
#endif
if(event_base_dispatch(global_ev_base)<0) {
ERR("IO couldn't start event loop\n");
return -1;
}
return 0;
}
void
async_network_task_push(struct async_network_task_s *task)
{
static int thread_started = 0;
if (!thread_started) {
pthread_t t;
evthread_use_pthreads();
event_b = event_base_new();
evdns_b = evdns_base_new(event_b, 0);
evdns_base_resolv_conf_parse(evdns_b, DNS_OPTIONS_ALL, "/etc/resolv.conf");
if (config.randomize_dns_case == 0)
evdns_base_set_option(evdns_b, "randomize-case:", "0");
pthread_create(&t, NULL, network_worker_thread, NULL);
pthread_detach(t);
thread_started = 1;
}
switch (task->type) {
case ASYNC_NETWORK_TCP_CONNECT:
handle_tcp_connect_stage1(task);
break;
case ASYNC_NETWORK_TCP_CONNECT_WITH_NETADDRESS:
handle_tcp_connect_with_net_address(task);
break;
case ASYNC_NETWORK_DISCONNECT:
handle_disconnect_stage1(task);
break;
case ASYNC_NETWORK_TCP_READ:
handle_tcp_read_stage1(task);
break;
case ASYNC_NETWORK_TCP_WRITE:
handle_tcp_write_stage1(task);
break;
case ASYNC_NETWORK_UDP_RECV:
handle_udp_recv_stage1(task);
break;
case ASYNC_NETWORK_UDP_SEND:
handle_udp_send_stage1(task);
break;
case ASYNC_NETWORK_HOST_RESOLVE:
handle_host_resolve_stage1(task);
break;
}
}
bool
f4dns_init(f4dns_ctx_t *ctx) {
ctx->dns_base = evdns_base_new( ctx->f4->base, 1 );
assert( ctx->dns_base != NULL );
ctx->sock = socket(ctx->f4->listen_dns.ss_family, SOCK_DGRAM, 0);
evutil_make_socket_nonblocking(ctx->sock);
if( bind(ctx->sock, (struct sockaddr*)&ctx->f4->listen_dns, ctx->f4->listen_dns_sz) != 0 ) {
perror("Cannot bind() DNS socket");
return false;
}
ctx->server = evdns_add_server_port_with_base(ctx->f4->base, ctx->sock, 0, _f4dns_cb_dnsserver, ctx);
return true;
}
static void lookup_and_connect(void)
{
struct evutil_addrinfo hints;
if (!ev_dnsbase)
ev_dnsbase = evdns_base_new(ev_base, 1);
if (!ev_dnsbase)
tmate_fatal("Cannot initialize the DNS lookup service");
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_flags = 0;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
tmate_info("Looking up %s...", TMATE_HOST);
(void)evdns_getaddrinfo(ev_dnsbase, TMATE_HOST, NULL,
&hints, dns_cb, NULL);
}
int main ()
{
SSL_library_init ();
ERR_load_crypto_strings ();
SSL_load_error_strings ();
OpenSSL_add_all_algorithms();
event_enable_debug_mode ();
evbase = event_base_new ();
dnsbase = evdns_base_new (evbase, 1);
perform_ssl_connection ();
event_base_dispatch (evbase);
event_base_free (evbase);
return 0;
}
