C++的tcp和udp例子类 2011

最新推荐文章于 2021-05-25 10:20:09 发布

西海棱镜

最新推荐文章于 2021-05-25 10:20:09 发布

阅读量984

点赞数

CC 4.0 BY-SA版权

分类专栏： linux C/C++服务端编程文章标签： C++ tcp udp server socket

本文链接：https://blog.youkuaiyun.com/zhanjianshinian/article/details/8177717

linux C/C++服务端编程专栏收录该内容

10 篇文章

订阅专栏

本文详细介绍了一个用于Linux环境下的Socket编程类实现，包括不同构造函数的使用、创建套接字、绑定监听、客户端和服务端的连接及数据收发等功能。通过错误码枚举定义确保了错误处理的一致性和明确性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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;

}