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); }