static int
setup_server_sockets(int *ipv4fd, int *ipv6fd, int *unixfd, int epfd)
{
struct epoll_event ev;
ev.data.ptr = NULL;
ev.events = EPOLLIN | EPOLLET; /* epoll_wait waits for EPOLLERR and
EPOLLHUP as well */
if (!settings.disable_ipv6) {
settings.bind_addr_6.sin6_port = htons((unsigned short)settings.port);
*ipv6fd = init_server_socket((struct sockaddr *)&settings.bind_addr_6);
ev.data.fd = *ipv6fd;
if (*ipv6fd != -1)
epoll_ctl(epfd, EPOLL_CTL_ADD, *ipv6fd, &ev);
} else
*ipv6fd = -1;
if (!settings.disable_ipv4) {
settings.bind_addr_4.sin_port = htons((unsigned short)settings.port);
*ipv4fd = init_server_socket((struct sockaddr *)&settings.bind_addr_4);
ev.data.fd = *ipv4fd;
if (*ipv4fd != -1)
epoll_ctl(epfd, EPOLL_CTL_ADD, *ipv4fd, &ev);
} else
*ipv4fd = -1;
if (settings.bind_addr_unix.sun_family && remove_unix_socket()) {
int prevmask = umask(0);
*unixfd =
init_server_socket((struct sockaddr *)&settings.bind_addr_unix);
ev.data.fd = *unixfd;
if (*unixfd != -1)
epoll_ctl(epfd, EPOLL_CTL_ADD, *unixfd, &ev);
umask(prevmask);
}
if (*ipv4fd == -1 && *ipv6fd == -1) {
log_msg
("Failed to create any listening socket. Nothing to do except shut down.");
return FALSE;
}
return TRUE;
}
int main(int argc, char **argv)
{
t_socket *socket;
int port;
if (argc != 2 || (port = atoi(argv[1])) < 0)
{
fprintf(stderr, "Usage: ./server port\n");
return (-1);
}
signal(SIGINT, clean_socket);
if ((socket = init_server_socket(port)) == NULL)
return (-1);
core(socket, NULL, NULL);
return (0);
}
JNIEXPORT jlong JNICALL
Java_com_caucho_vfs_JniServerSocketImpl_nativeOpenPort(JNIEnv *env,
jobject obj,
jint sock,
jint port)
{
server_socket_t *ss;
#ifdef WIN32
{
WSADATA data;
WORD version = MAKEWORD(2,2);
WSAStartup(version, &data);
}
#endif
if (sock < 0)
return 0;
ss = (server_socket_t *) cse_malloc(sizeof(server_socket_t));
if (ss == 0)
return 0;
memset(ss, 0, sizeof(server_socket_t));
ss->fd = sock;
ss->port = port;
ss->conn_socket_timeout = 65000;
ss->accept = &std_accept;
ss->close = &std_close_ss;
#ifdef WIN32
ss->accept_lock = CreateMutex(0, 0, 0);
ss->ssl_lock = CreateMutex(0, 0, 0);
#endif
init_server_socket(env, ss);
return (PTR) ss;
}
void listen_from_asue()
{
int threadnum = 1;
init_user_table();
pthread_mutex_init(&user_table_mutex, NULL);
int server_socket = init_server_socket();
pthread_t child_thread;
pthread_attr_t child_thread_attr;
pthread_attr_init(&child_thread_attr);
pthread_attr_setdetachstate(&child_thread_attr, PTHREAD_CREATE_DETACHED);
if (pthread_attr_init(&child_thread_attr) != 0)
perror("pthread_attr_init");
pthread_attr_setdetachstate(&child_thread_attr,PTHREAD_CREATE_DETACHED);
// accept connection from each ASUE
while (1)
{
struct sockaddr_in client_addr;
socklen_t length = sizeof(client_addr);
int new_asue_socket = accept(server_socket, (struct sockaddr*) &client_addr, &length);
if (new_asue_socket < 0){
perror("AE Accept Failed\n");
//break;
}
printf("going to create thread %d ...\n", threadnum);
if (pthread_create(&child_thread, &child_thread_attr, serve_each_asue,(void *) new_asue_socket) < 0)
//if (pthread_create(&child_thread, NULL, serve_each_asue,(void *) new_asue_socket) < 0)
perror("pthread_create Failed");
//serve_each_asue((void *)new_asue_socket);
threadnum++;
}
}
int main(int ac, char **av)
{
int fd;
t_env env;
f_action *fptr_action;
if (init_args(ac, av, &env) == -1)
{
error_arg();
return (-1);
}
signal(SIGTERM, &set_flag);
signal(SIGINT, &set_flag);
if (verif_fd() == -1
|| create_socket(&fd) == -1
|| init_server_socket(fd, env.port) == -1
|| init_env(&env, fd, &fptr_action) == -1
|| server(&env, fptr_action) == -1)
return (-1);
printf("Bye Bye\n");
delete_env(&env, fptr_action);
return (0);
}
int main(int argc, char *argv[])
{
pid_t pid ;
int sock = -1;
int cliSock;
int rlen, wlen;
char *clientIP = NULL;
SOH_MSG_H msg_header;
SOH_MSG_B msg_body;
MSG_CTT_BODY ctt_body;
int offset;
int i, j;
char* packet_buff = NULL;
char* ack_nack = NULL;
if((pid = fork()) < 0)
return -1;
else if(pid != 0)
exit(0);
setsid() ;
//Log = openLog("FakeServer", "/install/log/Dongbu_Recv_Trafficinfo/FakeServer.LOG", "dtfl") ;
if ((sock = init_server_socket(12117)) < 0) {
printf("Can't create listen socket (%d)\n", 12117);
}
printf("Listen(port:%d)sock(%d)\n", 12117, sock);
while (1) {
cliSock = -1;
if ((cliSock = accept_to_client(sock, &clientIP)) < 0) {
printf("Too many clients are trying to connect.\n");
exit(0);
}
printf("Connected client %s(%d)\n", clientIP, cliSock);
for(i=0 ; i<MSG_CNT ; i++) {
packet_buff = NULL;
ack_nack = NULL;
memset (&msg_header, 0x00, sizeof(SOH_MSG_H));
msg_header.S1 = 0x7E;
msg_header.S2 = 0x7E;
msg_header.length = (sizeof(MSG_CTT_BODY)*DATA_CNT) + sizeof(SOH_MSG_B); //11232
msg_header.length = htonl(msg_header.length);
if((wlen = writen(cliSock, &msg_header, sizeof(SOH_MSG_H))) != sizeof(SOH_MSG_H)) {
printf("SOH_MSG_H: Send Error size(%d/%d)\n", wlen, sizeof(SOH_MSG_H));
exit(0);
}
memset (&msg_body, 0x00, sizeof(SOH_MSG_B));
msg_body.code = 0xB0;
msg_body.s_code = 0x02;
strcpy(msg_body.date, "20110215165503");
msg_body.msg_cnt = MSG_CNT;
msg_body.seq = 1+i;
msg_body.data_cnt = DATA_CNT;
msg_body.data_cnt = htonl(msg_body.data_cnt);
if( (packet_buff = (char *)calloc((sizeof(MSG_CTT_BODY)*DATA_CNT) + sizeof(SOH_MSG_B), sizeof(char))) == NULL ) {
printf("ERR: Memory Alloc Fail ==> Program Exit\n");
exit(0);
}
memcpy(packet_buff, &msg_body, sizeof(SOH_MSG_B));
offset = sizeof(SOH_MSG_B);
for(j=0 ; j<msg_body.data_cnt ; j++) {
ctt_body.link_id=1000000000+j;
ctt_body.link_spd=(rand() % 150);
ctt_body.travel_time = (rand() % 50);
ctt_body.delay_time = 0;
ctt_body.congesion_type = (rand() % 5);
ctt_body.link_id = htonl(ctt_body.link_id);
ctt_body.travel_time = htons(ctt_body.travel_time);
ctt_body.delay_time = htons(ctt_body.delay_time);
memcpy((packet_buff+offset), &ctt_body, sizeof(MSG_CTT_BODY));
offset = offset + sizeof(MSG_CTT_BODY);
}
if((wlen = writen(cliSock, packet_buff, msg_header.length)) != msg_header.length) {
printf("packet_buff Send Error size(%d/%d)\n", wlen, msg_header.length);
exit(0);
}
if( (ack_nack = (char *)calloc(28, sizeof(char))) == NULL ) {
printf("ERR: Memory Alloc Fail ==> Program Exit\n");
exit(0);
}
if((rlen = readn(cliSock, &ack_nack, sizeof(SOH_MSG_H)+sizeof(SOH_MSG_B))) != sizeof(SOH_MSG_H)+sizeof(SOH_MSG_B)) {
printf("ERR: read ACK/NACK [rlen:%d/%d]\n", rlen, sizeof(SOH_MSG_H)+sizeof(SOH_MSG_B)) ;
}
free(packet_buff);
free(ack_nack);
}
sleep(300);
}
}
int
main(int argc, char ** argv)
{
command_t cmd; int i;
char * in, * args, buffer[MAX_COMMAND_LENGTH];
struct sigaction thread_signal_action, old_signal_action;
struct thread_data_t * thread_datum;
/* Sanitize input */
if (argc != 2) {
fprintf(stderr, "USAGE: %s port\n", argv[0]);
return EXIT_FAILURE;
}
/* Crypto initialization */
if (init_crypto(new_shmid(&i))) {
fprintf(stderr, "FATAL: unable to enter secure mode\n");
return EXIT_FAILURE;
}
/* Database initialization */
if (init_db(BANKING_DB_FILE, &session_data.db_conn)) {
fprintf(stderr, "FATAL: unable to connect to database\n");
shutdown_crypto(old_shmid(&i));
return EXIT_FAILURE;
}
/* Socket initialization */
if ((session_data.sock = init_server_socket(argv[1])) < 0) {
fprintf(stderr, "FATAL: unable to start server\n");
destroy_db(BANKING_DB_FILE, session_data.db_conn);
shutdown_crypto(old_shmid(&i));
return EXIT_FAILURE;
}
/* Thread initialization */
gcry_pthread_mutex_init((void **)(&session_data.accept_mutex));
gcry_pthread_mutex_init((void **)(&session_data.keystore_mutex));
/* Save the old list of blocked signals for later */
pthread_sigmask(SIG_SETMASK, NULL, &old_signal_action.sa_mask);
/* Worker threads inherit this mask (ignore everything except SIGUSRs) */
memset(&thread_signal_action, '\0', sizeof(struct sigaction));
sigfillset(&thread_signal_action.sa_mask);
sigdelset(&thread_signal_action.sa_mask, SIGUSR1);
sigdelset(&thread_signal_action.sa_mask, SIGUSR2);
thread_signal_action.sa_handler = &handle_interruption;
pthread_sigmask(SIG_SETMASK, &thread_signal_action.sa_mask, NULL);
/* Afterwhich, all signals should be ignored in the handler */
sigfillset(&thread_signal_action.sa_mask);
/* Kick off the workers */
for (i = 0; i < MAX_CONNECTIONS; ++i) {
/* Thread data initialization */
thread_datum = &session_data.thread_data[i];
memset(thread_datum, '\0', sizeof(struct thread_data_t));
thread_datum->sock = BANKING_FAILURE;
thread_datum->remote_addr_len = sizeof(thread_datum->remote_addr);
thread_datum->signal_action = &thread_signal_action;
if (pthread_create(&thread_datum->id, NULL, &handle_client,
thread_datum)) {
thread_datum->id = (pthread_t)(BANKING_FAILURE);
fprintf(stderr, "WARNING: unable to start worker thread\n");
}
}
/* Reset the signal mask to the prior behavior, and ignore SIGUSRs */
sigaddset(&old_signal_action.sa_mask, SIGUSR1);
sigaddset(&old_signal_action.sa_mask, SIGUSR2);
pthread_sigmask(SIG_SETMASK, &old_signal_action.sa_mask, NULL);
/* Session Signal initialization */
memset(&session_data.signal_action, '\0', sizeof(struct sigaction));
/* The signal handler should ignore SIGTERM and SIGINT */
sigemptyset(&session_data.signal_action.sa_mask);
sigaddset(&session_data.signal_action.sa_mask, SIGTERM);
sigaddset(&session_data.signal_action.sa_mask, SIGINT);
session_data.signal_action.sa_handler = &handle_signal;
/* Make sure any ignored signals remain ignored */
sigaction(SIGTERM, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGTERM, &session_data.signal_action, NULL);
}
sigaction(SIGINT, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGINT, &session_data.signal_action, NULL);
}
session_data.caught_signal = 0;
/* TODO tab-completion for commands */
rl_bind_key('\t', rl_insert);
/* Issue an interactive prompt, only quit on signal */
while (!session_data.caught_signal && (in = readline(SHELL_PROMPT))) {
/* Ignore empty strings */
if (*in != '\0') {
/* Add the original command to the shell history */
memset(buffer, '\0', MAX_COMMAND_LENGTH);
strncpy(buffer, in, MAX_COMMAND_LENGTH);
buffer[MAX_COMMAND_LENGTH - 1] = '\0';
for (i = 0; buffer[i] == ' '; ++i);
add_history(buffer + i);
/* Catch invalid commands prior to invocation */
if (validate_command(in, &cmd, &args)) {
fprintf(stderr, "ERROR: invalid command '%s'\n", in);
rl_ding();
} else {
/* Hook the command's return value to this signal */
session_data.caught_signal = ((cmd == NULL) || cmd(args));
}
}
free(in);
in = NULL;
}
/* Teardown */
handle_signal(0);
return EXIT_SUCCESS;
}
int
main(int argc, char ** argv)
{
ssize_t received, sent, bytes;
struct sigaction old_signal_action;
/* Input sanitation */
if (argc != 3) {
fprintf(stderr, "USAGE: %s listen_port bank_port\n", argv[0]);
return EXIT_FAILURE;
}
/* Capture SIGINT and SIGTERM */
memset(&session_data.signal_action, '\0', sizeof(struct sigaction));
sigfillset(&session_data.signal_action.sa_mask);
session_data.signal_action.sa_handler = &handle_signal;
sigemptyset(&session_data.termination_signals);
sigaction(SIGINT, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGINT, &session_data.signal_action, NULL);
sigaddset(&session_data.termination_signals, SIGINT);
}
sigaction(SIGTERM, NULL, &old_signal_action);
if (old_signal_action.sa_handler != SIG_IGN) {
sigaction(SIGTERM, &session_data.signal_action, NULL);
sigaddset(&session_data.termination_signals, SIGTERM);
}
/* Socket initialization */
if ((session_data.csock = init_client_socket(argv[2])) < 0) {
fprintf(stderr, "ERROR: unable to connect to server\n");
return EXIT_FAILURE;
}
if ((session_data.ssock = init_server_socket(argv[1])) < 0) {
fprintf(stderr, "ERROR: unable to start server\n");
destroy_socket(session_data.csock);
return EXIT_FAILURE;
}
/* Provide a dumb echo tunnel service TODO send/recv threads */
while (!handle_connection(session_data.ssock, &session_data.conn)) {
session_data.mode = A2B;
session_data.count = 0;
while (!handle_relay(&received, &sent)) {
/* Report leaky transmissions */
if (sent != received) {
bytes = sent - received;
if (bytes < 0) {
bytes = -bytes;
}
fprintf(stderr, "ERROR: %li byte(s) lost\n", (long)(bytes));
}
/* NOTE: modality is swapped after relay */
if (session_data.mode == A2B) {
fprintf(stderr,
"INFO: server sent message [id: %08i]\n",
session_data.count);
}
if (session_data.mode == B2A) {
fprintf(stderr,
"INFO: client sent message [id: %08i]\n",
session_data.count);
}
#ifndef NDEBUG
/* Report entire transmission */
hexdump(stderr, session_data.buffer, MAX_COMMAND_LENGTH);
#endif
}
time(&session_data.terminated);
fprintf(stderr, "INFO: tunnel closed [%i msg / %li sec]\n",
session_data.count,
(long)(session_data.terminated - session_data.established));
/* Disconnect from defunct clients */
destroy_socket(session_data.conn);
/* Re-establish with the server TODO should this be necessary? */
destroy_socket(session_data.csock);
session_data.csock = init_client_socket(argv[2]);
}
/* Teardown */
handle_signal(0);
return EXIT_SUCCESS;
}
JNIEXPORT jlong JNICALL
Java_com_caucho_vfs_JniServerSocketImpl_bindPort(JNIEnv *env,
jobject obj,
jstring jaddr,
jint port)
{
int val = 0;
char addr_name[256];
const char *temp_string = 0;
int sock;
int family = 0;
int protocol = 0;
server_socket_t *ss;
char sin_data[256];
struct sockaddr_in *sin = (struct sockaddr_in *) sin_data;
int sin_length = sizeof(sin_data);
#ifdef WIN32
{
WSADATA data;
WORD version = MAKEWORD(2,2);
WSAStartup(version, &data);
}
#endif
addr_name[0] = 0;
memset(sin_data, 0, sizeof(sin_data));
if (jaddr != 0) {
temp_string = (*env)->GetStringUTFChars(env, jaddr, 0);
if (temp_string) {
strncpy(addr_name, temp_string, sizeof(addr_name));
addr_name[sizeof(addr_name) - 1] = 0;
(*env)->ReleaseStringUTFChars(env, jaddr, temp_string);
}
else {
resin_throw_exception(env, "java/lang/NullPointerException", "missing addr");
return 0;
}
sin = lookup_addr(env, addr_name, port, sin_data,
&family, &protocol, &sin_length);
}
else {
sin = (struct sockaddr_in *) sin_data;
sin->sin_family = AF_INET;
sin->sin_port = htons(port);
family = AF_INET;
protocol = IPPROTO_TCP;
sin_length = sizeof(struct sockaddr_in);
}
if (! sin)
return 0;
sock = socket(family, SOCK_STREAM, 0);
if (sock < 0) {
return 0;
}
val = 1;
if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(char *) &val, sizeof(int)) < 0) {
closesocket(sock);
return 0;
}
if (bind(sock, (struct sockaddr *) sin, sin_length) < 0) {
int i = 5;
int result = 0;
/* somewhat of a hack to clear the old connection. */
while (result == 0 && i-- >= 0) {
int fd = socket(AF_INET, SOCK_STREAM, 0);
result = connect(fd, (struct sockaddr *) &sin, sizeof(sin));
closesocket(fd);
}
result = -1;
for (i = 50; result < 0 && i >= 0; i--) {
result = bind(sock, (struct sockaddr *) sin, sin_length);
if (result < 0) {
struct timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 100000;
select(0, 0, 0, 0, &tv);
}
}
if (result < 0) {
closesocket(sock);
return 0;
}
}
sin_length = sizeof(sin_data);
getsockname(sock, (struct sockaddr *) sin, &sin_length);
/* must be 0 if the poll is missing for accept */
#if 0 && defined(O_NONBLOCK)
/*
* sets nonblock to ensure the timeout work in the case of multiple threads.
*/
{
int flags;
int result;
flags = fcntl(sock, F_GETFL);
result = fcntl(sock, F_SETFL, O_NONBLOCK|flags);
}
#endif
ss = (server_socket_t *) cse_malloc(sizeof(server_socket_t));
memset(ss, 0, sizeof(server_socket_t));
ss->fd = sock;
ss->port = ntohs(sin->sin_port);
ss->conn_socket_timeout = 65000;
ss->accept = &std_accept;
ss->close = &std_close_ss;
#ifdef WIN32
ss->accept_lock = CreateMutex(0, 0, 0);
ss->ssl_lock = CreateMutex(0, 0, 0);
#endif
init_server_socket(env, ss);
return (PTR) ss;
}
void main(int argc, char *argv[])
{
int sock=-1;
int cliSock;
char *clientIP = NULL;
int ret, stat;
pthread_t pingpong_thread, worker_thread;
Log = NULL;
if ((Log = openLog(argv[0], LOG_FILE, LOG_MODE)) == NULL) {
fprintf(stderr, "Can't open log file(%s)\n", LOG_FILE);
exit_handler();
}
#ifdef _MINJA_LINK
Log_Minja = NULL;
if ((Log_Minja = openLog(argv[0], LOG_FILE_MINJA, LOG_MODE)) == NULL) {
fprintf(stderr, "Can't open log file(%s)\n", LOG_FILE_MINJA);
exit_handler();
}
#endif
#ifdef _DETOUR_KD_LINK
Log_DetourKD = NULL;
if ((Log_DetourKD = openLog(argv[0], LOG_FILE_DETOUR, LOG_MODE)) == NULL) {
fprintf(stderr, "Can't open log file(%s)\n", LOG_FILE_DETOUR);
exit_handler();
}
#endif
#ifdef _STD_LINK
Log_Std = NULL;
if ((Log_Std = openLog(argv[0], LOG_FILE_STD, LOG_MODE)) == NULL) {
fprintf(stderr, "Can't open log file(%s)\n", LOG_FILE_STD);
exit_handler();
}
#endif
#ifdef _NEWS_INFO
Log_News = NULL;
if ((Log_News = openLog(argv[0], LOG_FILE_NEWS, LOG_MODE)) == NULL) {
fprintf(stderr, "Can't open log file(%s)\n", LOG_FILE_NEWS);
exit_handler();
}
#endif
printLog(Log, STAMP, "-------------------------------\n");
printLog(Log, STAMP, "RecvEXTrafficInfo is started on %s\n", getenv("HOST"));
printLog(Log, STAMP, "-------------------------------\n");
do_daemon();
set_signal();
read_config(); // 환경설정값을 읽어들인다..
#ifdef _USEDB
if((ret = mydbc_connect(Config.DB_NAME, Config.DB_USER, Config.DB_PASSWORD, Config.DB_HOST, Config.DB_PORT, Config.DB_CONN_COUNT)) != DB_SUCCESS) {
printLog(Log, STAMP, "DB Connection ERROR[%d]\n", ret);
exit_handler();
}else {
printLog(Log, STAMP, "DB Connection Success...\n");
}
// DB PING-PONG
if(pthread_create(&pingpong_thread, NULL, db_conn_check, (void *)NULL) != 0) {
printLog(Log, STAMP, "Can't create worker thread(errno:%d)\n", errno);
exit_handler();
}
#endif
// Mutex 초기화
pthread_mutex_init(&p_lock, NULL);
thread_count = 0;
// 도공에서 1분마다 수신되는 고속도로 속도를 DB에 반영할지 판단하는 전역변수
pthread_mutex_init(&std_fw_lock, NULL);
g_std_fw_update_flag = TRUE;
// 민자구간, 우회국도, 표준링크구간 메모리 로딩...
if((ret = mem_load_db_minja_link_list()) != 0) {
printLog(Log, STAMP, "mem_load_db_get_minja_link_list(ret:%d)\n", ret);
exit_handler();
}
if((ret = mem_load_db_detour_kd_link_list()) != 0) {
printLog(Log, STAMP, "mem_load_db_get_detour_kd_link_list(ret:%d)\n", ret);
exit_handler();
}
if((ret = mem_load_db_std_link_list()) != 0) {
printLog(Log, STAMP, "mem_load_db_get_std_link_list(ret:%d)\n", ret);
exit_handler();
}
/*
if((ret = mem_load_db_std_kd_link_list()) != 0) {
printLog(Log, STAMP, "mem_load_db_get_std_kd_link_list(ret:%d)\n", ret);
exit_handler();
}
*/
// 로딩 finish...
// CLIENT로부터의 요청을 받기위한 소켓을 생성한다..
if ((sock = init_server_socket(Config.LISTEN_PORT)) < 0) {
printLog(Log, STAMP, "Can't create listen socket (%d)\n", Config.LISTEN_PORT);
exit_handler();
}
printLog(Log, STAMP, "Listen(port:%d)sock(%d)\n", Config.LISTEN_PORT, sock);
while (1) {
cliSock = -1;
if ((cliSock = accept_to_client(sock, &clientIP)) < 0) {
printLog(Log, STAMP, "Too many clients are trying to connect.\n");
continue;
}
printLog(Log, STAMP, "Connected client %s(%d)\n", clientIP, cliSock);
// For Debugging
pthread_mutex_lock(&p_lock);
if(pthread_create(&worker_thread, NULL, worker_handler, (void *)cliSock) != 0) {
printLog(Log, STAMP, "Can't create worker thread(errno:%d)\n", errno);
exit_handler();
}
printLog(Log, STAMP, "Create worker Thread...(sock:%d)\n", cliSock);
thread_count++;
pthread_mutex_unlock(&p_lock);
}
}
int main() {
running = 1;
signal(SIGINT, interrupt_handler);
printf("Starting server\n");
if(!init_server_socket(&sock, PORT))
return -1;
//A linked list might not be the most efficient for this
llist client_sessions;
llist_init(&client_sessions);
queue message_queue;
queue_init(&message_queue);
//TODO: initialise thread pool
const int num_workers = 4;
pthread_t workers[num_workers];
for(int i=0; i<num_workers; i++) {
pthread_create(&workers[i], NULL, worker_run, (void*)&message_queue);
}
//select stuff
fd_set readsocketset;
fd_set writesocketset;
fd_set errorsocketset;
struct timeval timeout;
while(running) {
timeout.tv_sec = 1;
timeout.tv_usec = 0;
printf("1\n");
build_socket_list(&client_sessions, &readsocketset);
FD_ZERO(&readsocketset);
FD_SET(sock, &readsocketset);
int s = select(client_sessions.len, &readsocketset, 0, 0, &timeout);
printf("2\n");
if(s < 0) {
printf("ERROR: Select error\n");
exit(1);
}
//if we have a new connection create a new session
if(FD_ISSET(sock, &readsocketset)) {
int csock = check_for_connections(sock);
session clientSession;
session_init(&clientSession, csock);
llist_append(&client_sessions, (void*)&clientSession);
}
printf("2\n");
//check if each session exists in the read socket thingE
llist_node *cur = client_sessions.head;
while(cur != NULL) {
int sock = ((session*)cur->data)->sock;
//check readsocketset
if(FD_ISSET(sock, &readsocketset))
client_read_data((session*)cur->data);
//check writesocketset
//check errorset
cur = cur->next;
}
//TODO:
//parse the messages
//add parsed message to the queue
//send messages on the queue (Should this be done here?)
}
printf("Exiting..\n");
//free memory
llist_node *cur = client_sessions.head;
while(cur != NULL) {
session *sess = (session*)cur->data;
session_end(sess);
free(sess);
cur = cur->next;
}
llist_free(&client_sessions);
close(sock);
pthread_exit(NULL);
}
