Can a socket expert on Unix review this code. In current state it is acting a little flakey! Errors out.

can i pay someone with more smarts than me to review this socket code in unix c.

I want to make it more robust, it seems to error out a lot.  Any pointers, hints, suggestions would be great.  It only has one client connected to it at any time, it receives and sends information.  

Thanks

<email id removed by sunnycoder, Page Editor>











#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include "/wdpf/rel/ssw/shc/inc/SHC_err.h"
#include "/wdpf/rel/ssw/shc/inc/spd.h"
#include "pointServer.h"
#include <signal.h>
#include <unistd.h>


#define TRUE 1
#define FALSE 0
#define anaDB  .01
#define MAXPOINTS 8000
#define RECBUFFSIZE  400000
#define SENDBUFFSIZE 400000
#define MAXRECORDSENDS 100

/* signal stuff */
void update_timer(int);
void cleanup();

#define SCANTIME  1


char debug_msg = FALSE;
int PORT;

void processRead(void);

typedef struct datarec {
       char pn[9];
    int rt;
    unsigned short digital_val;
    unsigned short old_digital_val;
      unsigned short digital_stat;
      unsigned short old_digital_stat;
      unsigned short gp_val;
      unsigned short old_gp_val;
      unsigned short gp_stat;
      unsigned short old_gp_stat;
      unsigned short gp_force_stat;
      unsigned short old_gp_force_stat;
      float av;
    float old_av;      
    unsigned short as;
      unsigned short old_as;
    long sid; } DATAREC;



/* struct datarec *indatap; */
struct datarec indatap[MAXPOINTS];


int numpoints;

FILE *data_lun;
int access_type = RUNTIME;
static char *wdpf_pdir;
long gp_sid = 0;
char gp_bit_num = 0;
char ina_flag;
char ext_flag;
char outbuff[SENDBUFFSIZE];   /* need to dynamically do this! later*/
char inbuff[RECBUFFSIZE];
int file_desc;
int status;
/* char ch[1]; */
int pcalcins, pcalcouts;
int msgsock;
struct tm *local;
Point_entry point_info;
char network_name[8];
unsigned short digital_val;
unsigned short digital_stat;
unsigned short gp_val;
unsigned short gp_stat;
unsigned short gp_force_stat;
char field_name[2];
unsigned char byte_val;
int optlen;
long sockstat;
int ch;

main(int argc, char *argv[])
{

int sock,clientLen,serverLen;
struct sockaddr_in serverAddr, clientAddr;
int i;
char on=1;
int tcpsendbuff, tcprecbuff;
struct linger stLinger;

if(debug_msg)
printf("\nprogram started...");


/** get program command flags **/
/** first argument is port number **/
if(argc < 2) {
  printf("\nincorrect calling parameters;  rt portID <d>  <d> = debug mode");
  exit(0); }

/** see if want to go into debug mode **/
while(--argc >0)
 if(strchr(argv[argc],'d')) {
   debug_msg = TRUE;
   printf("\nentering debug message mode\n"); }

/** get port number from command line **/
PORT = strtol(argv[1],NULL,10);

/** set up WDPF stuff **/
wdpf_pdir = (char *) getenv("WDPF_PDIR");
if(wdpf_pdir == NULL) {
  printf("\nunable to get WDPF_PDIR environment variable");
  exit(1); }

status = SHC_open_memory();
if(status != SHC_OK) {
  printf("\nSHC_open_memory error -- status = %d",status);
  exit(1); }

file_desc = SPD_open_file(wdpf_pdir,&access_type);
if(file_desc < 0) {
  printf("\nSPD_open_file error -- %s status = %d",wdpf_pdir,file_desc);
  exit(1); }



/******************** set up socket interface with NT  ***********************/


/** setup stream socket **/
if((sock = socket(AF_INET,SOCK_STREAM,0)) < 0) {
    printf("\ncannot open stream socket");
    exit(1); }

if(debug_msg)
  printf("\ncreated sock, sock = %d..",sock);

/** set socket options **/
if(setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on)) < 0) {
    printf("\ncannot set SO_REUSEADDR socket option");
   /* exit(1);*/ }
   

tcpsendbuff = 64384;
tcprecbuff = 64384;


if(setsockopt(sock,SOL_SOCKET,SO_SNDBUF, (char *) &tcpsendbuff, sizeof(tcpsendbuff)) < 0) {
    printf("\ncannot set SO_SNDBUF socket option");
    exit(1); }
 
if(setsockopt(sock,SOL_SOCKET,SO_RCVBUF, (char *) &tcprecbuff, sizeof(tcprecbuff)) < 0) {
    printf("\ncannot set SO_RCVBUF socket option");
    exit(1); }

optlen =sizeof(tcpsendbuff);
if(getsockopt(sock,SOL_SOCKET,SO_SNDBUF, (char *) &tcpsendbuff, &optlen) < 0) {
    printf("\ncannot set SO_SNDBUF socket option");
    exit(1); }
if(debug_msg)
 printf("\nnew SO_SNDBUF len = %d",tcpsendbuff);


optlen =sizeof(tcprecbuff);
if(getsockopt(sock,SOL_SOCKET,SO_RCVBUF, (char *) &tcprecbuff, &optlen) < 0) {
    printf("\ncannot set SO_RCVBUF socket option");
    exit(1); }
if(debug_msg)
 printf("\nnew SO_RCVBUF len = %d",tcprecbuff);


serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port=htons(PORT);

if(bind(sock,(struct sockaddr *) &serverAddr,sizeof(serverAddr)) < 0) {
   printf("\ncannot bind stream socket error, port = %d",PORT);
   exit(1); }

if(debug_msg)
  printf("\nbind socket ok...");

serverLen = sizeof(serverAddr);

if(getsockname(sock,(struct sockaddr *) &serverAddr,&serverLen) <0) {
   printf("getting socket name");
   exit(1); }

if(debug_msg)
  printf("\ngetsocketname ok...");

listen(sock,1);

if(debug_msg)
  printf("\nlistening for requests on socket %d...",PORT);

/* turn off alarming up front  */
signal(SIGINT, cleanup);
signal(SIGPIPE, SIG_IGN);



for(;;) {

do {
  clientLen= sizeof(clientAddr);
  msgsock = accept(sock, (struct sockaddr *) &clientAddr, &clientLen);
if(debug_msg);  
printf("\nmsgsock=%d errno = %d errstr = %s",msgsock,errno,strerror(errno));
}while (msgsock <0 && (errno == EINTR || errno == 32));


if(msgsock < 0)
 if(debug_msg) {
    printf("\nsock accept error");
    exit (-1); }
 

if(debug_msg)
  printf("\naccepted socket...");
inbuff[0]='\0';
i=readn(msgsock,inbuff, sizeof(inbuff));

if(debug_msg) {
 printf("\nreceived %d bytes",i);
 printf("\nstring = %s",inbuff); }



 read_request();
 /* checkforchanges();  */

}/* end for loop */

if(debug_msg)
printf("\nexiting do loop errno = %s",strerror(errno));
sockstat = close(msgsock);
exit(0);



}

/*************************** end main **********************************/



/************************************************************************/
/** this function  used to read "n" bytes from socket **/
int
readn(fd,ptr,nbytes)
register int fd;
register char *ptr;
register int nbytes;
{
int nleft,nread;
char tmpbuff[RECBUFFSIZE];


nleft = nbytes;
ptr = tmpbuff;

do {

nread = read(fd,ptr,nleft);
 
if(nread < 0)
   return(nread);
else if (nread == 0)
   break;

nleft -= nread;
ptr   += nread;
*ptr ='\0';

if(strstr(tmpbuff,"^^"))
{
  break;
}


} while(1);

tmpbuff[strlen(tmpbuff)]='\0';
strcpy(inbuff,tmpbuff);
return(strlen(tmpbuff));

}


/*************************************************************************/
/* used to write "n" bytes */
int
writen(fd,ptr,nbytes)
register int fd;
register char *ptr;
register int nbytes;
{

int nleft, nwritten;

nleft = nbytes;

while(nleft >0) {
 
nwritten = write(fd,ptr,nleft);
 
if(nwritten <=0)
    return(nwritten);
  nleft -= nwritten;
 ptr   += nwritten;
}

return(nbytes - nleft);
}
/*****************************************************************/




/********** read inputs points ******/
read_request(void)
{

int i,j;
char cmdType[3];
int cmdNum;
int status;
int count;
char strcount[5];
char field_name[2];
char in;

cmdType[0]='\0';
cmdNum=99;

strncpy(cmdType,inbuff+0,2);
cmdNum = atoi(cmdType);
cmdType[2]='\0';



/* whole point records */
if(cmdNum==0) {


update_timer(0);
 
strncpy(strcount,inbuff+2,4);
strcount[4]='\0';
count = atoi(strcount);
numpoints = count;


if(debug_msg)
 printf("\nrequested to retreive %d points",count);

/* allocate memory based on number of points found */
/*indatap = malloc(count * sizeof(datarec)); */
if(debug_msg)
  printf("\nallocated %d memory structures for points",count);


j=6;
for (i = 1;i <=count; i++)
 {
strncpy(indatap[i].pn, inbuff+j,8);
j=j+8;
indatap[i].pn[8]='\0';

/* need to add error checking here later*/
status = SPD_get_sid(&file_desc,indatap[i].pn,&indatap[i].sid,&gp_sid,&gp_bit_num,&ext_flag,&ina_flag);


status = SPD_get_point_info(&file_desc,&indatap[i].sid,&point_info,network_name);
indatap[i].rt = point_info.rec_type;

if(debug_msg)
  printf("\nrt = %d",indatap[i].rt);

if(debug_msg)
  printf("\npopulated dynamic structure for %s (index = %d) stat = %d",indatap[i].pn,i,status);
}

/* go and get whole point records if cmd type = 00*/

/* free( (void *)indatap); */
update_timer(1);

} /* end whole point record */


if(cmdNum== 2) {

update_timer(0);

strcpy(field_name,"CM");
byte_val = 14;

printf("\nnum points = %d",numpoints);
for(i=1;i<=numpoints;i++)  {
status = SHC_change_byte_attribute(&indatap[i].sid,&field_name, &byte_val);
if(debug_msg)
  printf("\nwrote ack bit for pn = %s, stat = %d", indatap[i].pn,status);
 }

update_timer(1);
} /* end write ack bit */



}


int getpointrecord()
{

int i;
int k;
unsigned char point_record[300];
char hh[2];
char hdrStr[6];
int status;
int bytesSent;
long retMsgCount;
char tempbuff[300];
int sendCounter;

/* build ret msg string in format of [cmd][index]data^^  */  
outbuff[0]='\0';
hdrStr[0]='\0';
sendCounter = 0;

/* cmdtype = 00 for whole point record ret */
sprintf(hdrStr,"%2s","00");  
hdrStr[2]='\0';
strcpy(outbuff,hdrStr);

if(debug_msg)
printf("\nnumpoints = %d",numpoints);

for (i = 1;i <= numpoints; i++)

 {

   strcat(outbuff,"(");
   sprintf(hdrStr,"%04d",i);  
   hdrStr[4]='\0';
   strcat(outbuff,hdrStr);

   tempbuff[0]='\0';
   status = SHC_get_point_record(&indatap[i].sid, &point_record);
   if(debug_msg)
    printf("\nretrieved record for %s (index = %d)",indatap[i].pn,i);

    for(k=0;k<128;k++) {
     sprintf(hh,"%02x",point_record[k]);
     strcat(tempbuff,hh);}
   
   strcat(outbuff,tempbuff);
   strcat(outbuff,")");

   if(sendCounter >= MAXRECORDSENDS) {
       outbuff[strlen(outbuff)] ='\0';
       bytesSent=writen(msgsock,(char *)outbuff,strlen(outbuff));
      if(debug_msg  )
         printf("\ngoing to send back %d bytes",strlen(outbuff));
          /*  printf("\nstring = \n%s",outbuff);  */
           outbuff[0]='\0';
         sendCounter = 0; }
   else
         sendCounter = sendCounter +1;
   
}  

/* tag ending message info */
    strcat(outbuff,"^^");
    retMsgCount = strlen(outbuff);
    outbuff[retMsgCount]='\0';

   /* send back the localbuff up to retMsgCount of len */
   if(debug_msg  ) {
     printf("\ngoing to send back %d bytes",retMsgCount);
     /* printf("\nstring = \n%s",outbuff); */ }

   bytesSent=writen(msgsock,(char *)outbuff,retMsgCount);
   if(debug_msg)
     printf("\nwriten errno = %d, sent %d bytes over network",errno,bytesSent);

/** ok once here, then start sending exceptions **/

init_struct();


}


checkforchanges()
{
int i;
char *modestr;
int status;
float absval;
int bytesSent;
char tmpstr[20];
char ch;


/* exceptions sent as CMD(PN_TOKEN=VALUE), ... */
/* clear out buffer */


/* don't let another timer hit if already in here */

/* while(1) {    */


outbuff[0]='\0';
strcpy(outbuff,"01");

for (i=1;i<=numpoints;i++)
  {

modestr="";

  switch(indatap[i].rt) {

  case RECORD_TYPE_AI:
  case RECORD_TYPE_AL:
  case RECORD_TYPE_AC:
  case RECORD_TYPE_AM:
  modestr="Analog";
  status = SHC_get_analog_val_stat(&indatap[i].sid,&indatap[i].av,&indatap[i].as);



if(indatap[i].old_as != indatap[i].as) {
      strcat(outbuff,"(");
      strcat(outbuff,indatap[i].pn);
      strcat(outbuff,"_AS=");
        sprintf(tmpstr,"%d",indatap[i].as);
        strcat(outbuff,tmpstr);
      strcat(outbuff,")");

indatap[i].old_as = indatap[i].as;
 }

if(debug_msg &&  indatap[i].old_as != indatap[i].as)  
     printf("\nold as of %s = %d, new as val = %d",indatap[i].pn, indatap[i].old_as,indatap[i].as);


  break;

  case RECORD_TYPE_DI:
  case RECORD_TYPE_DL:
  case RECORD_TYPE_DC:
  case RECORD_TYPE_DM:
  modestr="Digital";
  status = SHC_get_digital_val_stat(&indatap[i].sid,&gp_sid,&gp_bit_num,&indatap[i].digital_val,&indatap[i].digital_stat);

if(indatap[i].digital_stat != indatap[i].old_digital_stat && status == SHC_OK) {
      strcat(outbuff,"(");
       strcat(outbuff,indatap[i].pn);
      strcat(outbuff,"_DS=");
        sprintf(tmpstr,"%d",indatap[i].digital_stat & 0x01);
        strcat(outbuff,tmpstr);
      strcat(outbuff,")");

indatap[i].old_digital_stat = indatap[i].digital_stat;
}


if(debug_msg && indatap[i].digital_stat != indatap[i].old_digital_stat)
          printf("\nold ds of %s = %d, new ds = %d",indatap[i].pn, indatap[i].old_digital_stat,indatap[i].digital_stat);

/* indatap[i].old_digital_stat = indatap[i].digital_stat;
*/
        
break;


  break; }  /* end switch */


 }   /* next point, end for*/

 strcat(outbuff,"^^");
 outbuff[strlen(outbuff)]='\0';

/* only send if string is greater than the default 00^^ */
if(strlen(outbuff) > 4) {
 bytesSent=writen(msgsock,(char *)outbuff,strlen(outbuff));
   if(debug_msg)
     printf("\nwriten errno = %d, sent %d bytes over network",errno,bytesSent);
   }

if(errno == 32) {
if(debug_msg)  
  printf("\nreceived EPIPE signal, closing socket, waiting...");
 close(msgsock);
 errno=0;
 return; }

/*  sleep(SCANTIME); */

/*     }     while true */

}


 
void update_timer(int signum)
{

if(debug_msg)
  printf("\nchecking for exceptions");
checkforchanges();
signal(SIGALRM,update_timer);
alarm(SCANTIME);  
return;
}  

init_struct()
{

int i;

for(i=1;i<=numpoints;i++) {

        indatap[i].digital_val=0;
        indatap[i].old_digital_val=9;
      indatap[i].digital_stat=0;
      indatap[i].old_digital_stat=9;
      indatap[i].gp_val=0;
      indatap[i].old_gp_val=9;
      indatap[i].gp_stat=0;
      indatap[i].old_gp_stat=9;
      indatap[i].gp_force_stat=0;
      indatap[i].old_gp_force_stat=9;
      indatap[i].av=0.00;
        indatap[i].old_av=99999.00;      

}
}



void cleanup(int sig_num)
{
 signal(SIGINT,cleanup);
 printf("\nexit gracefully\n\n\n...");
 fflush(stdout);
 sockstat = close(msgsock);  
exit(0);
}