void recv_data(int fd, void *arg)
{
// char req_buf[RECV_BUFFER_SIZE];
char *req_buf = (char *)malloc(sizeof(char) *RECV_BUFFER_SIZE);
int char_num;
char_num = recv(fd, req_buf, RECV_BUFFER_SIZE, 0);
if(char_num < 0)
{
#ifdef DEBUG
fprintf(stderr, "[%d] : recv data error\n",fd);
#endif
return;
}
else if(char_num == 0)
{
#ifdef DEBUG
printf("socket [ %d ] : closed\n",fd);
#endif
if(event_del(efd, (my_event_t *)arg) == 0)close(fd);
return;
}
#ifdef DEBUG
printf("#############################\n");
printf("recved :\n%s\n", req_buf);
printf("#############################\n");
#endif
pool_add_task(procpool, deal_req, fd, req_buf);
return;
}
int deal(void *ptr)
{
my_event_t *ev = (my_event_t *)ptr;
pool_add_task(rdpool, ev -> callback, ev -> fd, ev -> argv);
return 0;
}
void parse_request_task(void* arg)
{
parse_request_arg* parse_task = (parse_request_arg*) arg;
if (parse_task != NULL &&
parse_task->pool != NULL &&
parse_task->req != NULL) {
if (parse_request(parse_task->connfd, parse_task->req)) {
process_request_arg* process_task =
(process_request_arg*) malloc(sizeof(process_request_arg));
process_task->pool = parse_task->pool;
process_task->connfd = parse_task->connfd;
process_task->req = parse_task->req;
clock_gettime(CLOCK_MONOTONIC_RAW, &process_task->start_time);
// Add the process request task to the queue.
pool_add_task(parse_task->pool, process_request_task, (void*)process_task);
} else {
if (parse_task != NULL) {
free(parse_task->req);
}
}
} else {
if (parse_task != NULL) {
free(parse_task->req);
}
}
free(parse_task);
}
int pool_destroy(pool_t *pool)
{
int err = 0;
int i;
while(pool_add_task(pool, NULL, 0));
for (i = 0; i < pool->thread_count; i++) {
if (pool->threads[i] != pthread_self())
pthread_join(pool->threads[i], NULL);
}
free((void*)pool->queue);
free((void*)pool->threads);
free((void*)pool);
return err;
}
int main(int argc,char *argv[])
{
int flag, num_seats = 20;
struct sockaddr_in serv_addr;
char send_buffer[BUFSIZE];
listenfd = 0;
int server_port = 8080;
if (argc > 1)
{
num_seats = atoi(argv[1]);
}
if (server_port < 1500)
{
fprintf(stderr,"INVALID PORT NUMBER: %d; can't be < 1500\n",server_port);
exit(-1);
}
if (signal(SIGINT, shutdown_server) == SIG_ERR)
printf("Issue registering SIGINT handler");
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if ( listenfd < 0 ){
perror("Socket");
exit(errno);
}
printf("Established Socket: %d\n", listenfd);
flag = 1;
setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag) );
// initialize the threadpool
// Set the number of threads and size of the queue
threadpool = pool_create(200,20);
// Load the seats;
load_seats(num_seats); //TODO read from argv
// set server address
memset(&serv_addr, '0', sizeof(serv_addr));
memset(send_buffer, '0', sizeof(send_buffer));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(server_port);
// bind to socket
if ( bind(listenfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) != 0)
{
perror("socket--bind");
exit(errno);
}
// listen for incoming requests
listen(listenfd, 10);
// handle connections loop (forever)
while(1)
{
int* connfd = (int*) malloc(sizeof(int));
*connfd = accept(listenfd, (struct sockaddr*)NULL, NULL);
pool_add_task(threadpool, &handle_connection, (void*) connfd);
}
}
int main(int argc,char *argv[])
{
int flag, num_seats = 20;
long connfd = 0; //int connfd = 0;
struct sockaddr_in serv_addr;
char send_buffer[BUFSIZE];
listenfd = 0;
int server_port = 8080;
if (argc > 1)
{
num_seats = atoi(argv[1]);
}
if (server_port < 1500)
{
fprintf(stderr,"INVALID PORT NUMBER: %d; can't be < 1500\n",server_port);
exit(-1);
}
if (signal(SIGINT, shutdown_server) == SIG_ERR)
printf("Issue registering SIGINT handler");
listenfd = socket(AF_INET, SOCK_STREAM, 0);
if ( listenfd < 0 ){
perror("Socket");
exit(errno);
}
printf("Established Socket: %d\n", listenfd);
flag = 1;
setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag) );
// Load the seats;
load_seats(num_seats);
// set server address
memset(&serv_addr, '0', sizeof(serv_addr));
memset(send_buffer, '0', sizeof(send_buffer));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(server_port);
// bind to socket
if ( bind(listenfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) != 0)
{
perror("socket--bind");
exit(errno);
}
listen(listenfd, 10);
// TODO: Initialize your threadpool!
threadpool = pool_create(10,50);
// This while loop "forever", handling incoming connections
while(1)
{
connfd = accept(listenfd, (struct sockaddr*)NULL, NULL);
// pthread_t thread;
// pthread_create(&thread, NULL, (void*)handle_request, (void*)connfd);
pool_add_task(threadpool, (void*)handle_request, (void*)connfd);
}
}
int main(int argc,char *argv[])
{
int flag, num_seats = 20;
int connfd = 0;
struct sockaddr_in serv_addr;
char send_buffer[BUFSIZE];
listenfd = 0;
int server_port = 8080;
if (argc > 1)
{
num_seats = atoi(argv[1]); //convert char to int
}
if (server_port < 1500)
{
fprintf(stderr,"INVALID PORT NUMBER: %d; can't be < 1500\n",server_port);
exit(-1);
}
if (signal(SIGINT, shutdown_server) == SIG_ERR) //set a function to handle a signal
printf("Issue registering SIGINT handler");
listenfd = socket(AF_INET, SOCK_STREAM, 0); //establish a socket using default TCP protocol (0),return socket file descriptor
if ( listenfd < 0 ){
perror("Socket");
exit(errno);
}
printf("Established Socket: %d\n", listenfd);
flag = 1;
setsockopt( listenfd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag) ); //set options on sockets
//SO_REUSEADDR enables local address reuse
// Load the seats;
load_seats(num_seats);
// set server address
memset(&serv_addr, '0', sizeof(serv_addr));
memset(send_buffer, '0', sizeof(send_buffer));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); //host to network long
serv_addr.sin_port = htons(server_port);
// bind to socket
if ( bind(listenfd, (struct sockaddr*) &serv_addr, sizeof(serv_addr)) != 0)
{
perror("socket--bind");
exit(errno);
}
// listen for incoming requests
listen(listenfd, 10); //10, The backlog parameter defines the maximum length for the queue of pending connections
// TODO: Initialize your threadpool!
threadpool = pool_create(40, 100); //pool_t *pool_create(int thread_count, int queue_size); 50/100
// This while loop "forever", handling incoming connections
while(1)
{
connfd = accept(listenfd, (struct sockaddr*)NULL, NULL);
/*********************************************************************
You should not need to modify any of the code above this comment.
However, you will need to add lines to declare and initialize your
threadpool!
The lines below will need to be modified! Some may need to be moved
to other locations when you make your server multithreaded.
*********************************************************************/
parse_argument *argument = (parse_argument *)malloc(sizeof(parse_argument));
argument->connfd = connfd;
argument->request = (struct request *)malloc(sizeof(struct request));
pool_add_task(threadpool, parseRequest, (void *)argument);
}
}
