pub_socket.c

自已结累的Unix下C语言开发函数库

/*
 *socket通讯的一些函数
 *zyq - shilyu - cff 040903
 *functionnum 015
 */
 
#include "./../inc/pub.h"

#if !defined( DEBUG )
#define DEBUG
#endif

#define		ADDRESS_LEN		16
#define		SUCCESSED_RETURN_CODE	0
#define		FAILED_RETURN_CODE	-1

static int	pcsp_socket_fd=-6789, pcsp_new_socket_fd=-6789;
static char	client_ip_address[ADDRESS_LEN+1];

/* 001 
 * 设置soctet描述符的属性
 */
void init_socket( int socket_fd )
{
  struct linger linger_buffer;
  int		lo_len=1;
  int		nodelay_flag=1;

  linger_buffer.l_onoff = 1;
  linger_buffer.l_linger = 10;

  setsockopt (socket_fd, SOL_SOCKET, SO_LINGER,
              (char *)&linger_buffer, sizeof (linger_buffer));

  setsockopt (socket_fd, SOL_SOCKET, SO_SNDLOWAT,
              (char *)&lo_len, sizeof (lo_len));

  setsockopt (socket_fd, SOL_SOCKET, SO_RCVLOWAT,
              (char *)&lo_len, sizeof (lo_len));

  setsockopt (socket_fd, IPPROTO_TCP, TCP_NODELAY,
              (char *)&nodelay_flag, sizeof (nodelay_flag));

  return;
}

/* 002 
 * 端口重用设置 
 */
void SetSocketRuseAddr( int socket_fd )  
{
	/**端口重用**/
   int opt=SO_REUSEADDR ;
   
   setsockopt( socket_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&opt, sizeof( opt ) ) ;
}

/* 003 
 * close关闭连接 
 */
int close_socket( int socket_fd )
{
  if (socket_fd >= 0)
  {
    close( socket_fd ) ;
    return( ERROR ) ;
  }
  else
  {
    return( SUCCESS ) ;
  }
}

/* 004 
 * 服务器端server
 */
int pcsp_server_connect (int waiting_port)
{
   struct sockaddr_in	local_listen_address ;
   struct sockaddr	   peer_client_addr     ;
   int			         client_address_len   ;
   static long		      try_count = 0        ;

   if ( ( pcsp_new_socket_fd != -6789) && ( pcsp_socket_fd != -6789))
   {
      goto pcsp_accept_loop;
   }

   pcsp_socket_fd = socket (AF_INET, SOCK_STREAM, 0 );
   try_count ++;
   if (pcsp_socket_fd < 0)
   {
      fprintf (stderr, "open socket[socket] for bind to %d failed, errno=%d\n", waiting_port, errno);
      close_socket (pcsp_socket_fd);
      return (FAILED_RETURN_CODE);
   }

   local_listen_address.sin_family      = AF_INET              ;   /* AF_INET == 2 */
   local_listen_address.sin_addr.s_addr = htonl( INADDR_ANY )  ;
   local_listen_address.sin_port        = htons (waiting_port) ;

pcsp_bind_loop:
   if (bind (pcsp_socket_fd, (struct sockaddr *)&local_listen_address ,
       sizeof(local_listen_address)) < 0 )
   {
      fprintf (stderr, "bind socket[bind:port=%d] for listen failed, errno = %d\n",  waiting_port, errno);
      close_socket (pcsp_socket_fd);
      return (FAILED_RETURN_CODE);
   }

pcsp_listen_loop:
   if (listen (pcsp_socket_fd, 200) <0)
   {
      fprintf (stderr, "listen client connection request [listen:port=%d] failed, errno = %d", waiting_port, errno);
      #ifdef CONNECT_MODE_1
         return (FAILED_RETURN_CODE);
      #else
         goto pcsp_bind_loop;
      #endif
   }
   
	/**端口重用**/
   SetSocketRuseAddr( pcsp_socket_fd ) ;
   
pcsp_accept_loop:
   client_address_len = sizeof (struct sockaddr);
   if ((pcsp_new_socket_fd = accept (pcsp_socket_fd,
	    (struct sockaddr *)&peer_client_addr, (void *)&client_address_len)) <0)
   {
      if (errno == EINTR)
      {
         /* if interrupt by signal, program must return to do with the signal command */
	      return (FAILED_RETURN_CODE);
      }

      fprintf (stderr, "accepting client [accept:port=%d] connection failed, errno = %d\n", waiting_port, errno);
      shutdown (pcsp_new_socket_fd, 2);
      close (pcsp_new_socket_fd);
      #ifdef CONNECT_MODE_1
         return (FAILED_RETURN_CODE);
      #else
         goto pcsp_listen_loop;
      #endif
   }
   else
   {
      #ifdef DEBUG_SERVER_CONNECT
         fprintf (stderr, "accepting client [accept:port=%d] connected !!", waiting_port);
      #endif
         init_socket (pcsp_new_socket_fd);
      return (pcsp_new_socket_fd);
   }
}

/* 005 
 * 客户端connect
 */
int pcsp_client_connect (int server_listen_port, char *server_host_address)
{
   struct sockaddr_in 	server_address_buffer;
   static long		try_count=0;

   bzero ((char *)&server_address_buffer, sizeof (server_address_buffer));
   server_address_buffer.sin_family	= AF_INET;
   server_address_buffer.sin_addr.s_addr = inet_addr (server_host_address);
   server_address_buffer.sin_port	= htons (server_listen_port);
   try_count ++;

pcsp_init_socket:
   pcsp_socket_fd = socket (AF_INET, SOCK_STREAM, 0);
   if (pcsp_socket_fd < 0)
   {
      fprintf (stderr,
      "open socket[socket] for connecting to server [%s:%d] failed, errno = %d",
      server_host_address, server_listen_port, errno);
      close_socket (pcsp_socket_fd);
      return (FAILED_RETURN_CODE);
   }

pcsp_connect_loop:
   if (connect (pcsp_socket_fd, (struct sockaddr *)&server_address_buffer,
       sizeof (server_address_buffer)) < 0)
   {
      #ifdef DEBUG
         fprintf (stderr,
	          "connect[connect] to server [%s:%d] failed, errno = %d",
	          server_host_address, server_listen_port);
      #endif
      close_socket (pcsp_socket_fd);
      return (FAILED_RETURN_CODE);
   }
   else
   {
      try_count = 0;
      init_socket (pcsp_socket_fd);
      return (pcsp_socket_fd);
   }
}

/* 006 
 * 发送数据
 */
int pcsp_tcp_send (int socket_fd, char *send_buffer, int len)
{
   int	rc , i ;

   rc = write (socket_fd, send_buffer, len);
   #ifdef DEBUG
      fprintf (stdout, "send data[len=%d,rc=%d]: %s\n", len, rc, send_buffer);
   #endif
   return (rc);
}

/* 007 
 * 接收数据
 */
int pcsp_tcp_receive (int socket_fd, char *receive_buffer, int len)
{
   int	rc,i;

   rc = read (socket_fd, receive_buffer, len);
   return (rc);
}

/* 008 
 * 接收数据(等待收完指定长度的字符串）
 */
int pcsp_tcp_receive_waitall ( int socket_fd, char *receive_buffer, int len )
{
   ssize_t rc ;
   rc = recv ( socket_fd, receive_buffer, len, MSG_WAITALL ) ;
   return ( rc ) ;
}

/* 009 
 * 获得客户端的信息
 */
char *pcsp_get_client_address (int socket_fd)
{
   unsigned long		name_length;
   struct sockaddr	socket_client_address;

   memset (&socket_client_address, 0x00, sizeof (struct sockaddr));
   name_length = sizeof (struct sockaddr);
   if (getpeername (socket_fd, &socket_client_address, &name_length) < 0)
   {
      return (NULL);
   }

   memset (client_ip_address, 0x00, 16);
   sprintf (client_ip_address, "%d.%d.%d.%d",
	    socket_client_address.sa_data[2], socket_client_address.sa_data[3],
	    socket_client_address.sa_data[4], socket_client_address.sa_data[5]);
   return ((char *) client_ip_address);
}

/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/
/***                 上面的函数主要是在PCSP AIX 下用的                       ***/
/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/
/*******************************************************************************/

/* 010
 * Function Name  : readn                                            
 * Description    : 从socket中读指定个字符                           
 * Input Para     : fd       socket标识符                            
 *                  n        要读取的字符数                          
 * Output Para    : vptr     从socket中读出的字符                    
 * Return Code    : >0 读回的字节数                                  
 *                  -2 超时                                          
 *                  -1 其他错误                                      
 * Note           :                                                  
 */
int readn ( fd , vptr , n ) 
int  fd ;
void *vptr ;
unsigned int n ;
{
   int  nleft ;
   int  nread ;
   char *ptr ;

   ptr = vptr ;
   nleft = n ;
   while ( nleft > 0 ) 
   {
      nread = read ( fd , ptr , nleft ) ;
      
#ifdef DEBUG
      printf ( "nread=%d\n"  , nread ) ;
#endif

      if ( nread < 0 ) 
      {
	      if ( errno == EINTR )
	      {
	         errno = ETIMEDOUT ;
	         perror ( "read" ) ;
	         return ( -2 ) ;                   /*  time out */
         }
         else
	      {
	         perror ( "read" ) ;
	         return ( -1 ) ;
         }
      } 
      else if ( nread == 0 )
	      break ;

      nleft -= nread ;
      ptr += nread ;
   }
   
#ifdef DEBUG
      printf ( "in readn read=[%s]\n"  , ptr ) ;
#endif

   return ( n - nleft ) ;
}

/* 011
 * Function Name  : writen                                           
 * Description    : 写socket中写指定个字符                           
 * Input Para     : fd       socket标识符                            
 *                  n        要写入的字符数                          
 * Output Para    : vptr     写如socket的字符                        
 * Return Code    : >0 读回的字节数                                  
 *                  -2 超时                                          
 *                  -1 其他错误                                      
 * Note           :                                                  
 */
int writen ( fd , vptr , n )
int  fd ;
void *vptr ;
int  n ;
{
   int  nleft ;
   int  nwritten ;
   char *ptr ;

   ptr = vptr ;
   nleft = n ;

#ifdef DEBUG
   printf ( "in writen ptr=[%s]\n"  , ptr ) ;
#endif

   while ( nleft > 0 )
   {
      if ( ( nwritten = write ( fd , ptr , nleft ) ) <= 0 )
      {
	 if ( errno == EINTR )
	 {
	    errno = ETIMEDOUT ;
	    perror ( "write" ) ;
	    return ( -2 ) ;
         }
	 else
	 {
	    perror ( "write" ) ;
	    return ( -1 ) ;
         }
      }
      nleft -= nwritten ;
      ptr += nwritten ;
   }
   
#ifdef DEBUG
   printf ( "nwrite=%d\n"  , nwritten ) ;
#endif

   return ( n ) ;
}

/* 012
 *创建socket 
 */
int  CreateSocket ( )
{
   int fd ;

   if ( ( fd = socket ( AF_INET , SOCK_STREAM , 0 ) ) < 0 )
   {
   	perror ( "socket" ) ;
   	return ( ERROR ) ;
   }	
   return ( fd ) ;
}

/*013 
 *绑定端口 0-正 -1-负 
 */
int BindIP ( int sockfd , char *ip , char *port )
{
   struct sockaddr_in addr ;

   /*init*/
   bzero ( &addr , sizeof( addr ) ) ;
   
   addr.sin_family = AF_INET ;
   addr.sin_port   = htons( atoi ( port ) ) ;
   addr.sin_addr.s_addr = inet_addr( ip ) ;
   
   if ( addr.sin_addr.s_addr == INADDR_NONE )
   {
      fprintf ( stderr , "IP address is not correct!" ) ;
      return ( ERROR ) ;
   }

   if ( bind( sockfd , (struct sockaddr *)&addr, sizeof( addr ) ) < 0 )
   {
      perror ( "IP bind" ) ;
      return ( ERROR ) ;
   }
   return ( OK );
}

/*014
 *Listen端口 0-正 -1-负 
 */
int Listen ( int fd, int n )
{
   if ( listen ( fd , n ) < 0 )
   {
      perror ( "listen" ) ;
      return ( ERROR ) ;
   }
   return ( OK );
}

/*015 
 *收到客户端连接 
 */
int  Accept ( int listenfd )
{
   struct sockaddr_in addr ;
   int                connfd ;
   socklen_t          clilen ;

   clilen = sizeof ( struct sockaddr_in ) ;

   while ( 1 )
   {
      if ((connfd = accept ( listenfd, (struct sockaddr *) &addr, &clilen ))<0)
      {

		  if ( errno == EINTR )
	        continue ;
	     else
		  {
	         perror ( "accept" ) ;
	         return ( ERROR );
		  }
      }

      return ( connfd ) ;
   }
}