C++的tcp和udp例子类 2011

const unsigned int MySOCKET_DEFAULT_PORT= 4096;
mylinuxsocket::mylinuxsocket()
{
 
  m_bstate_connect = false;
      address_family=AF_INET;
      socket_type=SOCK_STREAM;
      protocol_family=IPPROTO_TCP;
      port_number = MySOCKET_DEFAULT_PORT;
      mysocket = -1;
 
    socket_error = MySOCKET_NO_ERROR;
    bytes_send = 0;
    bytes_read  = 0;

}
//构造函数：指定端口，套接字类型，端口名,创建套接字
mylinuxsocket::mylinuxsocket(int port, int stype, char* strhostname)         
{
      bytes_send = 0;
    bytes_read  = 0;
  m_bstate_connect = false;
  socket_error=MySOCKET_NO_ERROR;
 
  address_family=AF_INET;
    port_number=port;
    if (stype == SOCK_STREAM)                  //判断套接字的类型
    {
          socket_type=SOCK_STREAM;
          protocol_family=IPPROTO_TCP;
    }

    else if(st==SOCK_DGRAM)     
    {
            socket_type=SOCK_DGRAM;
            protocol_family=IPPROTO_UDP;
    }
    else
    {
      socket_error = MySOCKET_SOCKETTYPE_ERROR;
    return -1;
  }

    sockaddr_sin.sin_family=address_family;

        if (strhostname)
  {
                  hostent *hostentnm = gethostbyname(strhostname);
                if (hostentnm==(struct hostent *)0){
                socket_error=MySOCKET_HOSTNAME_ERROR;
          return -1;
  }
    sockaddr_sin.sin_addr.s_addr=*((unsigned long*) hostentnm->h_addr);
    else
    sockaddr_sin.sin_addr.s_addr=INADDR_ANY;

        sockaddr_sin.sin_port=htons(port_number);
  mysocket=socket(address_family, socket_type, protocol_family);

 

}
//构造函数：指定协议家族， 地址家族，端口，套接字类型，端口名，创建套接字
mylinuxsocket::mylinuxsocket(sa_family_t af,int stype,int pro_family,
    int port,char *strhostname)
{
      bytes_send = 0;
    bytes_read  = 0;
        address_family = af;
              socket_type = stype;
          protocol_family = pro_family;
      port_number = port;
  sockaddr_sin.sin_family = address_family;
      socket_error = MySOCKET_NO_ERROR;
      m_bstate_connect = false;
  if (strhostname) {
  struct hostent *hostentnm = gethostbyname(strhostname);
  if(hostentnm==(struct hostent *) 0) {
    socket_error=MySOCKET_HOSTNAME_ERROR;
    return -1;
  }
  sockaddr_sin.sin_addr.s_addr=*((unsigned long*) hostnm->h_addr);

  }
  else
    sockaddr_sin.sin_addr.s_addr=INADDR_ANY;
  sockaddr_sin.sin_port=htons(port_number);

  Mysocket=socket(address_family, socket_type, protocol_family);

}

//创建初始化套接字函数，创建套接字
int mylinuxsocket::socket_create(void)
{
  mysocket = =socket(address_family, socket_type, protocol_family);
  if (mysocket<0)
  {
        socket_error=MySOCKET_INIT_ERROR;
        return -1;
  }
  return mysocket;

}

//服务端套接字绑定监听函数， 返回值    -1：失败                    0：成功
unsigned long mylinuxsocket::bindserver_listen(int maxconn_num)
{
 
    if(bind(mysocket,(struct sockaddr*)&sockaddr_sin, sizeof(struct sockaddr*)) == -1)
    {
      socket_error=MySOCKET_BIND_ERROR;
      return -1;
    }
    if(listen(Mysocket,maxconn_num) == -1)
    {
      socket_error=MySOCKET_LISTEN_ERROR;
      return -1;
   
    }
    return 0;

}

//客户端套接字连接函数
unsigned int mylinuxsocket::sock_connect()
{
    if(connect(mysocket,(struct sockaddr*)&sin,sizeof(sin)) == -1)
    {
      socket_error=MySOCKET_CONNECT_ERROR;
      m_bstate_connect = false;
      return -1;
   
    }
    else
    {
      m_bstate_connect = true;
      return 1;
   
    }

}

//服务端接受函数
unsigned int mylinuxsocket::sock_accept()
{
  socklen_t addr_size = (socklen_t)sizeof(remote_addrsin);
  conn_socket = accept(mysocket,(struct sockaddr*)&remote_addrsin , &addr_size);
  if(conn_socket < 0)
  {
                  socket_error = MySOCKET_ACCEPT_ERROR;
      return -1;
  }
  return conn_socket;
}

//服务端轮询监听接收操作
int mylinuxsocket::Read_Select(int maxsock,int seconds,int useconds)
{
  struct timeval timeout;
  fd_set readfds;
  FD_ZERO(&readfds);
  FD_SET(maxsock, &readfds);
  timeout.tv_sec = seconds;
  timeout.tv_usec = useconds;
  return select(maxsock+1, &readfds, 0 ,0, &timeout);
}

//TCP客户端接收函数
int mylinuxsocket::client_recv(void *buf, int bytes, int flags)
{
  bytes_read = 0;
  int num_reads = 0;
  int num_requestrecv = bytes;        //需要接收的字节数
  char *preceivebuffer = (char*)buf;
  //循环接收需要接收的字节数
  while(bytes_read < bytes){
    if((num_reads = recv(mysocket, preceivebuffer, num_requestrecv - bytes_read, flags))>0)
    {
      bytes_read += num_read;
      preceivebuffer += num_read;               
    }
    if (num_read<0){
      socket_error=MySOCKET_RECEIVE_ERROR;
      return -1;
    }
        }
  return bytes_read;

}

//TCP服务端接收函数
int mylinuxsocket::server_recv(int socket, void *buf, int bytes,int seconds,int useconds,int flags)
{
  bytes_read=0;
  int num_read = 0;
  int num_requestrecv = (int)bytes;
  char*preceivebuffer = (char*)buf;
  while(bytes_read < bytes)
  {
    if(!ReadSelect(socket, seconds,useconds)){
      socket_error=MySOCKET_REQUEST_TIMEOUT;
      return -1;
    }
    if((num_read = recv(socket, p, num_requestrecv - bytes_read, flags))>0){
      bytes_read += num_read;
      preceivebuffer += num_read;
    }
    if(num_read < 0){
      socket_error = MySOCKET_RECEIVE_ERROR;
      return -1;
    }
  }
  return bytes_read;
}

//TCP发送函数
int mylinuxsocket::sock_send(int soket,const void *buf,int bytes,int flags)
{
      bytes_send = 0;

  int num_sends = 0;
  int num_requestsend = (int)bytes;
  char *psendbuffer = (char*)buf;
  while(bytes_send < num_requestsend)
  {
    if((num_sends = send(soket, psendbuffer,  num_requestsend - bytes_send, flags))>0)
    {
      bytes_send += num_sends;
      psendbuffer += num_sends;
    }
    if(num_sends<0){
      socket_error=MySOCKET_TRANSMIT_ERROR;
      return -1;
    }
        }
  return bytes_send;
}

//服务端UDP接收函数
int mylinuxsocket::udprecvfrom(void *buf, int bytes, int seconds, int useconds,int flags)
{

  socklen_t addr_size = (socklen_t)sizeof(sockaddr_in);
  bytes_read = 0;
  int num_read = 0;
  int num_req = (int)bytes;
  char *preceivebuffer = (char *)buf;

  while(bytes_read < bytes) {
    if(!ReadSelect(mysocket, seconds, useconds)) {
      socket_error = MySOCKET_REQUEST_TIMEOUT;
      return -1;
    }
    if((num_read = recvfrom(mysocket, preceivebuffer, num_req - bytes_read, flags
      , (struct sockaddr *)remote_addrsin, &addr_size)) > 0) {
      bytes_read += num_read;
      preceivebuffer += num_read;
    }
    if(num_read < 0) {
      socket_error = MySOCKET_RECEIVE_ERROR;
      return -1;
    }
  }
  return bytes_read;

}

//客户端UDP接收函数
int mylinuxsocket::udprecvfrom(void *buf, int bytes, int flags)
{

  socklen_t addr_size = (socklen_t)sizeof(sockaddr_in);
    int num_read = 0;
  int num_req = (int)bytes;
  char *preceivebuffer = (char *)buf;
          while(bytes_read < bytes)
    {
    if((num_read = recvfrom(mysocket, preceivebuffer, num_req - bytes_read
      , flags, (struct sockaddr *)sockaddr_sin, &addr_size)) > 0)
    {
      bytes_read += num_read;
      p += num_read;
    }
      if(num_read < 0)
    {
      socket_error = MySOCKET_RECEIVE_ERROR;
      return -1;
            }

            }
    return bytes_read;

}

//udp发送函数
int mylinuxsocket::udpSendTo(void *buf, int bytes, int flags)
{

    int addr_size = (int)sizeof(sockaddr_in);
  bytes_send = 0;
  int num_moved = 0;
  int num_req = (int)bytes;
  char *pSendbuffer = (char *)buf;
    while(bytes_moved < bytes)
    {
    if((num_moved = sendto(mysocket, pSendbuffer, num_req-bytes_moved, flags
      , (const struct sockaddr *)sockaddr_sin, addr_size)) > 0)
    {
      bytes_send += num_moved;
      pSendbuffer += num_moved;
    }
        if(num_moved < 0)
        {
                    socket_error = MySOCKET_TRANSMIT_ERROR;
                  return -1;
            }

            }
      return bytes_send;
}

 

enum MySocketError{
  MySOCKET_NO_ERROR=0,
  MySOCKET_INVALID_ERROR_CODE,
  MySOCKET_ACCEPT_ERROR,
  MySOCKET_BIND_ERROR,
  MySOCKET_BUFOVER_ERROR,
  MySOCKET_CONNECT_ERROR,
  MySOCKET_FILESYSTEM_ERROR,
  MySOCKET_GETOPTION_ERROR,
  MySOCKET_HOSTNAME_ERROR,
  MySOCKET_INIT_ERROR,
  MySOCKET_LISTEN_ERROR,
  MySOCKET_PEERNAME_ERROR,
  MySOCKET_PROTOCOL_ERROR,
  MySOCKET_RECEIVE_ERROR,
  MySOCKET_REQUEST_TIMEOUT,
  MySOCKET_SERVICE_ERROR,
  MySOCKET_SETOPTION_ERROR,
  MySOCKET_SOCKNAME_ERROR,
  MySOCKET_SOCKETTYPE_ERROR,
  MySOCKET_TRANSMIT_ERROR,
};

#include"mysocket.h"
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <string.h>
#include <fcntl.h>
#include <netdb.h>

class mylinuxsocket
{
  protected:
  sa_family_t address_family;
    int socket_type;
    int port_number;
    int protocol_family;

    sockaddr_in remote_addrsin;

    sockaddr_in sockaddr_sin;
    MySocketError socket_error;
 
    int mysocket;
   

public:
  mylinuxsocket();
  virtual ~mylinuxsocket();
  mylinuxsocket(int port, int stype, char* strhostname);
  mylinuxsocket(sa_family_t af,int stype,int pro_family,
    int port,char *strhostname);

  int socket_create(void);

  unsigned long bindserver_listen(int maxconn_num);

  unsigned int sock_connect()；
  unsigned  int sock_accept();
  int Read_Select(int maxsock,int seconds,int useconds);
  int client_recv(void *buf, int bytes, int flags);
  int server_recv(int socket,void *pbuf,int bytes, int seconds,int useconds,int flags);
  int sock_send(int soket,const void *buf,int bytes,int flags);
  int udprecvfrom(void *buf, int bytes, int seconds, int useconds,int flags);
  int udprecvfrom(void *buf, int bytes, int flags);
  int udpSendTo(void *buf, int bytes, int flags);
private:
  bool m_bstate_connect;
  int conn_socket;
  int bytes_read;
  int bytes_send;

}