#include <stdio.h>
|
#include <stdlib.h>
|
#include <unistd.h>
|
#include <string.h>
|
#include <errno.h>
|
#include <ctype.h>
|
#include <time.h>
|
#include <pthread.h>
|
#include <getopt.h>
|
#include <libgen.h>
|
#include <sys/types.h>
|
#include <sys/socket.h>
|
#include <arpa/inet.h>
|
#include <netinet/in.h>
|
|
|
typedef struct link_node_s
|
{
|
int fd;
|
struct link_node_s *next;
|
} link_node_t;
|
|
|
static inline void msleep(unsigned long ms);
|
static inline void print_usage(char *progname);
|
int socket_server_init(char *listen_ip, int listen_port);
|
int add_fd_list(link_node_t **head, int fd);
|
link_node_t *list_remove_node(link_node_t **head, link_node_t *node);
|
|
|
int main(int argc, char **argv)
|
{
|
int listenfd, connfd;
|
int serv_port = 0;
|
int daemon_run = 0;
|
char *progname = NULL;
|
pthread_t tid;
|
int opt;
|
fd_set rdset;
|
link_node_t *client_list = NULL; /* client fd link list, we will not use arrary for it get max client limite */
|
link_node_t *node;
|
int rv;
|
int i;
|
int maxfd=0;
|
char buf[1024];
|
|
struct option long_options[] =
|
{
|
{"daemon", no_argument, NULL, 'b'},
|
{"port", required_argument, NULL, 'p'},
|
{"help", no_argument, NULL, 'h'},
|
{NULL, 0, NULL, 0}
|
};
|
|
progname = basename(argv[0]);
|
|
/* Parser the command line parameters */
|
while ((opt = getopt_long(argc, argv, "bp:h", long_options, NULL)) != -1)
|
{
|
switch (opt)
|
{
|
case 'b':
|
daemon_run=1;
|
break;
|
|
case 'p':
|
serv_port = atoi(optarg);
|
break;
|
|
case 'h': /* Get help information */
|
print_usage(progname);
|
return EXIT_SUCCESS;
|
|
default:
|
break;
|
}
|
}
|
|
if( !serv_port )
|
{
|
print_usage(progname);
|
return -1;
|
}
|
|
if( (listenfd=socket_server_init(NULL, serv_port)) < 0 )
|
{
|
printf("ERROR: %s server listen on port %d failure\n", argv[0],serv_port);
|
return -2;
|
}
|
printf("%s server start to listen on port %d\n", argv[0],serv_port);
|
|
|
/* set program running on background */
|
if( daemon_run )
|
{
|
daemon(0, 0);
|
}
|
|
printf("add listen socket[%d] into client list\n", listenfd );
|
add_fd_list(&client_list, listenfd);
|
|
for ( ; ; )
|
{
|
FD_ZERO(&rdset);
|
for( node=client_list; node!=NULL; node=node->next )
|
{
|
//printf("Add socket[%d] in select readset\n", node->fd);
|
maxfd = node->fd>maxfd ? node->fd : maxfd;
|
FD_SET(node->fd, &rdset);
|
}
|
|
/* program will blocked here */
|
rv = select(maxfd+1, &rdset, NULL, NULL, NULL);
|
if(rv < 0)
|
{
|
printf("select failure: %s\n", strerror(errno));
|
break;
|
}
|
else if(rv == 0)
|
{
|
printf("select get timeout\n");
|
continue;
|
}
|
|
/* listen socket get event means new client start connect now */
|
if ( FD_ISSET(listenfd, &rdset) )
|
{
|
if( (connfd=accept(listenfd, (struct sockaddr *)NULL, NULL)) < 0)
|
{
|
printf("accept new client failure: %s\n", strerror(errno));
|
continue;
|
}
|
|
printf("accept new client[%d] and add it into client list\n", connfd );
|
add_fd_list(&client_list, connfd);
|
}
|
else /* data arrive from already connected client */
|
{
|
node = client_list;
|
while( node != NULL )
|
{
|
if( !FD_ISSET(node->fd, &rdset) )
|
{
|
node = node->next;
|
continue;
|
}
|
|
if( (rv=read(node->fd, buf, sizeof(buf))) <= 0)
|
{
|
printf("socket[%d] read failure or get disconncet.\n", node->fd);
|
/* list_remove_node will return the previous node */
|
node = list_remove_node(&client_list, node);
|
}
|
else
|
{
|
printf("socket[%d] read get %d bytes data\n", node->fd, rv);
|
|
/* convert letter from lowercase to uppercase */
|
for(i=0; i<rv; i++)
|
buf[i]=toupper(buf[i]);
|
|
if( write(node->fd, buf, rv) < 0 )
|
{
|
printf("socket[%d] write failure: %s\n", node->fd, strerror(errno));
|
/* list_remove_node will return the previous node */
|
node = list_remove_node(&client_list, node);
|
}
|
}
|
|
if( node != NULL )
|
{
|
node = node->next;
|
}
|
} /* while( node != NULL ) */
|
}
|
}
|
|
CleanUp:
|
close(listenfd); /* We must close socket File Description when program exit*/
|
return 0;
|
}
|
|
|
static inline void msleep(unsigned long ms)
|
{
|
struct timeval tv;
|
|
tv.tv_sec = ms/1000;
|
tv.tv_usec = (ms%1000)*1000;
|
|
select(0, NULL, NULL, NULL, &tv);
|
}
|
|
|
static inline void print_usage(char *progname)
|
{
|
printf("Usage: %s [OPTION]...\n", progname);
|
|
printf(" %s is a socket server program, which used to verify client and echo back string from it\n", progname);
|
printf("\nMandatory arguments to long options are mandatory for short options too:\n");
|
|
printf(" -b[daemon ] set program running on background\n");
|
printf(" -p[port ] Socket server port address\n");
|
printf(" -h[help ] Display this help information\n");
|
|
|
printf("\nExample: %s -b -p 8900\n", progname);
|
return ;
|
}
|
|
|
int socket_server_init(char *listen_ip, int listen_port)
|
{
|
struct sockaddr_in servaddr;
|
int rv = 0;
|
int on = 1;
|
int listenfd;
|
|
if ( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
|
{
|
printf("Use socket() to create a TCP socket failure: %s\n", strerror(errno));
|
return -1;
|
}
|
|
/* Set socket port reuseable, fix 'Address already in use' bug when socket server restart */
|
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
|
|
memset(&servaddr, 0, sizeof(servaddr));
|
servaddr.sin_family = AF_INET;
|
servaddr.sin_port = htons(listen_port);
|
|
if( !listen_ip ) /* Listen all the local IP address */
|
{
|
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
|
}
|
else /* listen the specified IP address */
|
{
|
if (inet_pton(AF_INET, listen_ip, &servaddr.sin_addr) <= 0)
|
{
|
printf("inet_pton() set listen IP address failure.\n");
|
rv = -2;
|
goto CleanUp;
|
}
|
}
|
|
|
if(bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr)) < 0)
|
{
|
printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
|
rv = -3;
|
goto CleanUp;
|
}
|
|
if(listen(listenfd, 13) < 0)
|
{
|
printf("Use bind() to bind the TCP socket failure: %s\n", strerror(errno));
|
rv = -4;
|
goto CleanUp;
|
}
|
|
CleanUp:
|
if(rv<0)
|
close(listenfd);
|
else
|
rv = listenfd;
|
|
return rv;
|
}
|
|
int add_fd_list(link_node_t **head, int fd)
|
{
|
link_node_t *node;
|
link_node_t *tmp;
|
|
if( NULL == (node=(link_node_t *)malloc(sizeof(*node))) )
|
{
|
printf("malloc for new node failure\n");
|
return -1;
|
}
|
|
memset(node, 0, sizeof(*node));
|
node->fd = fd;
|
node->next = NULL;
|
|
if( *head == NULL )
|
{
|
*head = node;
|
return 0;
|
}
|
|
tmp = *head;
|
while( tmp->next != NULL )
|
{
|
tmp=tmp->next;
|
}
|
|
tmp->next = node;
|
}
|
|
/* list_remove_node will return the previous node */
|
link_node_t *list_remove_node(link_node_t **head, link_node_t *node)
|
{
|
link_node_t *prev;
|
|
close(node->fd);
|
|
if( node == *head )
|
{
|
*head = NULL;
|
free(node);
|
return NULL;
|
}
|
else
|
{
|
for(prev=*head; prev!=NULL; prev=prev->next)
|
{
|
if(prev->next == node)
|
{
|
prev->next = node->next;
|
free(node);
|
return prev;
|
}
|
}
|
}
|
}
|
|
