+Ԧ

它对bekerly标准socket的库函数进行了简单的包装

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <unistd.h>

int s_create(int type);
void s_bind(int sockfd,short port);
void s_connect(int sockfd,char* ipaddr,short port);
void s_listen(int sockfd);
int s_accept(int sockfd);
void s_close(int fd);
int s_read(int fd,unsigned char* buffer,const int size,const long usec);
int s_write(int fd,const unsigned char* buffer,const int size,const long usec);
int s_recvd(int fd,unsigned char* buffer,const int size,
	    struct sockaddr* from,socklen_t* addrlen,const long usec);
int s_sendd(int fd,unsigned char* buffer,const int size,
	    struct sockaddr* to,socklen_t addrlen,const long usec);


int s_create(int type)
{
  int sockfd;
  if((sockfd=socket(AF_INET,type,0))<0) {
    perror("socket error!\n");
    exit(0);
  }
  return sockfd;
}

void s_bind(int sockfd,short port)
{
  struct sockaddr_in me;

  me.sin_family=AF_INET;
  me.sin_addr.s_addr=htonl(INADDR_ANY);
  me.sin_port=htons(port);
  if(bind(sockfd,(struct sockaddr*)&me,sizeof(me))<0) {
    perror("Bind error!\n");
    exit(0);
  }
}

void s_listen(int sockfd)
{
  if(listen(sockfd,5)<0) {
    perror("Listen error!\n");
    exit(0);
  }  
}

void s_connect(int sockfd,char* ipaddr,short port)
{
  struct sockaddr_in serv;
  serv.sin_family=AF_INET;
  if(inet_pton(AF_INET,ipaddr,&serv.sin_addr)<=0) {
    perror("Ip address error!\n");
    exit(0);
  }
  serv.sin_port=htons(port);
  if(connect(sockfd,(struct sockaddr*)&serv,sizeof(serv))<0) {
    perror("Connect error!\n");
    exit(0);
  }
}

int s_accept(int sockfd)
{
  int connfd;
  if((connfd=accept(sockfd,(struct sockaddr*)NULL,NULL))<0) {
    perror("Accept error!\n");
    exit(0);
  }
  return connfd;
}

void s_close(int fd)
{
  if(close(fd)<0) {
    perror("Close error!\n");
    exit(0);
  }
}

int s_recv(int fd,unsigned char* buffer,const int size,const long usec)
{
  int slt;
  int rsize;
  fd_set rset;
  struct timeval* tv=NULL;
  if(usec>=0) {
    tv=(struct timeval*)malloc(sizeof(struct timeval));
    tv->tv_sec=0;
    tv->tv_usec=usec;
  }
  FD_ZERO(&rset);
  FD_SET(fd,&rset);
  if((slt=select(fd+1,&rset,NULL,NULL,tv))<0) {
    perror("Select error in s_recv!\n");
    if(tv)
      free(tv);
    exit(0);
  }else if(slt==0) {
    perror("Recv time out!\n");
    if(tv)
      free(tv);
    return -1;
  }
  if(tv)
    free(tv);
  if((rsize=recv(fd,buffer,size,0))<0) {
    perror("Recv error!\n");
    exit(0);
  }
  return rsize;
}

int s_read(int fd,unsigned char* buffer,const int size,const long usec)
{
  int this_size;
  int recv_size=0;
  unsigned char* pos=buffer;
  do {
    this_size=s_recv(fd,pos,size-recv_size,usec);
    if(this_size<=0) break;
    recv_size+=this_size;
    pos+=this_size;
  }while(recv_size<size);
  return recv_size;
}

int s_send(int fd,const unsigned char* buffer,const int size,const long usec)
{
  int slt;
  int wsize;
  fd_set wset;
  struct timeval* tv=NULL;
  if(usec>=0) {
    tv=(struct timeval*)malloc(sizeof(struct timeval));
    tv->tv_sec=0;
    tv->tv_usec=usec;
  }
  FD_ZERO(&wset);
  FD_SET(fd,&wset);
  if((slt=select(fd+1,NULL,&wset,NULL,tv))<0) {
    perror("Select error in s_send!\n");
    if(tv)
      free(tv);
    exit(0);
  }else if(slt==0) {
    perror("Send time out!\n");
    if(tv)
      free(tv);
    return -1;
  }
  if(tv)
    free(tv);
  if((wsize=send(fd,buffer,size,0))<0) {
    perror("Send error!\n");
    exit(0);
  }
  return wsize;
}

int s_write(int fd,const unsigned char* buffer,const int size,const long usec)
{
  int this_size;
  const unsigned char* pos;
  int send_size=0;
  pos=buffer;
  do {
    this_size=s_send(fd,pos,size-send_size,usec);
    if(this_size<=0) break;
    send_size+=this_size;
    pos+=this_size;
  }while(send_size<size);
  return send_size;
}

int s_recvd(int fd,unsigned char* buffer,const int size,
	    struct sockaddr* from,socklen_t* addrlen,const long usec)
{
  int recv_size;
  int slt;
  fd_set rset;
  struct timeval* tv=NULL;
  if(usec>=0) {
    tv=(struct timeval*)malloc(sizeof(struct timeval));
    tv->tv_sec=0;
    tv->tv_usec=usec;
  }
  FD_ZERO(&rset);
  FD_SET(fd,&rset);
  if((slt=select(fd+1,&rset,NULL,NULL,tv))<0) {
    perror("Select error in s_recvd!\n");
    if(tv)
      free(tv);
    exit(0);
  }else if(slt==0) {
    perror("Receive datagram time out!\n");
    if(tv)
      free(tv);
    return -1;
  }
  if(tv)
    free(tv);
  if((recv_size=recvfrom(fd,buffer,size,0,from,addrlen))<0) {
    perror("Receive datagram error!\n");
    exit(0);
  }
  return recv_size;
}

int s_sendd(int fd,unsigned char* buffer,const int size,
	    struct sockaddr* to,socklen_t addrlen,const long usec)
{
  int send_size;
  int slt;
  fd_set wset;
  struct timeval* tv=NULL;
  if(usec>=0) {
    tv=(struct timeval*)malloc(sizeof(struct timeval));
    tv->tv_sec=0;
    tv->tv_usec=usec;
  }
  FD_ZERO(&wset);
  FD_SET(fd,&wset);
  if((slt=select(fd+1,NULL,&wset,NULL,tv))<0) {
    perror("Select error in sendd!\n");
    if(tv)
      free(tv);
    exit(0);
  }else if(slt==0) {
    perror("Send datagram time out!\n");
    if(tv)
      free(tv);
    return -1;
  }
  if(tv)
    free(tv);
  if((send_size=sendto(fd,buffer,size,0,to,addrlen))<0) {
    perror("Send datagram error!\n");
    exit(0);
  }
  return send_size;
}