server.c

linux 下的socket 服务端程序

// server.c

#ifndef TEST_SERVER_C
#define TEST_SERVER_C

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <errno.h>

#define MYPORT 	        	5986
#define MAXBACKLOG      	5
#define STRLEN	        	0x10000
#define GN_EVT_MSU              4
#define GN_EVT_STARTTIME        14
#define GN_EVT_TRANS_ALARM      5
#define GN_EVT_SIGNAL_ALARM     6
#define MAX_SU_DATA_LEN         400
#define TCP_BUFFER_SIZE         0x20000
#define MAX_FILE_SIZE           0xa00000

#ifndef TO_FILE
#define TO_FILE
#endif

typedef struct tagGN_EVENT_HEAD {
   unsigned short length;
   unsigned char type;
   unsigned int  tmStamp0;
   unsigned char tmStamp1;
}EventHead;

unsigned char szPendingBuf[TCP_BUFFER_SIZE];
int  iPendingLen;
long cnt;
char seq;
int file_size;
char name[32];

int  analyseTcpStream(unsigned char *cbuffer, int len);
int  WriteToFile(unsigned char *data, int ilen);


void *pthread_work(void *fd)
{ 
  int iret;
  int sockfd = *(int *)fd;
  char cBuf[STRLEN];
//  char errmsg[256];
  fd_set fds;
  struct timeval timeout = {3,0};
  int tcp_buff_size, optlen;
  
  optlen = 1;
  tcp_buff_size = TCP_BUFFER_SIZE;
  if ((setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, (char*)&tcp_buff_size, sizeof(optlen)) != 0)
     || (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (char*)&tcp_buff_size, sizeof(optlen)) != 0))
  {
    fprintf(stderr, "setsockopt error:%s\n", strerror(errno));
    return NULL;
  }

  while(1)
  {
    FD_ZERO(&fds);
    FD_SET(sockfd, &fds);
    switch(select(sockfd+1, &fds, NULL, NULL, &timeout))
    {
      case -1: // close or error
        close(sockfd);
        return NULL;
      case 0: //timeout
        break;
      default:
        if (FD_ISSET(sockfd, &fds))
        {
          iret = recv(sockfd, cBuf, STRLEN, 0);
          if (iret == 0)
          {
            fprintf(stderr, "socket :%d is closed\n", sockfd);
            close(sockfd);
            return NULL;
          }
          
#ifdef TO_FILE
          WriteToFile(cBuf, iret);          
#else
          analyseTcpStream(cBuf, iret);
#endif
        }
    }

  }//while
}

int main(int argc , char **argv)
{
  int sockefd,listend;
  int ret,i,addrlen;
  struct sockaddr_in my_addr;
  char buf[STRLEN];
  pthread_t thid;
  int svr_port;
  time_t new_time;
  struct tm *pt;

  if(argc != 2)
  {
    printf("parameter error\n");
    return 0;

  }
  // initinal
#ifdef TO_FILE
  seq = 0;
  cnt =0;
  iPendingLen=0;
  file_size=0;
  time(&new_time);
  pt = gmtime(&new_time);
  sprintf(name,"%04d%02d%02d%02d%02d%02d%03d.dat", 
    pt->tm_year+1900,
    pt->tm_mon+1,
    pt->tm_mday,
    pt->tm_hour,
    pt->tm_min,
    pt->tm_sec,
    seq++);
#endif


  svr_port = atoi(argv[1]);
  sockefd=socket(AF_INET,SOCK_STREAM,0);
  my_addr.sin_family=AF_INET;
  my_addr.sin_port=htons(svr_port);
  my_addr.sin_addr.s_addr= htonl(INADDR_ANY);
  bzero(&my_addr.sin_zero,8);

  ret=bind(sockefd,(struct sockaddr*)&my_addr,sizeof(struct sockaddr_in));
  if(ret<0)
  {
    fprintf(stderr,"server:bind ret=[%d],error: %s\n",ret,strerror(errno));
    return -1;
   }

  ret=listen(sockefd,MAXBACKLOG);
  if(ret<0) 
  {
    fprintf(stderr,"server:listen ret=[%d]\n",ret);
    return -1;
  }
  fprintf(stderr,"socket %d is Listening at %d\n", sockefd,svr_port);

  while(1)
  {
    addrlen=sizeof(struct sockaddr_in);
    listend=accept(sockefd,(struct sockaddr *)&my_addr,&addrlen);
    if(listend==-1)
    {
      fprintf(stderr,"server:accept listend=[%d],errno=[%d]\n",listend,errno);
      return listend;
    }
    else
    {
      fprintf(stderr,"connect from %s\n", inet_ntoa(my_addr.sin_addr));
      if(pthread_create(&thid,NULL,pthread_work,&listend)<0) 
      {
        fprintf(stderr, "create the %dth thread fail\n",i);
        return -1;
      }
    }	
  }//while

  return 0;
}


int analyseTcpStream(unsigned char *cbuffer, int len)
{
  int iPendingPtr = 0;
  int bDoneFlag = 0;
  //EventHead *pEvt;
  unsigned char szTmpBuf[2048], outbuf[256];
  unsigned char *ptr;
  int i, packlen, type;
  static int sn[32];
  int seq;
  unsigned char e1,b1,b2,b3,b4;

  if((len + iPendingLen) > TCP_BUFFER_SIZE) {   return 0;}
  memcpy(&szPendingBuf[iPendingLen], cbuffer, len);
  iPendingLen += len;
  
  while(!bDoneFlag && iPendingLen > 10)
  {
    //pEvt = (EventHead*)(&szPendingBuf[iPendingPtr]);
    ptr = szPendingBuf+iPendingPtr;
    //packlen = pEvt->length;
    packlen = *ptr + *(ptr+1) * 0x100;
    type = *(ptr+2);

    //check packet length is valid
    if(packlen > MAX_SU_DATA_LEN || packlen < 10)
    { /* invalid packet */
      iPendingLen = 0;
      bDoneFlag = 1;
      fprintf(stderr, "DATA error, packlen=%d\n", packlen);
      continue;
    }

    if(iPendingLen < packlen)
    { /* packet no finished */
      bDoneFlag = 1;
      continue;
    }

    switch(type)
    {
      case GN_EVT_MSU:
        e1 = *(ptr+8);
        b1 = *(ptr+10);
        b2 = *(ptr+11);
        b3 = *(ptr+12);
        b4 = *(ptr+13);
        seq = b1 + b2 * 0x100 + b3 * 0x10000 + b4 * 0x1000000;
        if (seq != (sn[e1]+1))
        {
          fprintf(stderr, "E1[%d] seq lost , last-current[%d - %d]\n",
              e1, sn[e1], seq);
        }
        if (seq == 43)
        {
          seq = 0;
        }
        sn[e1] = seq;

        if (!(cnt++ & 0x0000ffff))
          fprintf(stderr, "\r(%u) packlen=%3d", cnt, packlen);
        break;
      case GN_EVT_STARTTIME:
        for(i = 0; i< packlen; i++)
          sprintf(&outbuf[i*3], " %02x", *ptr++ & 0xff);
        fprintf(stderr,outbuf);
        fprintf(stderr,"\n");
        break;
      default:
        fprintf(stderr, "recv data error \n");
        bDoneFlag = 1;
        iPendingLen = 0;
        break;
    }
    iPendingLen -= packlen;
    iPendingPtr += packlen;
  }//while

  if(iPendingLen > 0 && iPendingLen < MAX_SU_DATA_LEN)
  {
    memcpy(szTmpBuf, &szPendingBuf[iPendingPtr], iPendingLen);
    memcpy(szPendingBuf, szTmpBuf, iPendingLen);
  }
  else if (iPendingLen != 0)
  { 
	iPendingLen = 0;
  }

  return 0;
}

int WriteToFile(unsigned char *data, int ilen)
{
  char tmpname[32];
  struct tm *pt;
  FILE *pfd;
  time_t new_time;

  if (file_size > MAX_FILE_SIZE)
  {
    time(&new_time);
    pt = gmtime(&new_time);
    sprintf(name,"%04d%02d%02d%02d%02d%02d%03d.dat", 
      pt->tm_year+1900,
      pt->tm_mon+1,
      pt->tm_mday,
      pt->tm_hour,
      pt->tm_min,
      pt->tm_sec,
      seq++);
    file_size = 0;
  }


  if (!(pfd=fopen(name, "a+b")))
  {
    fprintf(stderr, "open file error:%s\n", strerror(errno));
    return -1;
  }
  
  if (fwrite(data, 1, ilen, pfd) != ilen)
  {
    fprintf(stderr, "write file error:%s\n", strerror(errno));
    return -1;
  }

  file_size += ilen;

  if (fclose(pfd))
  {
    fprintf(stderr, "close file error:%s\n", strerror(errno));
    return -1;
  }

}

#endif