EventBase::EventBase(const char* method)
{
// enable locking for libevent structure
if (evthread_use_pthreads())
{
throw std::exception();
}
#ifdef DEBUG
evthread_enable_lock_debuging();
event_enable_debug_mode();
#endif
struct event_config *config;
config = event_config_new();
int i = 0;
const char** availMethods = event_get_supported_methods();
for (i = 0; availMethods[i] != NULL; i++)
{
if (strcmp(availMethods[i], method)) {
event_config_avoid_method(config, availMethods[i]);
}
}
base_ = event_base_new_with_config(config);
if (!base_)
{
throw BadBaseException();
}
event_base_get_method(base_);
event_config_free(config);
}
void EventLoop::initialize()
{
// We need to initialize Libevent differently depending on the
// operating system threading support.
#if defined(EVTHREAD_USE_PTHREADS_IMPLEMENTED)
if (evthread_use_pthreads() < 0) {
LOG(FATAL) << "Failed to initialize, evthread_use_pthreads";
}
#elif defined(EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED)
if (evthread_use_windows_threads() < 0) {
LOG(FATAL) << "Failed to initialize, evthread_use_windows_threads";
}
#else
#error "Libevent must be compiled with either pthread or Windows thread support"
#endif
// This enables debugging of libevent calls. We can remove this
// when the implementation settles and after we gain confidence.
event_enable_debug_mode();
// TODO(jmlvanre): Allow support for 'epoll' once SSL related
// issues are resolved.
struct event_config* config = event_config_new();
event_config_avoid_method(config, "epoll");
base = event_base_new_with_config(config);
if (base == NULL) {
LOG(FATAL) << "Failed to initialize, event_base_new";
}
}
void initLibraries()
{
#ifdef _DEBUG
event_enable_debug_mode(); // may cause memory leak
#endif
event_set_fatal_callback(libeventError);
#ifdef _WIN32
#ifdef MEM_DEBUG
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
WSADATA data;
int err = WSAStartup(0, &data);
err = WSAStartup(data.wVersion, &data);
assert(err == 0);
#endif
#ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED
evthread_use_windows_threads(); // may cause memory leak
#endif
#ifdef EVTHREAD_USE_PTHREADS_IMPLEMENTED
evthread_use_pthreads();
#endif
srand(static_cast<unsigned int>(time(NULL))); // stdlib :)
}
int
main(int c, char **v)
{
setvbuf(stdout, NULL, _IONBF, 0);
event_enable_debug_mode();
run();
return 0;
}
int main(const int argc, const char *argv[])
{
event_set_log_callback(write_to_file_cb);
event_enable_debug_mode();
//log_level(LOG_DEBUG);
log_fileline(LOG_FILELINE_ON);
log_level(LOG_WARN);
server_t *server = server_init(DEFAULT_PORT);
if(server == NULL)
{
log_err(__FILE__, __LINE__, "Cannot init server.");
exit(-1);
}
int power = 10;
server->service_idx = service_index_init(power);
char *str = NULL;
str = calloc(sizeof(char), 5);
memcpy(str, "aaaa", 4);
service_t *aaaa = service_init(str);
aaaa = service_add(server->service_idx, power, aaaa);
server->service_first = aaaa;
server->service_last = aaaa;
server->num_services++;
str = calloc(sizeof(char), 5);
memcpy(str, "bbbb", 4);
service_t *bbbb = service_init(str);
bbbb = service_add(server->service_idx, power, bbbb);
aaaa->all_next = bbbb;
server->service_last = bbbb;
server->num_services++;
str = calloc(sizeof(char), 5);
memcpy(str, "cccc", 4);
service_t *cccc = service_init(str);
cccc = service_add(server->service_idx, power, cccc);
bbbb->all_next = cccc;
server->service_last = cccc;
server->num_services++;
server_event_run(server);
return 0;
}
LibEventInit::LibEventInit()
{
event_set_log_callback(my_libevent_log_cb);
#ifdef OS_WIN
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
evdns_set_log_fn(logfn);
if (CONFIG->enableEventDebug){
MYDEBUG("enable libevent debug");
event_enable_debug_mode();
}
}
int main (int argc, char **argv) {
signal(SIGPIPE, SIG_IGN);
event_enable_debug_mode();
int result = evthread_use_pthreads();
if (result < 0) {
printf("Could not use pthreads with libevent\n");
exit(1);
}
struct event_base *base = event_base_new();
if (base == NULL) {
printf("Could not create libevent base\n");
exit(1);
}
result = evthread_make_base_notifiable(base);
if (result) {
printf("Could not initialize libevent base\n");
exit(1);
}
riak_context ctx_data[10];
for(int i = 0; i < 10; i++) {
riak_context *ctx = &ctx_data[i];
riak_context_init(ctx);
if (ctx->err) {
printf("Error: %s\n", ctx->errstr);
return 1;
}
result = riak_context_connect(ctx, "httpbin.org", "80");
// result = riak_context_connect(ctx, "localhost", "6074");
if (result) {
printf("Could not connect to host\n");
exit(1);
}
result = riak_libevent_init(ctx, base);
if (result) {
printf("Could not initialize libevent\n");
exit(1);
}
riak_send(ctx, "GET / HTTP/1.1\r\nHost: httpbin.org\r\n\r\n", result_fn);
}
event_base_dispatch(base);
// cleanup
event_base_free(base);
return 0;
}
ClientImpl::ClientImpl(ClientConfig config) throw(voltdb::Exception, voltdb::LibEventException) :
m_nextRequestId(INT64_MIN), m_nextConnectionIndex(0), m_listener(config.m_listener),
m_invocationBlockedOnBackpressure(false), m_loopBreakRequested(false), m_isDraining(false),
m_instanceIdIsSet(false), m_outstandingRequests(0), m_username(config.m_username),
m_maxOutstandingRequests(config.m_maxOutstandingRequests), m_ignoreBackpressure(false),
m_useClientAffinity(false),m_updateHashinator(false), m_pendingConnectionSize(0) ,
m_pLogger(0)
{
pthread_once(&once_initLibevent, initLibevent);
#ifdef DEBUG
if (!voltdb_clientimpl_debug_init_libevent) {
event_enable_debug_mode();
voltdb_clientimpl_debug_init_libevent = true;
}
#endif
struct event_config *cfg = event_config_new();
event_config_set_flag(cfg, EVENT_BASE_FLAG_NO_CACHE_TIME);//, EVENT_BASE_FLAG_NOLOCK);
m_base = event_base_new_with_config(cfg);
assert(m_base);
if (!m_base) {
throw voltdb::LibEventException();
}
m_hashScheme = config.m_hashScheme;
if (m_hashScheme == HASH_SHA1) {
SHA1_CTX context;
SHA1_Init(&context);
SHA1_Update( &context, reinterpret_cast<const unsigned char*>(config.m_password.data()), config.m_password.size());
m_passwordHash = (unsigned char *)malloc(20*sizeof(char));
SHA1_Final ( &context, m_passwordHash);
} else if (config.m_hashScheme == HASH_SHA256) {
m_passwordHash = (unsigned char *)malloc(32*sizeof(char));
computeSHA256(config.m_password.c_str(), config.m_password.size(), m_passwordHash);
} else {
throw voltdb::LibEventException();
}
if (0 == pipe(m_wakeupPipe)) {
struct event *ev = event_new(m_base, m_wakeupPipe[0], EV_READ|EV_PERSIST, wakeupPipeCallback, this);
event_add(ev, NULL);
} else {
m_wakeupPipe[1] = -1;
}
SHA1_CTX context;
SHA1_Init(&context);
SHA1_Update( &context, reinterpret_cast<const unsigned char*>(config.m_password.data()), config.m_password.size());
SHA1_Final(&context, m_passwordHash);
}
int main(int argc, char **argv) {
chassis_log *log = NULL;
g_test_init(&argc, &argv, NULL);
log = chassis_log_new();
log->min_lvl = G_LOG_LEVEL_DEBUG; /* display messages while parsing or loading plugins */
g_log_set_default_handler(chassis_log_func, log);
log->log_file_fd = STDERR_FILENO;
event_enable_debug_mode();
t_lib_libevent_add_a_event_twice_nicely();
return 0;
}
int
main(int argc, const char **argv)
{
#ifdef _WIN32
WORD wVersionRequested;
WSADATA wsaData;
wVersionRequested = MAKEWORD(2, 2);
(void) WSAStartup(wVersionRequested, &wsaData);
#endif
#ifndef _WIN32
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
return 1;
#endif
#ifdef _WIN32
tinytest_skip(testgroups, "http/connection_retry");
tinytest_skip(testgroups, "http/https_connection_retry");
#endif
#ifndef EVENT__DISABLE_THREAD_SUPPORT
if (!getenv("EVENT_NO_DEBUG_LOCKS"))
evthread_enable_lock_debugging();
#endif
if (getenv("EVENT_DEBUG_MODE")) {
event_enable_debug_mode();
libevent_tests_running_in_debug_mode = 1;
}
if (getenv("EVENT_DEBUG_LOGGING_ALL")) {
event_enable_debug_logging(EVENT_DBG_ALL);
}
tinytest_set_aliases(testaliases);
evutil_weakrand_seed_(&test_weakrand_state, 0);
if (tinytest_main(argc,argv,testgroups))
return 1;
libevent_global_shutdown();
return 0;
}
int
main(int argc, char **argv)
{
struct event ev;
struct event *t1;
event_enable_debug_mode();
fprintf(stderr, "Libevent %s\n", event_get_version());
fflush(stderr);
if (!(base = event_base_new()))
die("event_base_new");
if (event_base_priority_init(base, 8) < 0)
die("event_base_priority_init");
if (event_assign(&ev, base, SIGTERM, EV_SIGNAL|EV_PERSIST, cbfunc, NULL)<0)
die("event_assign");
if (event_priority_set(&ev, SIGPRI) < 0)
die("event_priority_set");
if (event_add(&ev, NULL) < 0)
die("event_add");
fprintf(stderr, "SIGNAL EVENT DEFINED\n");
fflush(stderr);
t1 = (struct event*)malloc(sizeof(struct event));
if (event_assign(t1, base, -1, EV_WRITE, t1func, t1) < 0) {
die("event_assign_term");
}
if (event_priority_set(t1, TERMPRI) < 0) {
die("event_priority_set_term");
}
event_active(t1, EV_WRITE, 1);
fprintf(stderr, "FIRST TERMINATION EVENT DEFINED\n");
fflush(stderr);
/* event_dispatch(base); */
while (run) {
event_base_loop(base, EVLOOP_ONCE);
}
fprintf(stderr, "EXITED LOOP - FREEING BASE\n");
fflush(stderr);
event_base_free(base);
return 0;
}
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;
}
int opal_event_init(void)
{
char **includes=NULL;
bool dumpit=false;
int i, j;
if (opal_output_get_verbosity(opal_event_base_framework.framework_output) > 4) {
event_enable_debug_mode();
dumpit = true;
}
if (NULL == event_module_include) {
/* Shouldn't happen, but... */
event_module_include = strdup("select");
}
includes = opal_argv_split(event_module_include,',');
/* get a configuration object */
config = event_config_new();
/* cycle thru the available subsystems */
for (i = 0 ; NULL != eventops[i] ; ++i) {
/* if this module isn't included in the given ones,
* then exclude it
*/
dumpit = true;
for (j=0; NULL != includes[j]; j++) {
if (0 == strcmp("all", includes[j]) ||
0 == strcmp(eventops[i]->name, includes[j])) {
dumpit = false;
break;
}
}
if (dumpit) {
event_config_avoid_method(config, eventops[i]->name);
}
}
opal_argv_free(includes);
return OPAL_SUCCESS;
}
int main(int argc, char **argv) {
chassis_log *log = NULL;
g_test_init(&argc, &argv, NULL);
g_test_bug_base("http://bugs.mysql.com/");
log = chassis_log_new();
log->min_lvl = G_LOG_LEVEL_DEBUG; /* display messages while parsing or loading plugins */
g_log_set_default_handler(chassis_log_func, log);
log->log_file_fd = STDERR_FILENO;
event_enable_debug_mode();
g_test_add_func("/lib/libevent/add_a_event_twice_nicely", t_lib_libevent_add_a_event_twice_nicely);
g_test_add_func("/lib/libevent/add_a_event_twice_diff_type", t_lib_libevent_add_a_event_twice_diff_type);
g_test_add_func("/lib/libevent/add_a_event_twice_fail", t_lib_libevent_add_a_event_twice_fail);
g_test_add_func("/lib/libevent/assign_a_event_twice", t_lib_libevent_assign_a_event_twice);
return g_test_run();
//t_lib_libevent_add_a_event_twice();
//return 0;
}
int
main(int argc,
char *argv[])
{
riak_args args;
int operation = riak_parse_args(argc, argv, &args);
event_enable_debug_mode();
// event_use_pthreads();
riak_context *ctx;
riak_error err = riak_context_new_default(&ctx, args.host, args.portnum);
if (err) {
exit(1);
}
riak_event *rev = NULL;
riak_object *obj;
riak_bucket_props *props;
riak_put_options put_options;
char output[10240];
int it;
riak_binary *bucket_bin = riak_binary_new_from_string(ctx, args.bucket); // Not copied
riak_binary *key_bin = riak_binary_new_from_string(ctx, args.key); // Not copied
riak_binary *value_bin = riak_binary_new_from_string(ctx, args.value); // Not copied
if (bucket_bin == NULL ||
key_bin == NULL ||
value_bin == NULL) {
fprintf(stderr, "Could not allocate bucket/key/value\n");
exit(1);
}
for(it = 0; it < args.iterate; it++) {
riak_log_context(ctx, RIAK_LOG_DEBUG, "Loop %d", it);
if (args.async) {
riak_event *rev;
err = riak_event_new(ctx, &rev, NULL, NULL, NULL);
if (err) {
return err;
}
// For convenience have user callback know about its riak_event
riak_event_set_cb_data(rev, rev);
}
switch (operation) {
case MSG_RPBPINGREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)ping_cb);
riak_encode_ping_request(rev, &(rev->pb_request));
} else {
err = riak_ping(ctx);
if (err) {
fprintf(stderr, "No Ping [%s]\n", riak_strerror(err));
exit(1);
}
}
break;
case MSG_RPBGETSERVERINFOREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)serverinfo_cb);
riak_encode_serverinfo_request(rev, &(rev->pb_request));
} else {
riak_serverinfo_response *serverinfo_response;
err = riak_serverinfo(ctx, &serverinfo_response);
if (err) {
fprintf(stderr, "Server Info Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_print_serverinfo_response(serverinfo_response, output, sizeof(output));
printf("%s\n", output);
riak_free_serverinfo_response(ctx, &serverinfo_response);
}
break;
case MSG_RPBGETREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)get_cb);
riak_encode_get_request(rev, bucket_bin, key_bin, NULL, &(rev->pb_request));
} else {
riak_get_response *get_response;
err = riak_get(ctx, bucket_bin, key_bin, NULL, &get_response);
if (err) {
fprintf(stderr, "Get Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_print_get_response(get_response, output, sizeof(output));
printf("%s\n", output);
riak_free_get_response(ctx, &get_response);
}
break;
case MSG_RPBPUTREQ:
obj = riak_object_new(ctx);
if (obj == NULL) {
riak_log(rev, RIAK_LOG_FATAL, "Could not allocate a Riak Object");
return 1;
}
riak_object_set_bucket(obj, riak_binary_new_from_string(ctx, args.bucket)); // Not copied
riak_object_set_value(obj, riak_binary_new_from_string(ctx, args.value)); // Not copied
if (riak_object_get_bucket(obj) == NULL ||
riak_object_get_value(obj) == NULL) {
fprintf(stderr, "Could not allocate bucket/value\n");
riak_free(ctx, &obj);
exit(1);
}
memset(&put_options, '\0', sizeof(riak_put_options));
put_options.has_return_head = RIAK_TRUE;
put_options.return_head = RIAK_TRUE;
put_options.has_return_body = RIAK_TRUE;
put_options.return_body = RIAK_TRUE;
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)put_cb);
riak_encode_put_request(rev, obj, &put_options, &(rev->pb_request));
} else {
riak_put_response *put_response;
err = riak_put(ctx, obj, &put_options, &put_response);
if (err) {
fprintf(stderr, "Put Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_print_put_response(put_response, output, sizeof(output));
printf("%s\n", output);
riak_free_put_response(ctx, &put_response);
}
riak_object_free(ctx, &obj);
break;
case MSG_RPBDELREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)delete_cb);
riak_encode_delete_request(rev, bucket_bin, key_bin, NULL, &(rev->pb_request));
} else {
err = riak_delete(ctx, bucket_bin, key_bin, NULL);
if (err) {
fprintf(stderr, "Delete Problems [%s]\n", riak_strerror(err));
exit(1);
}
}
break;
case MSG_RPBLISTBUCKETSREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)listbucket_cb);
riak_encode_listbuckets_request(rev, &(rev->pb_request));
} else {
riak_listbuckets_response *bucket_response;
err = riak_listbuckets(ctx, &bucket_response);
if (err) {
fprintf(stderr, "List Buckets Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_print_listbuckets_response(bucket_response, output, sizeof(output));
riak_log_context(ctx, RIAK_LOG_DEBUG, "%s", output);
riak_free_listbuckets_response(ctx, &bucket_response);
}
break;
case MSG_RPBLISTKEYSREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)listkey_cb);
riak_encode_listkeys_request(rev, bucket_bin, args.timeout * 1000, &(rev->pb_request));
} else {
riak_listkeys_response *key_response;
err = riak_listkeys(ctx, bucket_bin, args.timeout * 1000, &key_response);
if (err) {
fprintf(stderr, "List Keys Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_print_listkeys_response(key_response, output, sizeof(output));
riak_log_context(ctx, RIAK_LOG_DEBUG, "%s", output);
riak_free_listkeys_response(ctx, &key_response);
}
break;
case MSG_RPBGETCLIENTIDREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)getclientid_cb);
riak_encode_get_clientid_request(rev, &(rev->pb_request));
} else {
riak_get_clientid_response *getcli_response;
err = riak_get_clientid(ctx, &getcli_response);
if (err) {
fprintf(stderr, "Get ClientID Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_print_get_clientid_response(getcli_response, output, sizeof(output));
printf("%s\n", output);
riak_free_get_clientid_response(ctx, &getcli_response);
}
break;
case MSG_RPBSETCLIENTIDREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)setclientid_cb);
riak_encode_set_clientid_request(rev, value_bin, &(rev->pb_request));
} else {
riak_set_clientid_response *setcli_response;
err = riak_set_clientid(ctx, value_bin, &setcli_response);
if (err) {
fprintf(stderr, "Set ClientID Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_free_set_clientid_response(ctx, &setcli_response);
}
break;
case MSG_RPBGETBUCKETREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)getbucketprops_cb);
riak_encode_get_bucketprops_request(rev, bucket_bin, &(rev->pb_request));
} else {
riak_get_bucketprops_response *bucket_response;
err = riak_get_bucketprops(ctx, bucket_bin, &bucket_response);
if (err) {
fprintf(stderr, "Get Bucket Properties Problems [%s]\n", riak_strerror(err));
exit(1);
}
riak_print_get_bucketprops_response(bucket_response, output, sizeof(output));
riak_log_context(ctx, RIAK_LOG_DEBUG, "%s", output);
riak_free_get_bucketprops_response(ctx, &bucket_response);
}
break;
case MSG_RPBRESETBUCKETREQ:
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)resetbucketprops_cb);
riak_encode_reset_bucketprops_request(rev, bucket_bin, &(rev->pb_request));
} else {
riak_reset_bucketprops_response *bucket_response;
err = riak_reset_bucketprops(ctx, bucket_bin, &bucket_response);
if (err) {
fprintf(stderr, "Reset Bucket Properties Problems [%s]\n", riak_strerror(err));
exit(1);
}
}
break;
case MSG_RPBSETBUCKETREQ:
props = riak_bucket_props_new(ctx);
if (obj == NULL) {
riak_log(rev, RIAK_LOG_FATAL, "Could not allocate a Riak Bucket Properties");
return 1;
}
riak_bucket_props_set_last_write_wins(props, RIAK_FALSE);
if (args.async) {
riak_event_set_response_cb(rev, (riak_response_callback)setbucketprops_cb);
riak_encode_set_bucketprops_request(rev, bucket_bin, props, &(rev->pb_request));
} else {
riak_set_bucketprops_response *bucket_response;
err = riak_set_bucketprops(ctx, bucket_bin, props, &bucket_response);
if (err) {
fprintf(stderr, "Reset Bucket Properties Problems [%s]\n", riak_strerror(err));
exit(1);
}
}
break;
default:
usage(stderr, argv[0]);
}
if (args.async) {
err = riak_send_req(rev, rev->pb_request);
if (err) {
riak_log(rev, RIAK_LOG_FATAL, "Could not send request");
exit(1);
}
}
}
// What has been queued up
fflush(stdout);
if (args.async) {
// Terminates only on error or timeout
riak_event_loop(ctx);
}
riak_free(ctx, &bucket_bin);
riak_free(ctx, &key_bin);
riak_free(ctx, &value_bin);
riak_context_free(&ctx);
return 0;
}
int main(int argc, char** argv)
{
/* Set the CWD */
char *home = getenv("HOME");
if (!home) {
printf("Failed to load data directory\n");
return EXIT_FAILURE;
}
char *datadir = malloc(strlen(home) + 10);
snprintf(datadir, strlen(home) + 10, "%s/.bitpeer", home);
if (chdir(datadir) < 0) {
if (mkdir(datadir, 0777) < 0) {
printf("Failed to create data directory.\n");
return EXIT_FAILURE;
}
if (chdir(datadir) < 0) {
printf("Failed to chdir\n");
return EXIT_FAILURE;
}
}
free(datadir);
/* For safety we do these protocol struct assertions */
assert(sizeof(bp_proto_message_s) == 24);
assert(sizeof(bp_proto_net_addr_s) == 26);
assert(sizeof(bp_proto_net_addr_full_s) == 30);
assert(sizeof(bp_proto_version_s) == 80);
assert(sizeof(bp_proto_inv_s) == 36);
assert(sizeof(bp_btcblock_header_s) == 80);
/* Set the settings */
bp_program_s program;
memset(&program, 0, sizeof(program));
program.addrpool_size = 20480;
program.min_connections = 8;
program.max_connections = 4096;
program.reindex_blocks = 0;
program.relay_transactions = 1;
program.relay_blocks = 1;
program.txpool_size = 1024;
program.blocks_per_getblocks = 500;
/* Interpret the command line */
if (argc < 2) {
printf("Invalid command line arguments.\n");
printf("Usage: bitpeer [listen_port] [public_ip] -n [seed_node]\n");
printf("public_ip and seed_node may optionally contain a port number.\n");
return EXIT_FAILURE;
}
unsigned short listen_port = atoi(argv[1]);
if (listen_port == 0) {
printf("Invalid port number specified. Valid ports go from 1 to 65535.\n");
return EXIT_FAILURE;
}
struct sockaddr_in6 sockaddr;
int sockaddr_len = sizeof(struct sockaddr_in6);
if (evutil_parse_sockaddr_port(argv[2], (struct sockaddr*)&sockaddr, &sockaddr_len) < 0) {
printf("Invalid public_ip specified\n");
return EXIT_FAILURE;
}
if (sockaddr.sin6_family == AF_INET) {
sockaddr = bp_in4to6((struct sockaddr_in*)&sockaddr);
sockaddr_len = sizeof(struct sockaddr_in6);
}
if (sockaddr.sin6_port == 0) {
sockaddr.sin6_port = ntohs(listen_port);
}
int nodecount = 0;
struct sockaddr_in6 *nodeaddrs = NULL;
int *nodelens = NULL;
int *nodeperm = NULL;
/* Now interpret the optional arguments */
// Quick preprocessor macro to go to the next argv
#define NEXT_I() {i++; if (i >= argc) { printf("Argument for %s missing\n", argv[i-1]); return EXIT_FAILURE; }}
for (int i = 3; i < argc; i++) {
if (strcmp(argv[i], "--reindex") == 0) {
program.reindex_blocks = 1;
}
else if (strcmp(argv[i], "--addnode") == 0 || strcmp(argv[i], "-n") == 0 ||
strcmp(argv[i], "--addpnode") == 0 || strcmp(argv[i], "-p") == 0) {
NEXT_I();
nodeaddrs = realloc(nodeaddrs, (nodecount+1) * sizeof(struct sockaddr_in6));
nodelens = realloc(nodelens, (nodecount+1) * sizeof(int));
nodeperm = realloc(nodeperm, (nodecount+1) * sizeof(int));
nodelens[nodecount] = sizeof(struct sockaddr_in6);
nodeperm[nodecount] = 0;
if (strcmp(argv[i-1], "--addpnode") == 0 || strcmp(argv[i-1], "-p") == 0) {
printf("Adding a permanent node\n");
nodeperm[nodecount] = 1;
}
struct sockaddr_in6 *addr = &nodeaddrs[nodecount];
memset(addr, 0, sizeof(struct sockaddr_in6));
if (evutil_parse_sockaddr_port(argv[i], (struct sockaddr*)addr, nodelens+nodecount) < 0) {
printf("Invalid node address specified: %s %d\n", argv[i], nodelens[nodecount]);
return EXIT_FAILURE;
}
if (addr->sin6_family == AF_INET) {
*addr = bp_in4to6((struct sockaddr_in*)addr);
nodelens[nodecount] = sizeof(struct sockaddr_in6);
}
assert(addr->sin6_family == AF_INET6);
if (addr->sin6_port == 0) addr->sin6_port = ntohs(8333);
nodecount += 1;
}
else if (strcmp(argv[i], "--txpool") == 0) {
NEXT_I();
program.txpool_size = atoi(argv[i]);
if (program.txpool_size <= 0) {
printf("Invalid argument for %s\n", argv[i-1]);
return EXIT_FAILURE;
}
}
else if (strcmp(argv[i], "--addrpool") == 0) {
NEXT_I();
program.addrpool_size = atoi(argv[i]);
if (program.addrpool_size <= 0) {
printf("Invalid argument for %s\n", argv[i-1]);
return EXIT_FAILURE;
}
}
else if (strcmp(argv[i], "--getblocks-limit") == 0) {
NEXT_I();
program.blocks_per_getblocks = atoi(argv[i]);
if (program.blocks_per_getblocks == 0) {
printf("Invalid argument for %s\n", argv[i-1]);
return EXIT_FAILURE;
}
}
else if (strcmp(argv[i], "--no-tx") == 0) {
program.relay_transactions = 0;
}
else if (strcmp(argv[i], "--no-blocks") == 0) {
program.relay_blocks = 0;
}
else if (strcmp(argv[i], "--minconn") == 0) {
NEXT_I();
program.min_connections = atoi(argv[i]);
}
else if (strcmp(argv[i], "--maxconn") == 0) {
NEXT_I();
program.max_connections = atoi(argv[i]);
if (program.max_connections <= 0) {
printf("Invalid argument for %s\n", argv[i-1]);
return EXIT_FAILURE;
}
}
else if (strcmp(argv[i], "--evdebug") == 0) {
#ifdef EVENT_DBG_ALL
event_enable_debug_logging(EVENT_DBG_ALL);
#endif
event_set_log_callback(log_cb);
event_enable_debug_mode();
}
else {
printf("Unknown argument '%s'\n", argv[i]);
return EXIT_FAILURE;
}
}
/* Ignore SIGPIPE */
struct sigaction act;
act.sa_handler = SIG_IGN;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGPIPE, &act, NULL);
/* Create the main loop */
bp_program_init(&program);
program.eventbase = event_base_new();
/* Set up the signal handler */
struct event *signal_event = evsignal_new(program.eventbase, SIGINT, signal_cb, &program);
evsignal_add(signal_event, NULL);
/* Create a server */
bp_server_s server;
program.server = &server;
bp_server_init(&server, &program, (char*)&sockaddr.sin6_addr, ntohs(sockaddr.sin6_port));
if (bp_server_listen(&server, listen_port) < 0) {
return EXIT_FAILURE;
}
/* We need to connect to one initial node in order to seed everything.
We will not do this initial discovery ourselves. */
for (int i = 0; i < nodecount; i++) {
bp_connection_s *seed_connection = malloc(sizeof(bp_connection_s));
int status = bp_connection_connect(seed_connection, &server, &nodeaddrs[i], nodelens[i]);
if (status < 0) {
printf("Connecting failed\n");
}
seed_connection->is_seed = 1;
seed_connection->is_permanent = nodeperm[i];
}
free(nodeaddrs);
free(nodelens);
free(nodeperm);
/* Run the loop */
event_base_loop(program.eventbase, 0);
printf("Entering clean shutdown state\n");
/* It would appear that our loop ended, so clean up */
event_free(signal_event);
bp_server_deinit(&server);
bp_program_deinit(&program);
event_base_free(program.eventbase);
return EXIT_SUCCESS;
}
static int
test_ratelimiting(void)
{
struct event_base *base;
struct sockaddr_in sin;
struct evconnlistener *listener;
struct sockaddr_storage ss;
ev_socklen_t slen;
struct bufferevent **bevs;
struct client_state *states;
struct bufferevent_rate_limit_group *group = NULL;
int i;
struct timeval tv;
ev_uint64_t total_received;
double total_sq_persec, total_persec;
double variance;
double expected_total_persec = -1.0, expected_avg_persec = -1.0;
int ok = 1;
struct event_config *base_cfg;
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
sin.sin_port = 0; /* unspecified port */
if (0)
event_enable_debug_mode();
base_cfg = event_config_new();
#ifdef _WIN32
if (cfg_enable_iocp) {
evthread_use_windows_threads();
event_config_set_flag(base_cfg, EVENT_BASE_FLAG_STARTUP_IOCP);
}
#endif
base = event_base_new_with_config(base_cfg);
listener = evconnlistener_new_bind(base, echo_listenercb, base,
LEV_OPT_CLOSE_ON_FREE|LEV_OPT_REUSEABLE, -1,
(struct sockaddr *)&sin, sizeof(sin));
slen = sizeof(ss);
if (getsockname(evconnlistener_get_fd(listener), (struct sockaddr *)&ss,
&slen) < 0) {
perror("getsockname");
return 1;
}
if (cfg_connlimit > 0) {
conn_bucket_cfg = ev_token_bucket_cfg_new(
cfg_connlimit, cfg_connlimit * 4,
cfg_connlimit, cfg_connlimit * 4,
&cfg_tick);
assert(conn_bucket_cfg);
}
if (cfg_grouplimit > 0) {
group_bucket_cfg = ev_token_bucket_cfg_new(
cfg_grouplimit, cfg_grouplimit * 4,
cfg_grouplimit, cfg_grouplimit * 4,
&cfg_tick);
group = ratelim_group = bufferevent_rate_limit_group_new(
base, group_bucket_cfg);
expected_total_persec = cfg_grouplimit;
expected_avg_persec = cfg_grouplimit / cfg_n_connections;
if (cfg_connlimit > 0 && expected_avg_persec > cfg_connlimit)
expected_avg_persec = cfg_connlimit;
if (cfg_min_share >= 0)
bufferevent_rate_limit_group_set_min_share(
ratelim_group, cfg_min_share);
}
if (expected_avg_persec < 0 && cfg_connlimit > 0)
expected_avg_persec = cfg_connlimit;
if (expected_avg_persec > 0)
expected_avg_persec /= seconds_per_tick;
if (expected_total_persec > 0)
expected_total_persec /= seconds_per_tick;
bevs = calloc(cfg_n_connections, sizeof(struct bufferevent *));
states = calloc(cfg_n_connections, sizeof(struct client_state));
for (i = 0; i < cfg_n_connections; ++i) {
bevs[i] = bufferevent_socket_new(base, -1,
BEV_OPT_CLOSE_ON_FREE|BEV_OPT_THREADSAFE);
assert(bevs[i]);
bufferevent_setcb(bevs[i], discard_readcb, loud_writecb,
write_on_connectedcb, &states[i]);
bufferevent_enable(bevs[i], EV_READ|EV_WRITE);
bufferevent_socket_connect(bevs[i], (struct sockaddr *)&ss,
slen);
}
tv.tv_sec = cfg_duration - 1;
tv.tv_usec = 995000;
event_base_loopexit(base, &tv);
event_base_dispatch(base);
ratelim_group = NULL; /* So no more responders get added */
for (i = 0; i < cfg_n_connections; ++i) {
bufferevent_free(bevs[i]);
}
evconnlistener_free(listener);
/* Make sure no new echo_conns get added to the group. */
ratelim_group = NULL;
/* This should get _everybody_ freed */
while (n_echo_conns_open) {
printf("waiting for %d conns\n", n_echo_conns_open);
tv.tv_sec = 0;
tv.tv_usec = 300000;
event_base_loopexit(base, &tv);
event_base_dispatch(base);
}
if (group)
bufferevent_rate_limit_group_free(group);
total_received = 0;
total_persec = 0.0;
total_sq_persec = 0.0;
for (i=0; i < cfg_n_connections; ++i) {
double persec = states[i].received;
persec /= cfg_duration;
total_received += states[i].received;
total_persec += persec;
total_sq_persec += persec*persec;
printf("%d: %f per second\n", i+1, persec);
}
printf(" total: %f per second\n",
((double)total_received)/cfg_duration);
if (expected_total_persec > 0) {
double diff = expected_total_persec -
((double)total_received/cfg_duration);
printf(" [Off by %lf]\n", diff);
if (cfg_grouplimit_tolerance > 0 &&
fabs(diff) > cfg_grouplimit_tolerance) {
fprintf(stderr, "Group bandwidth out of bounds\n");
ok = 0;
}
}
printf(" average: %f per second\n",
(((double)total_received)/cfg_duration)/cfg_n_connections);
if (expected_avg_persec > 0) {
double diff = expected_avg_persec - (((double)total_received)/cfg_duration)/cfg_n_connections;
printf(" [Off by %lf]\n", diff);
if (cfg_connlimit_tolerance > 0 &&
fabs(diff) > cfg_connlimit_tolerance) {
fprintf(stderr, "Connection bandwidth out of bounds\n");
ok = 0;
}
}
variance = total_sq_persec/cfg_n_connections - total_persec*total_persec/(cfg_n_connections*cfg_n_connections);
printf(" stddev: %f per second\n", sqrt(variance));
if (cfg_stddev_tolerance > 0 &&
sqrt(variance) > cfg_stddev_tolerance) {
fprintf(stderr, "Connection variance out of bounds\n");
ok = 0;
}
event_base_free(base);
free(bevs);
free(states);
return ok ? 0 : 1;
}
/*
* The actual main function.
*/
int
sntp_main (
int argc,
char **argv,
const char *sntpVersion
)
{
int i;
int exitcode;
int optct;
struct event_config * evcfg;
/* Initialize logging system - sets up progname */
sntp_init_logging(argv[0]);
if (!libevent_version_ok())
exit(EX_SOFTWARE);
init_lib();
init_auth();
optct = ntpOptionProcess(&sntpOptions, argc, argv);
argc -= optct;
argv += optct;
debug = OPT_VALUE_SET_DEBUG_LEVEL;
TRACE(2, ("init_lib() done, %s%s\n",
(ipv4_works)
? "ipv4_works "
: "",
(ipv6_works)
? "ipv6_works "
: ""));
ntpver = OPT_VALUE_NTPVERSION;
steplimit = OPT_VALUE_STEPLIMIT / 1e3;
gap.tv_usec = max(0, OPT_VALUE_GAP * 1000);
gap.tv_usec = min(gap.tv_usec, 999999);
if (HAVE_OPT(LOGFILE))
open_logfile(OPT_ARG(LOGFILE));
msyslog(LOG_INFO, "%s", sntpVersion);
if (0 == argc && !HAVE_OPT(BROADCAST) && !HAVE_OPT(CONCURRENT)) {
printf("%s: Must supply at least one of -b hostname, -c hostname, or hostname.\n",
progname);
exit(EX_USAGE);
}
/*
** Eventually, we probably want:
** - separate bcst and ucst timeouts (why?)
** - multiple --timeout values in the commandline
*/
response_timeout = OPT_VALUE_TIMEOUT;
response_tv.tv_sec = response_timeout;
response_tv.tv_usec = 0;
/* IPv6 available? */
if (isc_net_probeipv6() != ISC_R_SUCCESS) {
ai_fam_pref = AF_INET;
TRACE(1, ("No ipv6 support available, forcing ipv4\n"));
} else {
/* Check for options -4 and -6 */
if (HAVE_OPT(IPV4))
ai_fam_pref = AF_INET;
else if (HAVE_OPT(IPV6))
ai_fam_pref = AF_INET6;
}
/* TODO: Parse config file if declared */
/*
** Init the KOD system.
** For embedded systems with no writable filesystem,
** -K /dev/null can be used to disable KoD storage.
*/
kod_init_kod_db(OPT_ARG(KOD), FALSE);
// HMS: Should we use arg-defalt for this too?
if (HAVE_OPT(KEYFILE))
auth_init(OPT_ARG(KEYFILE), &keys);
/*
** Considering employing a variable that prevents functions of doing
** anything until everything is initialized properly
**
** HMS: What exactly does the above mean?
*/
event_set_log_callback(&sntp_libevent_log_cb);
if (debug > 0)
event_enable_debug_mode();
#ifdef WORK_THREAD
evthread_use_pthreads();
/* we use libevent from main thread only, locks should be academic */
if (debug > 0)
evthread_enable_lock_debuging();
#endif
evcfg = event_config_new();
if (NULL == evcfg) {
printf("%s: event_config_new() failed!\n", progname);
return -1;
}
#ifndef HAVE_SOCKETPAIR
event_config_require_features(evcfg, EV_FEATURE_FDS);
#endif
/* all libevent calls are from main thread */
/* event_config_set_flag(evcfg, EVENT_BASE_FLAG_NOLOCK); */
base = event_base_new_with_config(evcfg);
event_config_free(evcfg);
if (NULL == base) {
printf("%s: event_base_new() failed!\n", progname);
return -1;
}
/* wire into intres resolver */
worker_per_query = TRUE;
addremove_io_fd = &sntp_addremove_fd;
open_sockets();
if (HAVE_OPT(BROADCAST)) {
int cn = STACKCT_OPT( BROADCAST );
const char ** cp = STACKLST_OPT( BROADCAST );
while (cn-- > 0) {
handle_lookup(*cp, CTX_BCST);
cp++;
}
}
if (HAVE_OPT(CONCURRENT)) {
int cn = STACKCT_OPT( CONCURRENT );
const char ** cp = STACKLST_OPT( CONCURRENT );
while (cn-- > 0) {
handle_lookup(*cp, CTX_UCST | CTX_CONC);
cp++;
}
}
for (i = 0; i < argc; ++i)
handle_lookup(argv[i], CTX_UCST);
gettimeofday_cached(base, &start_tv);
event_base_dispatch(base);
event_base_free(base);
if (!time_adjusted &&
(ENABLED_OPT(STEP) || ENABLED_OPT(SLEW)))
exitcode = 1;
else
exitcode = 0;
return exitcode;
}
EventBase::EventBase() {
event_enable_debug_mode();
event_set_log_callback(saylog);
ev_base_ = event_base_new();
}
int main(int argc, char * * argv)
{
struct sigaction sa;
upnpc_t upnp;
char * multicast_if = NULL;
if(argc > 1) {
multicast_if = argv[1];
}
memset(&sa, 0, sizeof(struct sigaction));
sa.sa_handler = sighandler;
if(sigaction(SIGINT, &sa, NULL) < 0) {
perror("sigaction");
}
if(find_local_address() < 0) {
fprintf(stderr, "failed to get local address\n");
return 1;
}
#ifdef DEBUG
event_enable_debug_mode();
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
event_enable_debug_logging(EVENT_DBG_ALL); /* Libevent 2.1.1 */
#endif /* LIBEVENT_VERSION_NUMBER >= 0x02010100 */
#endif /* DEBUG */
printf("Using libevent %s\n", event_get_version());
if(LIBEVENT_VERSION_NUMBER != event_get_version_number()) {
fprintf(stderr, "WARNING build using libevent %s", LIBEVENT_VERSION);
}
base = event_base_new();
if(base == NULL) {
fprintf(stderr, "event_base_new() failed\n");
return 1;
}
#ifdef DEBUG
printf("Using Libevent with backend method %s.\n",
event_base_get_method(base));
#endif /* DEBUG */
if(upnpc_init(&upnp, base, multicast_if, ready, soap, &upnp) != UPNPC_OK) {
fprintf(stderr, "upnpc_init() failed\n");
return 1;
}
upnpc_set_local_address(&upnp, local_address, 50000);
#ifdef ENABLE_UPNP_EVENTS
upnpc_set_event_callback(&upnp, event_callback);
#endif /* ENABLE_UPNP_EVENTS */
if(upnpc_start(&upnp) != UPNPC_OK) {
fprintf(stderr, "upnp_start() failed\n");
return 1;
}
event_base_dispatch(base); /* TODO : check return value */
printf("finishing...\n");
upnpc_finalize(&upnp);
event_base_free(base);
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
libevent_global_shutdown(); /* Libevent 2.1.1 */
#endif
return 0;
}
/**
* Start server.
*
* @return 0 if successful, otherwise -1.
*/
int ad_server_start(ad_server_t *server) {
DEBUG("Starting a server.");
// Set default options that were not set by user..
set_undefined_options(server);
// Hookup libevent's log message.
if (_ad_log_level >= AD_LOG_DEBUG) {
event_set_log_callback(libevent_log_cb);
if (_ad_log_level >= AD_LOG_DEBUG2) {
event_enable_debug_mode();
}
}
// Parse addr
int port = ad_server_get_option_int(server, "server.port");
char *addr = ad_server_get_option(server, "server.addr");
struct sockaddr *sockaddr = NULL;
size_t sockaddr_len = 0;
if (addr[0] == '/') { // Unix socket.
struct sockaddr_un unixaddr;
bzero((void *) &unixaddr, sizeof(struct sockaddr_un));
if (strlen(addr) >= sizeof(unixaddr.sun_path)) {
errno = EINVAL;
DEBUG("Too long unix socket name. '%s'", addr);
return -1;
}
unixaddr.sun_family = AF_UNIX;
strcpy(unixaddr.sun_path, addr); // no need of strncpy()
sockaddr = (struct sockaddr *) &unixaddr;
sockaddr_len = sizeof(unixaddr);
} else if (strstr(addr, ":")) { // IPv6
struct sockaddr_in6 ipv6addr;
bzero((void *) &ipv6addr, sizeof(struct sockaddr_in6));
ipv6addr.sin6_family = AF_INET6;
ipv6addr.sin6_port = htons(port);
evutil_inet_pton(AF_INET6, addr, &ipv6addr.sin6_addr);
sockaddr = (struct sockaddr *) &ipv6addr;
sockaddr_len = sizeof(ipv6addr);
} else { // IPv4
struct sockaddr_in ipv4addr;
bzero((void *) &ipv4addr, sizeof(struct sockaddr_in));
ipv4addr.sin_family = AF_INET;
ipv4addr.sin_port = htons(port);
ipv4addr.sin_addr.s_addr =
(IS_EMPTY_STR(addr)) ? INADDR_ANY : inet_addr(addr);
sockaddr = (struct sockaddr *) &ipv4addr;
sockaddr_len = sizeof(ipv4addr);
}
// SSL
if (!server->sslctx && ad_server_get_option_int(server, "server.enable_ssl")) {
char *cert_path = ad_server_get_option(server, "server.ssl_cert");
char *pkey_path = ad_server_get_option(server, "server.ssl_pkey");
server->sslctx = init_ssl(cert_path, pkey_path);
if (server->sslctx == NULL) {
ERROR("Couldn't load certificate file(%s) or private key file(%s).",
cert_path, pkey_path);
return -1;
}
DEBUG("SSL Initialized.");
}
// Bind
if (! server->evbase) {
server->evbase = event_base_new();
if (! server->evbase) {
ERROR("Failed to create a new event base.");
return -1;
}
}
// Create a eventfd for notification channel.
int notifyfd = eventfd(0, 0);
server->notify_buffer = bufferevent_socket_new(server->evbase, notifyfd, BEV_OPT_CLOSE_ON_FREE);
bufferevent_setcb(server->notify_buffer, NULL, notify_cb, NULL, server);
if (! server->listener) {
server->listener = evconnlistener_new_bind(
server->evbase, listener_cb, (void *)server,
LEV_OPT_THREADSAFE | LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE,
ad_server_get_option_int(server, "server.backlog"),
sockaddr, sockaddr_len);
if (! server->listener) {
ERROR("Failed to bind on %s:%d", addr, port);
return -1;
}
}
// Listen
INFO("Listening on %s:%d%s", addr, port, ((server->sslctx) ? " (SSL)" : ""));
int exitstatus = 0;
if (ad_server_get_option_int(server, "server.thread")) {
DEBUG("Launching server as a thread.")
server->thread = NEW_OBJECT(pthread_t);
pthread_create(server->thread, NULL, &server_loop, (void *)server);
//pthread_detach(server->thread);
} else {
int *retval = server_loop(server);
exitstatus = *retval;
free(retval);
close_server(server);
if (ad_server_get_option_int(server, "server.free_on_stop")) {
ad_server_free(server);
}
}
return exitstatus;
}
void Server::startServer(int port) {
int sock;
event *ev_accept;
struct sockaddr_in server_addr;
event_enable_debug_mode();
event_set_log_callback(write_to_file_cb);
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1"); // INADDR_ANY;
server_addr.sin_port = htons(2000);
sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0) {
printf("ERROR opening socket\n");
exit(1);
}
if(bind(sock, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0) {
printf("ERROR binding socket\n");
exit(1);
}
if(listen(sock, 5) < 0) {
perror("ERROR listening");
exit(1);
}
/*
int reuse = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
*/
printf("DEBUG: listening\n");
if(evthread_use_pthreads() < 0) {
perror("failed start event thread");
exit(1);
}
base = event_base_new();
evutil_make_socket_nonblocking(sock);
startWorkers();
ev_accept = event_new(base, sock, EV_READ|EV_PERSIST, Server::acceptCallback, (void *)this);
event_add(ev_accept, NULL);
event_base_dispatch(base);
event_base_free(base);
base = NULL;
close(sock);
}
int rproxy_start(idevice_t device, rproxy_client_t * client)
{
struct rproxy_client_private * new_client = NULL;
idevice_connection_t control_connection = NULL;
control_thread_context_t * thread_ctx = NULL;
struct event_base * ev_base = NULL;
#ifdef WIN32
/* Initialize Winsock */
WSADATA wsaData = { 0 };
if (0 != WSAStartup(MAKEWORD(2, 2), &wsaData)) {
error("ERROR: Failed to initialize Winsock\n");
return -1;
}
#endif
/* Initialize libevent */
event_set_fatal_callback(libevent_fatal_cb);
event_set_log_callback(libevent_log_cb);
#ifdef WIN32
if (0 != evthread_use_windows_threads()) {
error("ERROR: Failed to initialize libevent's threading support\n");
goto cleanup;
}
#else
if (0 != evthread_use_pthreads()) {
error("ERROR: Failed to initialize libevent's threading support\n");
goto cleanup;
}
#endif
#ifdef _DEBUG
event_enable_debug_mode();
#endif
/* Create a new client struct */
new_client = (rproxy_client_private *)calloc(1, sizeof(rproxy_client_private));
if (NULL == new_client) {
error("ERROR: Out of memory\n");
goto cleanup;
}
/* Create an event base */
new_client->ev_base = event_base_new();
if (NULL == new_client->ev_base) {
error("ERROR: Failed to initialize libevent\n");
goto cleanup;
}
/* Connect to the proxy service */
uint16_t conn_port = 0;
int i = 0;
for (i = 1; i <= CONTROL_CONNTECTION_ATTEMPTS; i++) {
if (0 == rproxy_connect_control_service(device, &control_connection, &conn_port)) {
break;
}
if (CONTROL_CONNTECTION_ATTEMPTS == i) {
error("ERROR: Failed to initialize reverse proxy connection\n");
goto cleanup;
}
sleep(CONTROL_CONNTECTION_ATTEMPTS_INTERVAL);
debug("Failed to connect to the proxy, retrying...\n");
}
/* Start a new thread for the reverse proxy event loop */
thread_ctx = (control_thread_context_t *)calloc(1, sizeof(control_thread_context_t));
if (NULL == thread_ctx) {
error("ERROR: Out of memory\n");
goto cleanup;
}
thread_ctx->device = device;
thread_ctx->control_connection = control_connection;
thread_ctx->connection_port = (uint16_t)conn_port;
thread_ctx->ev_base = new_client->ev_base;
if (0 != thread_create(&(new_client->thread), rproxy_thread_proc, thread_ctx)) {
error("ERROR: Failed to start the reverse proxy thread\n");
goto cleanup;
}
info("Reverse proxy is running\n");
*client = new_client;
return 0;
cleanup:
if (control_connection) {
idevice_disconnect(control_connection);
}
if (new_client) {
if (new_client->ev_base) {
event_base_free(new_client->ev_base);
}
free(new_client);
}
if (thread_ctx) {
free(thread_ctx);
}
#ifdef WIN32
WSACleanup();
#endif
return -1;
}
