void wd_ssl_init(void) {
unsigned char dh1024_p[] = {
0xBC,0xBB,0x2B,0x4F,0x58,0x58,0x9C,0x4D,0x46,0x0D,0xBB,0x9E,
0x4D,0x85,0x69,0x56,0x43,0x5E,0xFB,0xC8,0xF6,0xC0,0xAC,0x8E,
0xCB,0xF6,0x0B,0x38,0x8F,0x25,0xD6,0x7A,0xA1,0x26,0xC4,0x74,
0x74,0x98,0x96,0x3F,0x96,0x90,0x3B,0x00,0x6E,0xE3,0x0A,0x61,
0xA9,0xA2,0x62,0x49,0xDA,0x7D,0xE0,0x6B,0x8F,0xA7,0x89,0x7F,
0x41,0x09,0x09,0xA3,0xA2,0x5F,0x2C,0xD3,0x77,0x26,0x8D,0x81,
0x33,0x04,0xEF,0x40,0x75,0xB2,0xCF,0xBA,0xEF,0xD5,0x08,0xF4,
0x9E,0x30,0xD2,0x57,0x12,0xD6,0xEA,0x86,0xCA,0x10,0x7B,0x4B,
0x93,0x42,0x7E,0x79,0x42,0x36,0x5D,0x2B,0x23,0xDB,0x7E,0xAB,
0xDB,0xFD,0x1B,0xDA,0x86,0x49,0x15,0x92,0x41,0x56,0xDD,0x68,
0x2C,0x7F,0xAA,0x34,0x56,0x80,0xA5,0x8B };
unsigned char dh1024_g[] = { 0x02 };
wd_control_socket_tls = wi_socket_tls_init_with_type(wi_socket_tls_alloc(), WI_SOCKET_TLS_SERVER);
wd_transfer_socket_tls = wi_socket_tls_init_with_type(wi_socket_tls_alloc(), WI_SOCKET_TLS_SERVER);
if(!wd_control_socket_tls || !wd_transfer_socket_tls)
wi_log_fatal(WI_STR("Could not create TLS context: %m"));
if(!wi_socket_tls_set_dh(wd_control_socket_tls, dh1024_p, sizeof(dh1024_p), dh1024_g, sizeof(dh1024_g)) ||
!wi_socket_tls_set_dh(wd_transfer_socket_tls, dh1024_p, sizeof(dh1024_p), dh1024_g, sizeof(dh1024_g)))
wi_log_fatal(WI_STR("Could not set anonymous DH key: %m"));
}
static void wd_banlist_create_tables(void) {
wi_uinteger_t version;
version = wd_database_version_for_table(WI_STR("banlist"));
switch(version) {
case 0:
if(!wi_sqlite3_execute_statement(wd_database, WI_STR("CREATE TABLE banlist ( "
"ip TEXT NOT NULL, "
"expiration_date TEXT, "
"PRIMARY KEY (ip) "
")"),
NULL)) {
wi_log_fatal(WI_STR("Could not execute database statement: %m"));
}
break;
}
wd_database_set_version_for_table(1, WI_STR("banlist"));
}
int main(int argc, const char **argv) {
wi_pool_t *pool;
wi_string_t *user, *password, *root_path;
wi_mutable_url_t *url;
int ch;
wi_initialize();
wi_load(argc, argv);
wi_log_tool = true;
wi_log_level = WI_LOG_DEBUG;
pool = wi_pool_init(wi_pool_alloc());
user = WI_STR("guest");
password = WI_STR("");
root_path = WI_STR(WD_ROOT);
while((ch = getopt(argc, (char * const *) argv, "d:p:u:")) != -1) {
switch(ch) {
case 'd':
root_path = wi_string_with_cstring(optarg);
break;
case 'p':
password = wi_string_with_cstring(optarg);
break;
case 'u':
user = wi_string_with_cstring(optarg);
break;
case '?':
case 'h':
default:
wc_usage();
break;
}
}
argc -= optind;
argv += optind;
if(argc != 1)
wc_usage();
if(!wi_fs_change_directory(root_path))
wi_log_fatal(WI_STR("Could not change directory to %@: %m"), root_path);
wc_spec = wi_p7_spec_init_with_file(wi_p7_spec_alloc(), WI_STR("wired.xml"), WI_P7_CLIENT);
if(!wc_spec)
wi_log_fatal(WI_STR("Could not open wired.xml: %m"));
url = wi_url_init_with_string(wi_mutable_url_alloc(), wi_string_with_cstring(argv[0]));
wi_mutable_url_set_scheme(url, WI_STR("wired"));
if(!url)
wc_usage();
wi_mutable_url_set_user(url, user);
wi_mutable_url_set_password(url, password);
if(wi_url_port(url) == 0)
wi_mutable_url_set_port(url, 4871);
if(!wi_url_is_valid(url))
wc_usage();
signal(SIGPIPE, SIG_IGN);
wc_test(url, 10, WI_STR("/transfertest"));
wi_release(pool);
return 0;
}
void wd_transfers_schedule(void) {
if(!wi_thread_create_thread(wd_transfers_queue_thread, NULL))
wi_log_fatal(WI_STR("Could not create a transfers queue thread: %m"));
}
int main(int argc, const char **argv) {
wi_mutable_array_t *arguments;
wi_pool_t *pool;
wi_string_t *string, *root_path;
int ch, facility;
wi_boolean_t test_config, daemonize, change_directory, switch_user;
/* init libwired */
wi_initialize();
wi_load(argc, argv);
pool = wi_pool_init(wi_pool_alloc());
wi_log_syslog = true;
wi_log_syslog_facility = LOG_DAEMON;
/* init core systems */
wt_version_init();
wt_status_lock = wi_lock_init(wi_lock_alloc());
wt_start_date = wi_date_init(wi_date_alloc());
/* set defaults */
root_path = WI_STR(WT_ROOT);
wi_settings_config_path = wi_string_init_with_cstring(wi_string_alloc(), WT_CONFIG_PATH);
test_config = false;
daemonize = true;
change_directory = true;
switch_user = true;
/* init reexec argument list */
arguments = wi_array_init(wi_mutable_array_alloc());
/* parse command line switches */
while((ch = getopt(argc, (char * const *) argv, "46Dd:f:hi:L:ls:tuVvXx")) != -1) {
switch(ch) {
case '4':
wt_address_family = WI_ADDRESS_IPV4;
break;
case '6':
wt_address_family = WI_ADDRESS_IPV6;
break;
case 'D':
daemonize = false;
wi_log_stderr = true;
break;
case 'd':
root_path = wi_string_with_cstring(optarg);
break;
case 'f':
wi_release(wi_settings_config_path);
wi_settings_config_path = wi_string_init_with_cstring(wi_string_alloc(), optarg);
break;
case 'i':
wi_log_limit = wi_string_uint32(wi_string_with_cstring(optarg));
break;
case 'L':
wi_log_syslog = false;
wi_log_file = true;
wi_release(wi_log_path);
wi_log_path = wi_string_init_with_cstring(wi_string_alloc(), optarg);
break;
case 'l':
wi_log_level++;
break;
case 's':
string = wi_string_with_cstring(optarg);
facility = wi_log_syslog_facility_with_name(string);
if(facility < 0)
wi_log_fatal(WI_STR("Could not find syslog facility \"%@\": %m"), string);
wi_log_syslog_facility = facility;
break;
case 't':
test_config = true;
break;
case 'u':
break;
case 'V':
case 'v':
wt_version();
break;
case 'X':
daemonize = false;
break;
case 'x':
daemonize = false;
change_directory = false;
switch_user = false;
break;
case '?':
case 'h':
default:
wt_usage();
break;
}
wi_mutable_array_add_data(arguments, wi_string_with_format(WI_STR("-%c"), ch));
if(optarg)
wi_mutable_array_add_data(arguments, wi_string_with_cstring(optarg));
}
/* detach */
if(daemonize) {
wi_mutable_array_add_data(arguments, WI_STR("-X"));
switch(wi_fork()) {
case -1:
wi_log_fatal(WI_STR("Could not fork: %m"));
break;
case 0:
if(!wi_execv(wi_string_with_cstring(argv[0]), arguments))
wi_log_fatal(WI_STR("Could not execute %s: %m"), argv[0]);
break;
default:
_exit(0);
break;
}
}
wi_release(arguments);
/* change directory */
if(change_directory) {
if(!wi_fs_change_directory(root_path))
wi_log_error(WI_STR("Could not change directory to %@: %m"), root_path);
}
/* open log */
wi_log_open();
/* init subsystems */
wt_ssl_init();
wt_clients_init();
wt_servers_init();
/* read the config file */
wt_settings_init();
if(!wt_settings_read_config())
exit(1);
/* apply settings */
wt_settings_apply_settings();
if(test_config) {
printf("Config OK\n");
exit(0);
}
/* dump command line */
wi_log_info(WI_STR("Started as %@ %@"),
wi_process_path(wi_process()),
wi_array_components_joined_by_string(wi_process_arguments(wi_process()), WI_STR(" ")));
/* init tracker */
wi_log_info(WI_STR("Starting Wired Tracker version %@"), wt_version_string);
wt_tracker_init();
/* switch user/group */
if(switch_user)
wi_switch_user(wt_settings.user, wt_settings.group);
/* create tracker threads after privilege drop */
wt_signals_init();
wt_block_signals();
wt_servers_schedule();
wt_tracker_create_threads();
wt_write_pid();
wt_write_status(true);
/* clean up pool after startup */
wi_pool_drain(pool);
/* enter the signal handling thread in the main thread */
wt_signal_thread(NULL);
/* dropped out */
wt_cleanup();
wi_log_close();
wi_release(pool);
return 0;
}
void wd_server_init(void) {
wi_enumerator_t *enumerator;
wi_array_t *array, *addresses;
wi_address_t *address;
wi_socket_t *control_socket, *transfer_socket;
wi_string_t *ip, *string;
wi_address_family_t family;
wd_control_sockets = wi_array_init(wi_mutable_array_alloc());
wd_transfer_sockets = wi_array_init(wi_mutable_array_alloc());
addresses = wi_array_init(wi_mutable_array_alloc());
if(wi_array_count(wd_settings.address) > 0) {
/* listen on configured addresses */
wi_array_rdlock(wd_settings.address);
enumerator = wi_array_data_enumerator(wd_settings.address);
while((string = wi_enumerator_next_data(enumerator))) {
array = wi_host_addresses(wi_host_with_string(string));
if(array)
wi_mutable_array_add_data_from_array(addresses, array);
else
wi_log_err(WI_STR("Could not resolve \"%@\": %m"), string);
}
wi_array_unlock(wd_settings.address);
} else {
/* add wildcard addresses */
wi_mutable_array_add_data(addresses, wi_address_wildcard_for_family(WI_ADDRESS_IPV6));
wi_mutable_array_add_data(addresses, wi_address_wildcard_for_family(WI_ADDRESS_IPV4));
}
enumerator = wi_array_data_enumerator(addresses);
while((address = wi_enumerator_next_data(enumerator))) {
ip = wi_address_string(address);
family = wi_address_family(address);
/* force address family? */
if(wd_address_family != WI_ADDRESS_NULL && family != wd_address_family)
continue;
/* create sockets */
wi_address_set_port(address, wd_settings.port);
control_socket = wi_autorelease(wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP));
wi_address_set_port(address, wd_settings.port + 1);
transfer_socket = wi_autorelease(wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP));
if(!control_socket || !transfer_socket) {
wi_log_warn(WI_STR("Could not create socket for %@: %m"), ip);
continue;
}
/* listen on sockets */
if(!wi_socket_listen(control_socket)) {
wi_log_warn(WI_STR("Could not listen on %@ port %u: %m"),
ip, wi_address_port(wi_socket_address(control_socket)));
continue;
}
if(!wi_socket_listen(transfer_socket)) {
wi_log_warn(WI_STR("Could not listen on %@ port %u: %m"),
ip, wi_address_port(wi_socket_address(transfer_socket)));
continue;
}
wi_socket_set_interactive(control_socket, true);
wi_socket_set_interactive(transfer_socket, false);
/* add to list of sockets */
wi_mutable_array_add_data(wd_control_sockets, control_socket);
wi_mutable_array_add_data(wd_transfer_sockets, transfer_socket);
wi_log_info(WI_STR("Listening on %@ ports %d-%d"),
ip, wd_settings.port, wd_settings.port + 1);
}
if(wi_array_count(wd_control_sockets) == 0 || wi_array_count(wd_transfer_sockets) == 0)
wi_log_fatal(WI_STR("No addresses available for listening"));
wi_release(addresses);
#ifdef HAVE_DNS_SD_H
if(wd_settings.zeroconf)
wd_server_register_dnssd();
#endif
}
void wd_server_create_threads(void) {
if(!wi_thread_create_thread(wd_control_listen_thread, NULL) ||
!wi_thread_create_thread(wd_transfer_listen_thread, NULL))
wi_log_fatal(WI_STR("Could not create a listen thread: %m"));
}
static void _wi_timer_create_thread(void) {
if(!wi_thread_create_thread(_wi_timer_thread, NULL))
wi_log_fatal(WI_STR("Could not create a timer thread: %m"));
}
