bool UpdateHTTPServerLogging(bool enable) {
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
if (enable) {
event_enable_debug_logging(EVENT_DBG_ALL);
} else {
event_enable_debug_logging(EVENT_DBG_NONE);
}
return true;
#else
// Can't update libevent logging if version < 02010100
return false;
#endif
}
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)
{
/* 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;
}
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;
}
bool InitHTTPServer()
{
struct evhttp* http = 0;
struct event_base* base = 0;
if (!InitHTTPAllowList())
return false;
if (GetBoolArg("-rpcssl", false)) {
uiInterface.ThreadSafeMessageBox(
"SSL mode for RPC (-rpcssl) is no longer supported.",
"", CClientUIInterface::MSG_ERROR);
return false;
}
// Redirect libevent's logging to our own log
event_set_log_callback(&libevent_log_cb);
#if LIBEVENT_VERSION_NUMBER >= 0x02010100
// If -debug=libevent, set full libevent debugging.
// Otherwise, disable all libevent debugging.
if (LogAcceptCategory("libevent"))
event_enable_debug_logging(EVENT_DBG_ALL);
else
event_enable_debug_logging(EVENT_DBG_NONE);
#endif
#ifdef WIN32
evthread_use_windows_threads();
#else
evthread_use_pthreads();
#endif
base = event_base_new(); // XXX RAII
if (!base) {
LogPrintf("Couldn't create an event_base: exiting\n");
return false;
}
/* Create a new evhttp object to handle requests. */
http = evhttp_new(base); // XXX RAII
if (!http) {
LogPrintf("couldn't create evhttp. Exiting.\n");
event_base_free(base);
return false;
}
evhttp_set_timeout(http, GetArg("-rpcservertimeout", DEFAULT_HTTP_SERVER_TIMEOUT));
evhttp_set_max_headers_size(http, MAX_HEADERS_SIZE);
evhttp_set_max_body_size(http, MAX_SIZE);
evhttp_set_gencb(http, http_request_cb, NULL);
if (!HTTPBindAddresses(http)) {
LogPrintf("Unable to bind any endpoint for RPC server\n");
evhttp_free(http);
event_base_free(base);
return false;
}
LogPrint("http", "Initialized HTTP server\n");
int workQueueDepth = std::max((long)GetArg("-rpcworkqueue", DEFAULT_HTTP_WORKQUEUE), 1L);
LogPrintf("HTTP: creating work queue of depth %d\n", workQueueDepth);
workQueue = new WorkQueue<HTTPClosure>(workQueueDepth);
eventBase = base;
eventHTTP = http;
return true;
}
