tcpfunc.c

unix下用C写的实现2主机间TCP通讯用的函数。

/********************************************
**  PROGRAM: tcpfunc.c                     **
**  AUTHOR: kenny                          **
**  WRITE DATE:       09/21/1997           **
**  LAST MODIFY DATE: 09/21/1997           **
**  COMMENT: TCP通信函数程序               **
**                                         **
*********************************************/
#include <stdio.h>
#include <memory.h>
#include <string.h>
#include "../incl/tcpt.h"
#include <errno.h>

extern int _n_Debug;
extern char _s_PrgName[];

#define  STX                 0x02
#define  ETX                 0x03

static char dirty_buf[MMAX]; /* Internal buffer for whatever purpose */

/*
 * readn() -- Function to read n bytes from network connection
 *   para   --
 *   return --
 */
int readn(int sd, char *ptr, int nbyte)
{
   int	nleft, nread;

    nleft = nbyte;
    while (nleft > 0) 
    {
	nread = read(sd, ptr, nleft);
	if (nread < 0) 
        {
        /*   perror("nread<0"); 
           printf("errno=%d",errno);
         */
	   return (nread);
        }
	else if (nread == 0) /* EOF */
       {
         /*  perror("nread==0");
           printf("errno=%d",errno);
          */
	   break;
        }

	nleft -= nread;
	ptr += nread;
    }

    /* Return number of bytes read == nbyte - nleft */
    return (nbyte - nleft);
}


/*
 * writen() -- Function to write n bytes from network connection
 *   para   --
 *   return --
 */
int writen(int sd, char *ptr, int nbyte)
{
    int	nleft, nwritten;

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

    /* Return number of bytes written == nbyte - nleft */
    return (nbyte - nleft);
}

/*
 * GetMessage() -- Function to get one application level message from socket 
 *   para   --
 *   return --
 */
int GetMessage(int sd, char *ptr, int max)
{
    int	  nread;
    char  cs_nob[USHORT_LEN + 1];	/* No. of bytes in character */
    unsigned char LRC=0;
    int s_nob;			/* No. of bytes in short */
    int	  nbyte;			/* No. of bytes to read from stream */
    int	  ret = -1;			/* Final return value */
    int i;
    char temp[30];

    /* First get the number of bytes in application message *
    nread = readn(sd, cs_nob, USHORT_LEN);
    if (nread != USHORT_LEN)
	return -1;

    * Convert to number *
    memcpy(&s_nob, cs_nob, USHORT_LEN);
    s_nob = ntohs(s_nob);
    ****/

    if ((nread=readn(sd, cs_nob, 1)) != 1)
    {
      fprintf(stderr, "read Err--1!!!!!!!!\n");
      return -1;
     }
    if (cs_nob[0] != STX)
    {
      fprintf(stderr, "read Err not equal STX  !!!!!!!!\n");
      return -1;
     }
    if ((nread=readn(sd, cs_nob, 2)) != 2)
    {
      fprintf(stderr, "read Err---2 !!!!!!!!\n");
      return -1;
     }
    /*fprintf(stderr,"receive len =[%02x %02x] ", cs_nob[0], cs_nob[1]);*/
    s_nob = (int)(((unsigned char)cs_nob[0]>>4)&0x0f)*1000 + (int)(cs_nob[0]&0x0f)*100;
    s_nob += (int)(((unsigned char)cs_nob[1]>>4)&0x0f)*10 + (int)(cs_nob[1]&0x0f);
   /* fprintf(stderr,"receive s_nob=%d ", s_nob);*/

    if (s_nob > max)
	nbyte = max;
    else
	nbyte = s_nob;

    /* Read remaining bytes */
    nread = readn(sd, ptr, nbyte);
    ret = nread;

    if (nread != nbyte)
    {
      fprintf(stderr, "read Err---3 !!!!!!!!\n");
      return -1;
     }
    if (readn(sd, dirty_buf, 2) != 2)
    {
      fprintf(stderr, "read Err---4 !!!!!!!!\n");
      return -1;
     }
    if (dirty_buf[0] != ETX)
    {
        printf("Read ETX error!\n"); 
        return -1;
    }

    LRC = 0;
    LRC ^= cs_nob[0];
    LRC ^= cs_nob[1];
    for (i=0; i<nbyte; i++)
      LRC ^= *(ptr+i);
    LRC ^= ETX;
    if (LRC != (unsigned char) dirty_buf[1])
    {
      printf("Read LRC error: [%02x %02x]\n", LRC, dirty_buf[1]);
      ret = -1;
    }
	
    /* Check if there is remaining bytes to clear */
    /* Return value independent on result of this section */
    nread = s_nob - max;	 /*Could be negative */
    while (nread > 0) 
    {
	if (nread >= MMAX) 
	    nbyte = MMAX;
	else
	    nbyte = nread; 
	nbyte = readn(sd, dirty_buf, nbyte);
	if (nbyte > 0)
	    nread -= nbyte;
	else
	    break;
    }

    /* Return number of application bytes got */
    return (ret);
}


/*
 * PutMessage() -- Function to put one application level message from socket 
 *   para   --
 *   return --
 */
int PutMessage(int sd, char *ptr, int nbytes)
{
    /* Similar variables as getMessage */
    int	nwritten;
    char	cs_nob[USHORT_LEN + 1];
    short	s_nob;
    unsigned char LRC;
    int i;
    char temp[30];

    cs_nob[0] = STX;
    if ((nwritten=writen(sd, cs_nob, 1)) != 1)
       return -1;
    cs_nob[0] = ((nbytes/1000)<<4) + ((nbytes/100)%10);
    cs_nob[1] = ((nbytes/10)%10<<4) + (nbytes%10);

    if ((nwritten=writen(sd, cs_nob, 2)) != 2)
        return -1;
    /* Write out application data */
    nwritten = writen(sd, ptr, nbytes);
    if (nwritten != nbytes)
        return -1;
    LRC = 0;
    LRC ^= cs_nob[0];
    LRC ^= cs_nob[1];
    for (i=0; i<nbytes; i++)
        LRC ^= *(ptr+i);
    LRC ^= ETX;

    cs_nob[0] = ETX;
    cs_nob[1] = LRC;
    if (writen(sd, cs_nob, 2) != 2)
        return -1;

     return nwritten;
}


/*
 * GetMessage() -- Function to get one application level message from socket 
 *   para   --
 *   return --
 */
int GetMessageFile(int sd, char *ptr, int max)
{
    int	  nread;
    char  cs_nob[USHORT_LEN + 1];	/* No. of bytes in character */
    short s_nob;			/* No. of bytes in short */
    int	  nbyte;			/* No. of bytes to read from stream */
    int	  ret = -1;			/* Final return value */

    /* First get the number of bytes in application message */
    nread = readn(sd, cs_nob, USHORT_LEN);
    if (nread != USHORT_LEN)
	return -1;

    /* Convert to number */
    memcpy(&s_nob, cs_nob, USHORT_LEN);
    s_nob = ntohs(s_nob);

    if (s_nob > max)
	nbyte = max;
    else
	nbyte = s_nob;

    /* Read remaining bytes */
    nread = readn(sd, ptr, nbyte);
    if (nread != nbyte)
	return -2;
	
    ret = nread;
	
    /* Check if there is remaining bytes to clear */
    /* Return value independent on result of this section */
    nread = s_nob - max;	 /*Could be negative */
    while (nread > 0) 
    {
	if (nread >= MMAX) 
	    nbyte = MMAX;
	else
	    nbyte = nread; 
	nbyte = readn(sd, dirty_buf, nbyte);
	if (nbyte > 0)
	    nread -= nbyte;
	else
	    break;
    }

    /* Return number of application bytes got */
    return (ret);
}


/*
 * PutMessage() -- Function to put one application level message from socket 
 *   para   --
 *   return --
 */
int PutMessageFile(int sd, char *ptr, int nbytes)
{
    /* Similar variables as getMessage */
    int	nwritten;
    char	cs_nob[USHORT_LEN + 1];
    short	s_nob;

    /* First put number of bytes */
    s_nob = (short) nbytes;
    s_nob = htons(s_nob);
    memcpy(cs_nob, &s_nob, USHORT_LEN);
    nwritten = writen(sd, cs_nob, USHORT_LEN);
    if (nwritten != USHORT_LEN)
	return -1;

    /* Write out application data */
    nwritten = writen(sd, ptr, nbytes);
    if (nwritten != nbytes)
	return -1;

    return nwritten;
}

/*
 * reserve_012() --
 *   para   --
 *   return --
 */
void reserve_012()
{
    int	fd;

    fd = open("/dev/null", O_RDWR);
    if (fd > 0) 
    {
	close(0);
	close(1);
	close(2);
	dup(fd);
	dup(fd);
	dup(fd);
	close(fd);
    }
}

/*
 * logmsg() --
 *   para   --
 *   return --
 */
void logmsg(char *fmt, ...)
{
    va_list	ap_list;
    FILE	*fp;
		
    va_start(ap_list, fmt);

    fp = fopen("/tmp/sltcpqlog", "w");
    if (fp != NULL) 
    {
	vfprintf(fp, fmt, ap_list);
	fclose(fp);
    }
    va_end(ap_list);
}

/*
 * ConnectRemote() -- to initiate a connection and waiting for a connection 
 *   para   --
 *   return --
 */
int ConnectRemote(char *hostname, short s_remote_port)
{
    static  char cache_hostname[MMAX];  /* Cached hostname */
    static  int first_call = TRUE;      /* Check if it is first called */
    static  struct sockaddr_in	ser_addr;
    struct  sockaddr_in backup;	        /* In case cannot resolve hostname */
    int	    sd;
    struct  hostent *h;
    struct  in_addr *p;

    if (first_call) 
    {
	cache_hostname[0] = '\0';
	first_call = FALSE;
    }

    if (strcmp(hostname, cache_hostname) != 0) 
    {
	/* Make a backup first */
	backup = ser_addr;

	/* Get IP address of the host */
	memset((char *) &ser_addr, 0, sizeof(ser_addr));
	ser_addr.sin_family = AF_INET;
	ser_addr.sin_addr.s_addr = inet_addr(hostname);
	/*if ((long) ser_addr.sin_addr.s_addr == INADDR_NONE) 
        {*/
    	    h = gethostbyname(hostname);
	    if (h != NULL) 
            {
		p = (struct in_addr *) (h->h_addr_list[0]);
		ser_addr.sin_addr.s_addr = p->s_addr;
	    }
	    else 
            {
		/* Cannot resolve address */
		/* Restore from backup */
		ser_addr = backup;
		logmsg("TCPT : [ %05d ] : Cannot resolve %s\n", getpid(), hostname);
		return -1;
	    }
/*	}
*/	/* Cache hostname */
	strcpy(cache_hostname, hostname);
    }
	
    /* Then setup port for all cases */
    ser_addr.sin_port = htons(s_remote_port);

    /* Open socket */
    sd = socket(AF_INET, SOCK_STREAM, 0);
    if (sd < 0)
    {
	logmsg("TCPT : [ %05d ] : Cannot open socket\n", getpid());
	return -2;
    }

    if (connect(sd, (struct sockaddr *) &ser_addr, sizeof(ser_addr)) < 0) 
    {
	close(sd);
    /*    perror("errno:\n"); 
        fprintf(stderr,"errno=[%d]\n",errno);
      */
	return -3;
    }

    return sd;
}

/*
 * ListenRemote() --
 *   para   --
 *   return --
 */
int ListenRemote(short s_own_port)
{
    static 	struct sockaddr_in	ser_addr; /* Cached */
    static	int first_call = TRUE;
    int		sd;
    int		opt;

    if (first_call) 
    {
	memset(&ser_addr, 0, sizeof(ser_addr));
	ser_addr.sin_family = AF_INET;
	ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	first_call = FALSE;
    }

    /* Set port for all cases */
    ser_addr.sin_port = htons(s_own_port);

    /* Get a socket */	
    sd = socket(AF_INET, SOCK_STREAM, 0);
    if (sd < 0) 
    {
	logmsg("TCPT : [ %05d ] sd = %d\n", getpid(), sd);
	return -1;
    }

    /* Set socket reuse address option */
    opt = 1;
    if (setsockopt(sd,SOL_SOCKET,SO_REUSEADDR,
           (char *) &opt,sizeof(opt))<0) 
    {
	logmsg("TCPT : [ %05d ] : setsockopt error\n", getpid());
	close(sd);
	return -2;
    }

    if (bind(sd, (struct sockaddr *) &ser_addr, sizeof(ser_addr)) < 0) 
    {
	logmsg("TCPT : [ %05d ] Cannot bind server at %hd\n", getpid(), s_own_port);
	close(sd);
	return -3;
    }

    if (listen(sd, 5) < 0)
    {
        close(sd);
        return -4;
    }

    return sd;
}


/*
 * AcceptRemote() --
 *   para   -- sd: 初始socket号
 *   return -- -1: 失败, 0: 成功
 */
int AcceptRemote(sd)
int sd;
{
    struct 	sockaddr *cli_addr;
    int		clilen;
    int         newsd;

    /* Block at accept */
/*
    clilen = sizeof(cli_addr);
*/
    cli_addr = NULL;
    clilen = 0;

    newsd = accept(sd, cli_addr, &clilen);
    if (newsd < 0) 
    {
	close(sd);
	return -1;
    }
    else 
    {
	close(sd);
	return newsd;
    }

}


int AcceptRemote1(int sd,char cli_ip[16],char zone[6])
{
    struct 	sockaddr_in cli_addr;
    int		clilen,flag=1;
    int         newsd;
    FILE	*fp;
    char	tmp[200],*ptr;

    /* Block at accept */
/*
    clilen = sizeof(cli_addr);
*/
/*    cli_addr = NULL;*/
    clilen = sizeof( struct sockaddr_in);

    newsd = accept(sd, (struct sockaddr *)&cli_addr, &clilen);
    if (newsd < 0) 
    {
	close(sd);
	return -1;
    }
    else 
    {
	sprintf(cli_ip,"%s",(char *)inet_ntoa(cli_addr.sin_addr));
	strtok(cli_ip," ");
	
	fp=fopen("/usr/maps/conf/filesvr_conf","r");
	while(fgets(tmp,sizeof(tmp)-1,fp))
	{
		if((ptr=strstr(tmp,cli_ip))!=NULL)
		{
			flag=0;
			memcpy(zone,tmp+strlen(cli_ip)+1,5);
			break;
		}
		flag=1;
	}
	if(flag==1) sprintf(zone,"0000");	

	close(sd);
	return newsd;
    }

}