/*********************************************************************************
|
* Copyright: (C) 2020 LingYun IoT System Studio
|
* All rights reserved.
|
*
|
* Filename: socket_server.c
|
* Description: This is a socket server program to receive RPi's temperature
|
*
|
* Version: 1.0.0(2020年04月14日)
|
* Author: Guo Wenxue <guowenxue@gmail.com>
|
* ChangeLog: 1, Release initial version on "2020年04月14日 00时52分56秒"
|
*
|
********************************************************************************/
|
#include <stdio.h>
|
#include <unistd.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <getopt.h>
|
#include <libgen.h>
|
#include <errno.h>
|
|
#include "logger.h"
|
#include "proc.h"
|
#include "list.h"
|
#include "socket.h"
|
#include "packet.h"
|
|
#define PROG_VERSION "1.0.0"
|
#define DAEMON_PIDFILE "/tmp/.sockets.pid"
|
#define MAX_EVENTS 512
|
|
/* Every client need get a stand alone buffer to save TLV packet data */
|
typedef struct cli_buf_s
|
{
|
int fd; /* client fd */
|
char buf[512]; /* client receive buffer */
|
int bytes; /* left bytes in buffer */
|
struct list_head list; /* all client buffer saved in a list */
|
} cli_buf_t;
|
|
static int parser_tlv_data(cli_buf_t *cli_buf);
|
static void term_socket_client(int epollfd, int fd, struct list_head *buf_list);
|
|
static void print_usage(char *progname)
|
{
|
printf("Usage: %s [OPTION]...\n", progname);
|
printf(" %s is LingYun studio temperature socket server program running on RaspberryPi\n", progname);
|
|
printf("\nMandatory arguments to long options are mandatory for short options too:\n");
|
printf("-p(--port) : sepcify server port.\n");
|
printf("-d(--debug) : running in debug mode\n");
|
printf("-v(--version) : display the program version\n");
|
printf("-h(--help) : display this help information\n");
|
|
printf("\n%s version %s build on %s %s\n", progname, PROG_VERSION, __DATE__, __TIME__);
|
return;
|
}
|
|
int main (int argc, char *argv[])
|
{
|
char *progname=NULL;
|
int daemon = 1;
|
int opt;
|
int i = 0;
|
int rv = 0;
|
|
char *logfile="sock_server.log";
|
int loglevel=LOG_LEVEL_INFO;
|
int logsize=10; /* logfile size max to 10K */
|
|
socket_t sock;
|
int port = 10086;
|
int epollfd;
|
int connfd;
|
int fd;
|
int nfds;
|
struct epoll_event event_array[MAX_EVENTS];
|
|
cli_buf_t *cli_buf;
|
cli_buf_t *node;
|
struct list_head buf_list; /* every client get a stand alone buffer saved in the list */
|
|
struct option long_options[] = {
|
{"port", required_argument, NULL, 'p'},
|
{"debug", no_argument, NULL, 'd'},
|
{"version", no_argument, NULL, 'v'},
|
{"help", no_argument, NULL, 'h'},
|
{NULL, 0, NULL, 0}
|
};
|
|
memset(&sock, 0, sizeof(sock));
|
INIT_LIST_HEAD(&buf_list);
|
|
progname = basename(argv[0]); /* get program name */
|
|
/* parser the command line parameters */
|
while ((opt = getopt_long(argc, argv, "p:dvh", long_options, NULL)) != -1)
|
{
|
switch (opt)
|
{
|
case 'p': /* listen port */
|
port = atoi(optarg);
|
break;
|
|
case 'd': /* set debug running */
|
daemon = 0;
|
logfile="console";
|
loglevel=LOG_LEVEL_DEBUG;
|
break;
|
|
case 'v': /* print software version */
|
printf("%s version %s\n", progname, PROG_VERSION);
|
return 0;
|
|
case 'h': /* print help information */
|
print_usage(progname);
|
return 0;
|
|
default:
|
break;
|
}
|
}
|
|
/* open logger system */
|
if( log_open(logfile, loglevel, logsize, THREAD_LOCK_NONE) < 0 )
|
{
|
fprintf(stderr, "Initial log system failed\n");
|
return 1;
|
}
|
|
/* install signal proc handler */
|
install_default_signal();
|
|
/* check program already running or not, if already running then exit, or set running as daemon */
|
if( check_set_program_running(daemon, DAEMON_PIDFILE) < 0 )
|
goto cleanup;
|
|
log_info("socket server(TLV) running and listen on port[%d].\n", port);
|
|
/* initial listen socket */
|
if( socket_listen(&sock, port) < 0 )
|
{
|
log_error("create listen socket failure\n");
|
rv = 2;
|
goto cleanup;
|
}
|
|
/* create epoll and put listen socket into it */
|
if( (epollfd=epoll_init(MAX_EVENTS, sock.fd)) < 0 )
|
{
|
log_error("initial epoll for listen socket failure\n");
|
rv = 3;
|
goto cleanup;
|
}
|
|
/* g_signal.stop defined in proc.c, and will be set when catch stop signal */
|
while( !g_signal.stop )
|
{
|
/* epoll wailt and program will blocked here */
|
nfds = epoll_wait(epollfd, event_array, MAX_EVENTS, -1 /* never timeout */);
|
if( nfds <= 0 )
|
{
|
log_error("epoll_wait failure or timeout: %s\n", strerror(errno));
|
continue;
|
}
|
|
/* nfds>0 is the active events count */
|
for(i=0; i<nfds; i++)
|
{
|
fd = event_array[i].data.fd;
|
|
/* epoll get error */
|
if ( (event_array[i].events&EPOLLERR) || (event_array[i].events&EPOLLHUP) )
|
{
|
log_error("epoll_wait get error on fd[%d]: %s\n", fd, strerror(errno));
|
if( fd != sock.fd )
|
term_socket_client(epollfd, event_array[i].data.fd, &buf_list);
|
|
continue;
|
}
|
|
/* listen socket get event means new client start connect now */
|
if( fd == sock.fd )
|
{
|
/* accept new client socket */
|
if( (connfd=accept(sock.fd, (struct sockaddr *)NULL, NULL)) < 0)
|
{
|
log_info("accept new client failure: %s\n", strerror(errno));
|
continue;
|
}
|
|
/* add new client socket into epoll */
|
if( epoll_add(epollfd, connfd) < 0 )
|
{
|
close(connfd);
|
log_error("epoll add client socket failure, rv=%d\n", rv);
|
}
|
|
/* malloc client buffer and add it into list */
|
if( NULL != (cli_buf=(cli_buf_t *)malloc(sizeof(*cli_buf))) )
|
{
|
memset(cli_buf, 0, sizeof(*cli_buf));
|
cli_buf->fd = connfd;
|
list_add_tail(&cli_buf->list, &buf_list);
|
log_info("alloc and add socket[%d] buffer[%p] into list\n", cli_buf->fd, cli_buf);
|
}
|
|
log_info("accept and add new client socket[%d] ok.\n", connfd);
|
}
|
/* already connected client socket get data arrive */
|
else
|
{
|
cli_buf = NULL;
|
|
/* Use list_for_each_entry to find the client buf in buf list */
|
list_for_each_entry(node, &buf_list, list)
|
{
|
if( node->fd == fd )
|
{
|
log_info("found socket[%d] buffer[%p] in list\n", fd, node);
|
cli_buf = node;
|
}
|
}
|
|
if( !cli_buf )
|
{
|
log_error("can not find socket[%d] buffer and close it now\n", fd);
|
term_socket_client(epollfd, fd, NULL);
|
}
|
|
rv=read(fd, &cli_buf->buf[cli_buf->bytes], sizeof(cli_buf->buf)-cli_buf->bytes);
|
if( rv <= 0 )
|
{
|
log_warn("socket[%d] read failure [%s] or disconncet, terminate it now.\n",
|
fd, strerror(errno));
|
|
term_socket_client(epollfd, fd, &buf_list);
|
continue;
|
}
|
else
|
{
|
cli_buf->bytes += rv;
|
log_debug("socket[%d] receive %d bytes data\n", fd, rv);
|
}
|
|
parser_tlv_data(cli_buf);
|
}
|
}
|
|
sleep(1);
|
}
|
|
|
cleanup:
|
socket_term(&sock);
|
log_close();
|
return 0;
|
}
|
|
static int parser_tlv_data(cli_buf_t *cli_buf)
|
{
|
int i, rv;
|
int left_bytes;
|
pack_info_t pack_info;
|
|
if( !cli_buf )
|
{
|
log_error("Invalid input arguments\n");
|
return -1;
|
}
|
|
log_info("start to parser client buffer %d bytes data:\n", cli_buf->bytes);
|
log_dump(LOG_LEVEL_INFO, NULL, cli_buf->buf, cli_buf->bytes);
|
|
if( cli_buf->bytes < TLV_FIXSIZE )
|
{
|
log_warn("TLV packet bytes less than min. size\n");
|
return -2;
|
}
|
|
for(i=0; i<cli_buf->bytes; i++)
|
{
|
memset(&pack_info, 0, sizeof(pack_info));
|
rv = parser_tlv_pack(&pack_info, (uint8_t *)&cli_buf->buf[i], cli_buf->bytes);
|
if( rv <= 0 )
|
{
|
/* parser failed, continue to parser next byte */
|
continue;
|
}
|
else if( rv == 0)
|
{
|
log_debug("found TLV packet header on [%d]\n", i);
|
|
/* remove the parsed garbage data */
|
left_bytes = cli_buf->bytes - i;
|
memmove(cli_buf->buf, &cli_buf->buf[i], left_bytes);
|
cli_buf->bytes = left_bytes;
|
|
log_warn("TLV packet not integrated, need receive left data");
|
break;
|
}
|
|
/* parser and get a correct TLV packet */
|
|
left_bytes = cli_buf->bytes - rv;
|
memmove(cli_buf->buf, &cli_buf->buf[i+rv], left_bytes);
|
cli_buf->bytes = left_bytes;
|
|
if( TAG_TEMPERATURE == pack_info.tag )
|
{
|
log_info("devsn: %s temperature:%.2f \n", pack_info.devid, pack_info.temper);
|
}
|
}
|
|
/* all the data is garbage */
|
if( rv < 0)
|
{
|
log_error("parser TLV data failed, remove the unused garbage data\n");
|
|
/* maybe last byte is the header's first byte */
|
cli_buf->buf[0] = cli_buf->buf[cli_buf->bytes-1];
|
cli_buf->bytes = 1;
|
}
|
|
return 0;
|
}
|
|
static void term_socket_client(int epollfd, int fd, struct list_head *buf_list)
|
{
|
cli_buf_t *buf, *tmp;
|
|
log_warn("start terminatl client socket[%d]\n", fd);
|
|
/* if get buf_list, then remove buf from list */
|
if( buf_list )
|
{
|
/* Use list_for_each_entry_safe to travel the socket list and destroy the buffer */
|
list_for_each_entry_safe(buf, tmp, buf_list, list)
|
{
|
if( buf->fd == fd )
|
{
|
list_del(&buf->list);
|
free(buf);
|
log_info("free socket[%d] buffer[%p]\n", fd, buf);
|
break;
|
}
|
}
|
}
|
|
epoll_del(epollfd, fd);
|
close( fd );
|
}
|
