int server_main(int port)
{
struct sockaddr_in *sin;
if ((ssock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET)
{
my_printf("Raytracer: Clustering: Error: Cant create socket.\n");
return (EXIT_FAILURE);
}
my_printf("[*] Raytracer: Clustering: Socket: Open(TCP/IP) ...");
if ((sin = server_sockaddr_create(port)) == NULL)
return (EXIT_FAILURE);
my_printf(" \033[32mDone !\033[00m\n");
if ((bind(ssock, (struct sockaddr *)sin, sizeof(*sin))) == SOCKET_ERROR)
{
my_printf("Raytracer: Clustering: Error: Port already use.\n");
return (EXIT_FAILURE);
}
signal(SIGINT, server_close);
if ((listen(ssock, MAX_CLIENT)) == SOCKET_ERROR)
return (EXIT_FAILURE);
if ((server_listen(ssock)) == EXIT_FAILURE)
return (EXIT_FAILURE);
return (EXIT_SUCCESS);
}
// Server Respond Functon
static void server_respond(int to_server)
{
// Client "Attributes"
int client_pid = 0;
char str_client_pid[256];
int to_client = 0;
int input_str_size = 0;
int new_str_size = 0;
char *input_str = 0;
char *new_str = 0;
// Fork Off
int f = fork();
// Child
if ( f == 0 )
{
// Get Client PID (client pipe)
read(to_server, &client_pid, sizeof(int));
// Get Input String Size
read(to_server, &input_str_size, sizeof(int));
// Get Input String
input_str = (char *) malloc( input_str_size + 1 );
read(to_server, input_str, input_str_size);
// Modify Input String
new_str = (char *) strfry(input_str);
// Connect to Client Pipe
sprintf(str_client_pid, "%d", client_pid);
to_client = open( str_client_pid, O_WRONLY );
// Send size of string
new_str_size = strlen(new_str);
write(to_client, &new_str_size, sizeof(int));
// Send New String
write(to_client, new_str, new_str_size);
// Cleanup
close(to_client);
close(to_server);
free(new_str);
exit(0);
}
// Parent
else
{
// Close Pipe
close(to_server);
// Remove WKP
remove(WKP);
// Listen
server_listen();
}
}
int main(int argc, const char *argv[])
{
if (argc != 3)
{
print_usage();
return 1;
}
setup_signal_handlers();
server *s = server_create((uint16_t)atoi(argv[1]), argv[2]);
server_listen(s);
printf("Listening...\n");
fflush(stdout);
while (running)
{
server_wait(s);
}
printf("Shutting down...\n");
fflush(stdout);
server_close(s);
server_destroy(s);
return 0;
}
static int run(void)
{
int ret = 0;
if (!dst_addr) {
ret = server_listen();
if (ret)
return ret;
}
ret = dst_addr ? client_connect() : server_connect();
if (ret) {
return ret;
}
run_test();
fi_shutdown(ep, 0);
fi_close(&ep->fid);
free_ep_res();
if (!dst_addr)
free_lres();
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
/* spawns a new transaction thread */
void tx_manager_spawn(worker_state_t* wstate, const char* tm_host, uint32_t tm_port, uint32_t transaction)
{
wstate->is_active = true;
wstate->transaction = transaction;
wstate->server = NULL;
wstate->tm_port = tm_port;
wstate->do_abort = false;
wstate->do_commit = true;
strcpy(wstate->tm_host, tm_host);
/* TODO: restore listening port */
int listen_port = 0;
if (wstate->uncertain)
listen_port = wstate->txlog->header->tm_listen_port;
else {
wstate->txlog->header->tm_port = tm_port;
strcpy(wstate->txlog->header->tm_host, tm_host);
}
/* Set up server :: TMananger*/
server_alloc(&wstate->server, listen_port, 10);
server_listen(wstate->server);
/* store ports & TM address in transaction log */
wstate->txlog->header->tm_listen_port = wstate->server->port;
pthread_t thread;
pthread_create(&thread, NULL, tx_worker_thread, (void*)wstate);
}
static int run(void)
{
int i, ret = 0;
buf = malloc(!custom ? test_size[TEST_CNT - 1].size : transfer_size);
if (!buf) {
perror("malloc");
return -1;
}
if (!dst_addr) {
ret = server_listen();
if (ret)
goto free;
}
printf("%-10s%-8s%-8s%-8s%-8s%8s %10s%13s\n",
"name", "bytes", "xfers", "iters", "total", "time", "Gb/sec", "usec/xfer");
if (!custom) {
optimization = opt_latency;
ret = dst_addr ? client_connect() : server_connect();
if (ret)
goto free;
for (i = 0; i < TEST_CNT; i++) {
if (test_size[i].option > size_option)
continue;
init_latency_test(test_size[i].size);
run_test();
}
rshutdown(rs, SHUT_RDWR);
rclose(rs);
optimization = opt_bandwidth;
ret = dst_addr ? client_connect() : server_connect();
if (ret)
goto free;
for (i = 0; i < TEST_CNT; i++) {
if (test_size[i].option > size_option)
continue;
init_bandwidth_test(test_size[i].size);
run_test();
}
} else {
ret = dst_addr ? client_connect() : server_connect();
if (ret)
goto free;
ret = run_test();
}
rshutdown(rs, SHUT_RDWR);
rclose(rs);
free:
free(buf);
return ret;
}
int
main (int argc, const char *argv[])
{
int fd;
unsigned short port;
port = TS_PORT;
char *addr = TS_SERVER_ADDRESS;
pid_t child_pid;
//step 1:
fd = get_sock_fd ();
struct sockaddr_in my_addr;
memset (&my_addr, 0, sizeof (my_addr));
//step 2:
bind_addr (fd, addr, port, &my_addr);
//step 3:
server_listen (fd, BACKLOG);
//step 4:
int new_fd;
struct sockaddr_in new_addr;
memset (&new_addr, 0, sizeof (new_addr));
socklen_t new_addr_len = 1;
signal(SIGCHLD, sig_chld);
signal(SIGINT, sig_int);
while (1)
{
if ((new_fd =
accept (fd, (struct sockaddr *) &new_addr, &new_addr_len)) == -1)
{
if (errno == EINTR) {
continue;
}else {
perror ("accept error");
close (fd);
}
}
else
{
if ((child_pid = fork()) == 0) {
close(fd);
server_client (new_fd);
exit(0);
}
close(new_fd);
}
}
return 0;
}
int main(int argc, char **argv)
{
int op, ret;
opts = INIT_OPTS;
hints = fi_allocinfo();
if (!hints)
return EXIT_FAILURE;
while ((op = getopt(argc, argv, "h" ADDR_OPTS INFO_OPTS)) != -1) {
switch (op) {
default:
ft_parse_addr_opts(op, optarg, &opts);
ft_parseinfo(op, optarg, hints);
break;
case '?':
case 'h':
ft_usage(argv[0], "A simple MSG client-sever example that "
"demonstrates one possible usage of the underlying "
"cq wait objects.");
return EXIT_FAILURE;
}
}
if (optind < argc)
opts.dst_addr = argv[optind];
hints->ep_attr->type = FI_EP_MSG;
hints->caps = FI_MSG;
hints->mode = FI_LOCAL_MR;
hints->addr_format = FI_SOCKADDR;
/* Fabric and connection setup */
if (!opts.dst_addr) {
ret = server_listen();
if (ret)
return -ret;
}
ret = opts.dst_addr ? client_connect() : server_connect();
if (ret) {
return -ret;
}
/* Exchange data */
ret = send_recv();
fi_shutdown(ep, 0);
free_ep_res();
fi_close(&cmeq->fid);
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
int main(int argc, char *argv[]) {
int opt = 0;
Arg_t optInfo;
progname = argv[0];
optInfo.cgiDir = NULL;
optInfo.ipAddr = NULL;
optInfo.logFile = NULL;
optInfo.port = "8080";
const char *optString = "c:dhi:l:p:";
char *endptr;
int pt;
while ((opt = getopt(argc, argv, optString)) != -1) {
switch (opt) {
case 'c': /* CGI */
optInfo.cgiDir = optarg;
break;
case 'd': /* debugging mode */
break;
case 'h': /* usage summary */
usage();
break;
case 'i': /* bind to given IPv4/6 address */
optInfo.ipAddr = optarg;
break;
case 'l': /* Log all request to given file */
optInfo.logFile = optarg;
break;
case 'p': /* Listen on the given port */
pt = strtol(optarg, &endptr, 10);
if (!*endptr && pt >= 0 && pt <= 65535)
optInfo.port = optarg;
else
fprintf(stderr, "Please input Port Number between 0-65535\n"), exit(1);
break;
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
server_listen(&optInfo);
free(optInfo.cgiDir);
free(optInfo.ipAddr);
free(optInfo.logFile);
free(optInfo.port);
exit(EXIT_SUCCESS);
}
int main(void) {
Server *server = server_new("0.0.0.0", 7000);
//Server *server = server_new("::", 7000);
Status rc;
rc = server_listen(server, 0);
insist_return(rc == GREAT_SUCCESS, rc, "Server failed to start listening")
printf("fd: %d\n", server->fd);
server_accept(server);
return 0;
} /* main */
// Main Function
int main()
{
// Attach Signals
signal( SIGTERM, sighandler );
signal( SIGINT, sighandler );
signal( SIGPIPE, sighandler );
// Server Runtime
server_listen();
return 0;
}
void ICACHE_FLASH_ATTR listen_chk_timer_cb(void* _timer)
{
//start tcp listen ...
os_printf("listen chk timer cb, timer: [%p]\n", _timer);
ETSTimer* timer = (ETSTimer*)_timer;
uint8 mode = wifi_get_opmode();
if(mode == STATION_MODE && wifi_station_get_connect_status() != STATION_GOT_IP) {
os_printf("station cannot got ip , cannot start server listen.\n");
return ;
}
os_timer_disarm(timer);
server_listen();
}
void test_server()
{
socket_t serverfd = server_create("127.0.0.1", SERVER_PORT);
setnonblocking(serverfd);
server_listen(serverfd);
event_manager_t event_manager;
event_manager_init(&event_manager, serverfd, my_event_callback);
event_dispatch(&event_manager);
event_magager_destroy(&event_manager);
}
// create and init the 'server' structure.
static void init_servers(system_data_t *sysdata)
{
char *str;
assert(sysdata);
assert(sysdata->servers == NULL);
sysdata->servers = ll_init(NULL);
assert(sysdata->servers);
assert(sysdata->settings->port > 0);
assert(sysdata->settings->interfaces);
if (ll_count(sysdata->settings->interfaces) == 0) {
// no interfaces were specified, so we need to bind to all of them.
server_listen(sysdata, sysdata->settings->port, NULL);
}
else {
// we have some specific interfaces, so we will bind to each of them only.
while ((str = ll_pop_tail(sysdata->settings->interfaces))) {
server_listen(sysdata, sysdata->settings->port, str);
free(str);
}
}
}
static int run(void)
{
int i, ret = 0;
if (!opts.dst_addr) {
ret = server_listen();
if (ret)
return ret;
}
ret = opts.dst_addr ? client_connect() : server_connect();
if (ret)
return ret;
ret = exchange_addr_key();
if (ret)
return ret;
if (!(opts.user_options & FT_OPT_SIZE)) {
for (i = 0; i < TEST_CNT; i++) {
if (test_size[i].option > opts.size_option)
continue;
opts.transfer_size = test_size[i].size;
init_test(&opts, test_name, sizeof(test_name));
ret = run_test();
if (ret)
goto out;
}
} else {
init_test(&opts, test_name, sizeof(test_name));
ret = run_test();
if (ret)
goto out;
}
sync_test();
wait_for_data_completion(scq, max_credits - credits);
/* Finalize before closing ep */
ft_finalize(ep, scq, rcq, FI_ADDR_UNSPEC);
out:
fi_shutdown(ep, 0);
free_ep_res();
if (!opts.dst_addr)
free_lres();
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
int TCP_Helper::server_open_endpoints(__u8* eps,__u8 num_eps,int timeout) {
int i;
struct pollfd* poll_connections=NULL;
__u8* poll_idxs=NULL;
int poll_count=0;
int poll_idx=0;
for (i=0;i<num_eps;i++) {
int idx=(eps[i]&0x80)?(eps[i]&0xf)|0x10:eps[i];
if (!ep_connect[idx]) {
if (!ep_listener[idx]) {
fprintf(stderr,"Listening EP%02x\n",eps[i]);
server_listen(idx);
}
poll_count++;
}
}
poll_connections=(struct pollfd*)calloc(poll_count,sizeof(struct pollfd));
poll_idxs=(__u8*)calloc(poll_count,sizeof(__u8));
for (i=0;i<num_eps;i++) {
int idx=(eps[i]&0x80)?(eps[i]&0xf)|0x10:eps[i];
if (!ep_connect[idx]) {
TRACE3(i,idx,ep_listener[idx])
poll_connections[poll_idx].fd=ep_listener[idx];
poll_connections[poll_idx].events=POLLIN;
poll_idxs[poll_idx]=idx;
poll_idx++;
}
}
int ep_count=poll_count;
int rc=-1;
TRACE1(poll_count)
if (poll(poll_connections,poll_count,timeout)) {
TRACE
for (poll_idx=0;poll_idx<poll_count;poll_idx++) {
TRACE1(poll_idx)
if (poll_connections[poll_idx].revents==POLLIN) {
int idx=poll_idxs[poll_idx];
if (server_connect(idx,0)==0) {
fprintf(stderr,"Connected EP%02x\n",(idx&0xf) | ((idx&0x10)<<3));
ep_buf[idx] = (__u8*) malloc(TCP_BUFFER_SIZE);
ep_count--;
}
}
}
rc=ep_count;
} else {
static int server_reject(size_t paramlen)
{
int ret;
ret = server_listen(paramlen);
if (ret)
return ret;
/* Data will appear in error event generated on remote end. */
ft_fill_buf(cm_data, paramlen);
ret = fi_reject(pep, fi->handle, cm_data, paramlen);
if (ret)
FT_PRINTERR("fi_reject", ret);
return ret;
}
/**
* Server function that listens for messages from clients
*/
void *server(void *token)
{
me.self = setupNode();
char message[BUFFER_LENGTH];
int numNodes = 0;
char *line = NULL;
size_t len = 0;
ssize_t read;
do {
//sleep(3);
me.endpoints_fp = fopen(ENDPOINTS, "a+");
} while (me.endpoints_fp == NULL);
while ((read = getline(&line, &len, me.endpoints_fp)) != -1) {
line[read - 1] = '\0';
read--;
numNodes++;
debug("Read %s from endpoints file", line);
}
me.id = numNodes;
debug("Done reading endpoints file, we have id: %d", me.id);
if (args.num_nodes - 1 == numNodes) {
debug("We are the last process");
me.last_process = TRUE;
}
fprintf(me.endpoints_fp, "%s\n", getNodeInfo(me.self));
debug("Node info written to endpoints file");
fclose(me.endpoints_fp);
if (!me.last_process) {
// wait for OK message
debug("Waiting for \"OK\" message");
if (recvfrom(me.self->socket, message, BUFFER_LENGTH, 0, NULL, NULL) == -1) {
log_err("Failed to receive message");
}
debug("Received message %s", message);
if (strcmp(message, "OK") == 0) {
debug("Got the \"OK\"");
}
}
pthread_barrier_wait(&me.barrier);
free(line);
server_listen(message);
}
int main(int argc, char * argv[])
{
int sockfd;
int newsockfd;
int rcvbuf = BUFSIZE;
int reuseaddr = 1;
long long t = 0;
SIMPLEOT_SENDER sender;
//
if (argc != 2)
{
fprintf(stderr, "usage %s port\n", argv[0]); exit(-1);
}
//
sockfd = server_listen(atoi(argv[1]));
newsockfd = server_accept(sockfd);
if (setsockopt(newsockfd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)) != 0) { perror("ERROR setsockopt"); exit(-1); }
if (setsockopt(newsockfd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr)) != 0) { perror("ERROR setsockopt"); exit(-1); }
t -= cpucycles_amd64cpuinfo();
ot_sender_test(&sender, newsockfd);
t += cpucycles_amd64cpuinfo();
//
if (!VERBOSE) printf("[n=%d] Elapsed time: %lld cycles\n", NOTS, t);
shutdown (newsockfd, 2);
shutdown (sockfd, 2);
//
return 0;
}
static int run(void)
{
int i, ret = 0;
if (!dst_addr) {
ret = server_listen();
if (ret)
return ret;
}
print_test_hdr();
ret = dst_addr ? client_connect() : server_connect();
if (ret) {
return ret;
}
if (!custom) {
for (i = 0; i < TEST_CNT; i++) {
if (test_size[i].option > size_option)
continue;
init_test(test_size[i].size, test_name, &transfer_size, &iterations);
run_test();
}
} else {
ret = run_test();
}
ret = wait_for_completion(scq, max_credits - credits);
if (ret) {
return ret;
}
credits = max_credits;
fi_shutdown(ep, 0);
fi_close(&ep->fid);
free_ep_res();
if (!dst_addr)
free_lres();
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
int TCP_Helper::connect(int timeout) {
int rc;
if(p_server) {
server_listen(0);
if(!ep_listener[0]) {
usleep(timeout*1000);
rc=ETIMEDOUT;
} else {
rc=server_connect(0,timeout);
}
} else {
rc=client_connect(0,timeout);
}
p_is_connected=rc==0;
//sized to handle ETHERNET less IP(20 byte)/TCP(max 24 byte) headers
if (p_is_connected) ep_buf[0] = (__u8*)calloc(TCP_BUFFER_SIZE,sizeof(__u8));
return rc;
}
/*
* A server thread (task)
* assumes network is started and shutdown by parent thread
*/
server_task (XML *xml)
{
SSL_CTX *ctx;
NETCON *conn, *ssl;
int port, threads, e;
if ((threads = xml_get_int (xml, "Phineas.Server.NumThreads")) == 0)
threads = 2;
if (port = xml_get_int (xml, "Phineas.Server.Port"))
{
if ((conn = net_open ("ANY", port, threads, NULL)) == NULL)
{
return (phineas_fatal ("Failed to open port %d\n", port));
}
}
if (port = xml_get_int (xml, "Phineas.Server.SSL.Port"))
{
ctx = server_ctx (xml);
if ((ssl = net_open ("ANY", port, threads, ctx)) == NULL)
{
if (conn != NULL)
net_close (conn);
return (phineas_fatal ("Failed to open SSL port %d\n", port));
}
if (conn != NULL)
threads *= 2;
}
e = server_listen (xml, conn, ssl, ctx, threads);
if (conn != NULL)
net_close (conn);
if (ssl != NULL)
{
net_close (ssl);
if (ctx != NULL)
SSL_CTX_free (ctx);
}
if (e)
phineas_fatal ("Failed to start PHINEAS server");
return (0);
}
void server_start(unsigned short port, int * server_socket_fd, list_node * question_pool, list_node * results)
{
//region Initialize/declare variables
struct sockaddr_in server = server_create_sin(port);
int server_fd = server_create_socket();
*server_socket_fd = server_fd;
server_listen(server_fd, &server);
struct sockaddr_in client_addr;
int client_socket_fd;
socklen_t client_socket_len = sizeof(struct sockaddr_in);
//endregion
//region Listen and handle connections in new threads
printf("Listening for connections on port %d...\n", port);
while ((client_socket_fd = accept(server_fd, (struct sockaddr *) &client_addr, &client_socket_len)))
{
client_handler_data_holder * holder = create_holder(client_socket_fd, &client_addr, question_pool, results);
//region Log connection
{
char ip_str[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &client_addr.sin_addr, ip_str, INET_ADDRSTRLEN);
printf("Client (%s) connected\n", ip_str);
}
//endregion
pthread_t thread;
int res = pthread_create(&thread, NULL, handle_connection, holder);
if (res < 0)
{
perror("Could not create client handler thread");
return;
}
pthread_detach(thread);
}
//endregion
}
int main( int argc, char* argv[] ) {
int ret;
SSL_CTX* ctx_server = ssl_server_init(SERVER_CERTIFICATE, SERVER_KEY);
SSL_CTX* ctx_client = ssl_client_init();
int listen_socket;
int accept_socket;
listen_socket = server_listen("5003");
if( listen_socket < 0 ) {
std::cout<<"socket error."<<std::endl;
return -1;
}
accept_socket = accept (listen_socket, NULL, NULL);
if( accept_socket < 0 ) {
std::cout<<"accept error."<<std::endl;
return -1;
}
close(listen_socket);
SSL *ssl = ssl_server(ctx_server, accept_socket);
char buf [4096];
ret = SSL_read (ssl, buf, sizeof(buf) - 1);
if( ret == -1 ) {
std::cout<<"SSL_read error."<<std::endl;
return -1;
}
buf[ret] = '\0';
printf("%s\n", buf);
int client_socket = client_connect("127.0.0.1", "5004");
SSL *ssl_cli = ssl_client(ctx_client, client_socket);
ret = SSL_write (ssl_cli, "I hear you.", strlen("I hear you."));
if( ret == -1 ) {
std::cout<<"SSL_write error."<<std::endl;
return -1;
}
return 0;
}
int main(int argc, char ** argv) {
if (argc != 2) {
printf("Usage: server pathname\n");
return 0;
}
int listenfd = server_listen(argv[1]);
int connection_fd;
struct sockaddr_un un;
socklen_t len = sizeof(un);
while (1) {
connection_fd = accept(listenfd, (struct sockaddr*)&un, &len);
if (fork() == 0) {
return connection_handler(connection_fd);
}
close(connection_fd);
}
close(listenfd);
unlink(argv[1]);
return 0;
}
static int run(void)
{
char *node, *service;
uint64_t flags;
int ret;
ret = ft_read_addr_opts(&node, &service, hints, &flags, &opts);
if (ret)
return ret;
if (!opts.src_port)
opts.src_port = "9229";
if (!opts.src_addr) {
fprintf(stderr, "Source address (-s) is required for this test\n");
return -EXIT_FAILURE;
}
ret = setup_handle();
if (ret)
return ret;
if (!opts.dst_addr) {
ret = server_listen();
if (ret)
return ret;
}
ret = opts.dst_addr ? client_connect() : server_connect();
if (ret) {
return ret;
}
ret = send_recv();
fi_shutdown(ep, 0);
return ret;
}
static int run(void)
{
int i, ret = 0;
if (!client) {
ret = server_listen();
if (ret)
return ret;
}
printf("%-8s%-8s%-8s%8s %10s%13s\n",
"bytes", "iters", "total", "time", "MB/sec", "usec/xfer");
ret = client ? client_connect() : server_connect();
if (ret)
return ret;
if (!custom) {
for (i = 0; i < TEST_CNT; i++) {
if (test_size[i].option > size_option)
continue;
init_test(test_size[i].size);
ret = run_test();
}
} else {
ret = run_test();
}
fi_shutdown(ep, 0);
fi_close(&ep->fid);
free_ep_res();
if (!client)
free_lres();
fi_close(&dom->fid);
fi_close(&fab->fid);
return ret;
}
void server_run (server_t * s, const char * port)
{
int i;
server_bind(s, port);
server_listen(s);
// Clear the master and temp sets
FD_ZERO(&(s->master));
FD_ZERO(&(s->read_fds));
// Add the listener to the master set
FD_SET(s->listener, &(s->master));
// Keep track of the biggest file descriptor
s->fdmax = s->listener; // so far, it's this one
while (1) {
s->read_fds = s->master;
if (select(s->fdmax + 1, &(s->read_fds), NULL, NULL, NULL) == -1) {
exit(1);
}
for (i = 0; i <= s->fdmax; i ++) {
if (FD_ISSET(i, &(s->read_fds))) {
if (i == s->listener) {
// Handle new connection
server_accept(s);
} else {
// Handle data from a client
robot_recv(s->robots[i]);
}
}
}
}
}
int main( int argc, char *argv[] )
{
size_t i;
int ret, opt, longIndex = 0;
struct event *evsig_int;
#ifdef _WIN32
WSADATA WSAData;
#endif
pthread_t tcp_thread, *job_threads;
if ( evutil_secure_rng_init() < 0 ) {
ED2KD_LOGERR("failed to seed random number generator");
return EXIT_FAILURE;
}
/* parse command line arguments */
opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
while( opt != -1 ) {
switch( opt ) {
case 'v':
display_version();
return EXIT_SUCCESS;
case 'g': {
unsigned char hash[ED2K_HASH_SIZE];
char hex_hash[sizeof(hash)*2+1];
get_random_user_hash(hash);
bin2hex(hash, hex_hash, sizeof(hex_hash));
puts(hex_hash);
return EXIT_SUCCESS;
}
case 'h':
display_usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
}
#ifdef _WIN32
if ( 0 != WSAStartup(0x0201, &WSAData) ) {
ED2KD_LOGERR("WSAStartup failed!");
return EXIT_FAILURE;
}
#endif
if ( !server_load_config(NULL) ) {
ED2KD_LOGERR("failed to load configuration file");
return EXIT_FAILURE;
}
display_libevent_info();
#ifdef EVTHREAD_USE_WINDOWS_THREADS_IMPLEMENTED
ret = evthread_use_windows_threads();
#elif EVTHREAD_USE_PTHREADS_IMPLEMENTED
ret = evthread_use_pthreads();
#else
#error "unable to determine threading model"
#endif
if ( ret < 0 ) {
ED2KD_LOGERR("failed to init libevent threading model");
return EXIT_FAILURE;
}
g_srv.evbase_main = event_base_new();
if ( NULL == g_srv.evbase_main ) {
ED2KD_LOGERR("failed to create main event loop");
return EXIT_FAILURE;
}
g_srv.evbase_tcp = event_base_new();
if ( NULL == g_srv.evbase_tcp ) {
ED2KD_LOGERR("failed to create tcp event loop");
return EXIT_FAILURE;
}
evsig_int = evsignal_new(g_srv.evbase_main, SIGINT, sigint_cb, NULL);
evsignal_add(evsig_int, NULL);
// common timers timevals
g_srv.portcheck_timeout_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->portcheck_timeout_tv);
g_srv.status_notify_tv = event_base_init_common_timeout(g_srv.evbase_tcp, &g_srv.cfg->status_notify_tv);
if ( !db_create() ) {
ED2KD_LOGERR("failed to create database");
return EXIT_FAILURE;
}
g_srv.thread_count = omp_get_num_procs() + 1;
pthread_cond_init(&g_srv.job_cond, NULL);
pthread_mutex_init(&g_srv.job_mutex, NULL);
TAILQ_INIT(&g_srv.jqueue);
job_threads = (pthread_t *)malloc(g_srv.thread_count * sizeof(*job_threads));
// start tcp worker threads
for ( i=0; i<g_srv.thread_count; ++i ) {
pthread_create(&job_threads[i], NULL, server_job_worker, NULL);
}
// start tcp dispatch thread
pthread_create(&tcp_thread, NULL, server_base_worker, g_srv.evbase_tcp);
// start tcp listen loop
if ( !server_listen() ) {
ED2KD_LOGERR("failed to start server listener");
server_stop();
}
pthread_join(tcp_thread, NULL);
while ( EBUSY == pthread_cond_destroy(&g_srv.job_cond) ) {
pthread_cond_broadcast(&g_srv.job_cond);
//pthread_yield();
}
pthread_mutex_destroy(&g_srv.job_mutex);
for ( i=0; i<g_srv.thread_count; ++i ) {
pthread_join(job_threads[i], NULL);
}
free(job_threads);
// todo: free job queue items
evconnlistener_free(g_srv.tcp_listener);
event_free(evsig_int);
event_base_free(g_srv.evbase_tcp);
event_base_free(g_srv.evbase_main);
if ( db_destroy() < 0 ) {
ED2KD_LOGERR("failed to destroy database");
}
server_free_config();
return EXIT_SUCCESS;
}
static int server_accept(size_t paramlen)
{
uint32_t event;
int ret;
ret = server_listen(paramlen);
if (ret)
return ret;
ret = fi_domain(fabric, fi, &domain, NULL);
if (ret) {
FT_PRINTERR("fi_domain", ret);
goto err;
}
ret = ft_alloc_active_res(fi);
if (ret) {
FT_PRINTERR("alloc_active_res", ret);
goto err;
}
ret = ft_init_ep();
if (ret) {
FT_PRINTERR("init_ep", ret);
goto err;
}
/* Data will apppear on accept event on remote end. */
ft_fill_buf(cm_data, paramlen);
/* Accept the incoming connection. Also transitions endpoint to active
* state.
*/
ret = fi_accept(ep, cm_data, paramlen);
if (ret) {
FT_PRINTERR("fi_accept", ret);
goto err;
}
/* Local FI_CONNECTED event does not have data associated. */
memset(entry, 0, sizeof(*entry));
ret = fi_eq_sread(eq, &event, entry, sizeof(*entry), -1, 0);
if (ret != sizeof(*entry)) {
FT_PROCESS_EQ_ERR(ret, eq, "fi_eq_sread", "accept");
goto err;
}
if (event != FI_CONNECTED || entry->fid != &ep->fid) {
FT_ERR("Unexpected CM event %d fid %p (ep %p)", event,
entry->fid, ep);
ret = -FI_EOTHER;
goto err;
}
fi_shutdown(ep, 0);
ret = read_shutdown_event();
if (ret)
goto err;
FT_CLOSE_FID(ep);
FT_CLOSE_FID(rxcq);
FT_CLOSE_FID(txcq);
FT_CLOSE_FID(rxcntr);
FT_CLOSE_FID(txcntr);
FT_CLOSE_FID(av);
FT_CLOSE_FID(domain);
return 0;
err:
fi_reject(pep, fi->handle, NULL, 0);
return ret;
}
