• 网络编程套接字，Linux下实现echo服务器和客户端

    目录

    1、一些网络中的名词

    1.1 IP地址

    1.2 端口号port

    1.3  "端口号" 和 "进程ID"

    1.4 初始TCP协议

    1.5 UDP协议

    2、socket编程接口

    2.1 socket 常见API

    2.2 sockaddr结构

    3、简单的网络程序

    3.1 udp实现echo服务器和客户端

    3.1.1 echo服务器实现

    3.1.2 echo客户端实现

    3.1.3 运行结果

    3.2  tcp实现echo服务器和客户端

    3.2.1 多进程的echo服务器

    3.2.2 基于线程池tcp的echo服务器

     3.3 代码中的一些函数

    3.3.1 地址转换函数

    3.3.2 udp使用的的函数

    3.3.3 tcp使用的函数

    4、结语

    1、一些网络中的名词

    1.1 IP地址

            IP地址就和我们现实中的地址是一个概念，只不过一个在网络中定位，一个在现实中定位，

            在一台服务器往另一台服务器发送数据的时候，IP数据包的头部中，有两个IP地址，一个是源IP地址，另一个是目的IP地址，

    1.2 端口号port

    端口号(port)是传输层协议的内容.

            端口号是一个2字节16位的整数;

            端口号用来标识一个进程, 告诉操作系统, 当前的这个数据要交给哪一个进程来处理;

            IP地址 + 端口号能够标识网络上的某一台主机的某一个进程;

            一个端口号只能被一个进程占用.

    1.3  "端口号" 和 "进程ID"

            pid 表示唯一一个进程; 此处我们的端口号也是唯一表示一个进程。一个进程可以绑定多个端口号; 但是一个端口号不能被多个进程绑定。

    1.4 初始TCP协议

    传输层协议

    有连接

    可靠传输

    面向字节流

    1.5 UDP协议

    传输层协议

    无连接

    不可靠传输

    面向数据报

    网络字节序

            在计算机的内存中的多字节数据相对于内存地址有大端和小端之分, 磁盘文件中的多字节数据相对于文件中的偏移地址也有大端小端之分, 网络数据流同样有大端小端之分. 那么如何定义网络数据流的地址呢?

            发送主机通常将发送缓冲区中的数据按内存地址从低到高的顺序发出;

            接收主机把从网络上接到的字节依次保存在接收缓冲区中,也是按内存地址从低到高的顺序保存;

            因此,网络数据流的地址应这样规定:先发出的数据是低地址,后发出的数据是高地址.

            TCP/IP协议规定,网络数据流应采用大端字节序,即低地址高字节.

            不管这台主机是大端机还是小端机, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据;

            如果当前发送主机是小端, 就需要先将数据转成大端; 否则就忽略, 直接发送即可;

            为使网络程序具有可移植性,使同样的C代码在大端和小端计算机上编译后都能正常运行,可以调用以下库函数做网络字节序和主机字节序的转换。

    1. #include 
    2.  
    3. uint32_t htonl(uint32_t hostlong);
    4. uint16_t htons(uint16_t hostshort);
    5. uint32_t ntohl(uint32_t netlong);
    6. uint16_t ntohs(uint16_t netshort);

    h表示host,n表示network,l表示32位长整数,s表示16位短整数。

    例如htonl表示将32位的长整数从主机字节序转换为网络字节序,例如将IP地址转换后准备发送。

    如果主机是小端字节序,这些函数将参数做相应的大小端转换然后返回;

    如果主机是大端字节序,这些  函数不做转换,将参数原封不动地返回。

    2、socket编程接口

    2.1 socket 常见API

    1. // 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器) 
    2. int socket(int domain, int type, int protocol);
    3. // 绑定端口号 (TCP/UDP, 服务器)
    4. int bind(int socket, const struct sockaddr *address, 
    5.           socklen_t address_len);
    6. // 开始监听socket (TCP, 服务器)
    7. int listen(int socket, int backlog); 
    8. // 接收请求 (TCP, 服务器)
    9. int accept(int socket, struct sockaddr* address, 
    10.           socklen_t* address_len);
    11. // 建立连接 (TCP, 客户端)
    12. int connect(int sockfd, const struct sockaddr *addr, 
    13.           socklen_t addrlen);

    2.2 sockaddr结构

            socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4、IPv6,以及UNIX Domain Socket. 然而, 各种网络协议的地址格式并不相同.

             IPv4和IPv6的地址格式定义在netinet/in.h中,IPv4地址用sockaddr_in结构体表示,包括16位地址类型, 16位端口号和32位IP地址.

            IPv4、IPv6地址类型分别定义为常数AF_INET、AF_INET6. 这样,只要取得某种sockaddr结构体的首地址,不需要知道具体是哪种类型的sockaddr结构体,就可以根据地址类型字段确定结构体中的内容.

            socket API可以都用struct sockaddr *类型表示, 在使用的时候需要强制转化成sockaddr_in; 这样的好处是程序的通用性, 可以接收IPv4, IPv6, 以及UNIX Domain Socket各种类型的sockaddr结构体指针做为参数;

    sockaddr 结构

    1. struct sockaddr
    2.   {
    3.     __SOCKADDR_COMMON (sa_);	/* Common data: address family and length.  */
    4.     char sa_data[14];		/* Address data.  */
    5.   };

    sockaddr_in 结构

    1. struct sockaddr_in
    2.   {
    3.     __SOCKADDR_COMMON (sin_);
    4.     in_port_t sin_port;			/* Port number.  */
    5.     struct in_addr sin_addr;		/* Internet address.  */
    6.  
    7.     /* Pad to size of `struct sockaddr'.  */
    8.     unsigned char sin_zero[sizeof (struct sockaddr) -
    9. 			   __SOCKADDR_COMMON_SIZE -
    10. 			   sizeof (in_port_t) -
    11. 			   sizeof (struct in_addr)];
    12.   };

            虽然socket api的接口是sockaddr, 但是我们真正在基于IPv4编程时, 使用的数据结构是sockaddr_in; 这个结构里主要有三部分信息: 地址类型, 端口号, IP地址.

    in_addr结构

    1. struct in_addr
    2.   {
    3.     in_addr_t s_addr;
    4.   };

    in_addr用来表示一个IPv4的IP地址. 其实就是一个32位的整数;

    3、简单的网络程序

    3.1 udp实现echo服务器和客户端

    3.1.1 echo服务器实现

    1. //udp_server.hpp
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14.  
    15. class udpserver{
    16. public:
    17.     udpserver(std::string ip, int16_t port):_fd(-1), _ip(ip), _port(port),_users(0)
    18.     {}
    19.  
    20.     ~udpserver(){
    21.         if (_fd > 0) {
    22.             close(_fd);
    23.         }
    24.     }
    25.  
    26.     void initServer() {
    27.         _fd = socket(AF_INET, SOCK_DGRAM, 0);
    28.         if (_fd < 0) {
    29.             perror("注册socket失败");
    30.             exit(2);
    31.         }
    32.         struct sockaddr_in local;
    33.         memset(&local, 0, sizeof(local));
    34.         local.sin_family = AF_INET;
    35.         local.sin_port = htons(_port);
    36.         local.sin_addr.s_addr = inet_addr(_ip.c_str());
    37.  
    38.         if (bind(_fd, (struct sockaddr*)&local, sizeof(local)) < 0) {
    39.             perror("绑定失败！");
    40.             exit(3);
    41.         }
    42.         //std::cout << "绑定成功！"<< std::endl;
    43.     }
    44.  
    45.     void startServer(){
    46.  
    47.         //准备用来接收客户端发送的消息的缓冲区
    48.         char buffer[1024];
    49.         while (1) {
    50.             
    51.             //准备用来接收发送消息的客户端信息
    52.             memset(buffer, '\0', sizeof(buffer));
    53.             struct sockaddr_in peer;
    54.             memset(&peer, 0, sizeof(peer));
    55.             socklen_t len = sizeof(peer);
    56.             //接收数据，以及接收发送数据的客户端信息
    57.             //std::cout << "正在接收！" << std::endl;
    58.             ssize_t recv_size = recvfrom(_fd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&peer, &len);
    59.             
    60.             //打印客户端发送来的数据
    61.             //std::cout << "接收成功！正在打印：" << std::endl;
    62.             // if (recv_size > 0) {
    63.             //     buffer[recv_size] = 0;
    64.             //     std::string ip = inet_ntoa(peer.sin_addr);
    65.             //     int16_t port = ntohs(peer.sin_port);
    66.             //     std::cout << "[" << ip << ":" << port << "]:";
    67.             //     std::cout << buffer << std::endl;
    68.             // }
    69.             //处理数据
    70.             buffer[recv_size] = 0;
    71.             std::string massage;
    72.             massage += inet_ntoa(peer.sin_addr);
    73.             massage += ":";
    74.             massage += ntohs(peer.sin_port);
    75.  
    76.             //_users.insert(make_pair(massage, peer);
    77.             _users.insert({massage, peer});
    78.  
    79.             massage += "#";
    80.             massage += buffer;
    81.             //_users.insert(makepair(, peer);
    82.  
    83.             //回写数据
    84.             //sendto(_fd, buffer, strlen(buffer), 0, (struct sockaddr*)&peer, len);
    85.             for (auto &s : _users) {
    86.                 sendto(_fd, massage.c_str(), massage.size(),0 ,(struct sockaddr*)&(s.second), sizeof(s.second));
    87.             }
    88.         }
    89.     }
    90.  
    91. private:
    92.     int _fd;
    93.     std::string _ip;
    94.     int16_t _port;
    95.     std::unordered_mapstruct sockaddr_in> _users;
    96. };
    1. //udp_server.cpp
    2. #include "udpserver.hpp"
    3. #include 
    4.  
    5. int main(int argc, char* args[]) {
    6.  
    7.     std::string ip;
    8.     int16_t port = 0;
    9.     if (argc == 3) {
    10.         ip = args[1];
    11.         port = atoi(args[2]);
    12.     }
    13.     else if (argc == 2) {
    14.         ip = "0.0.0.0";
    15.         port = atoi(args[1]);
    16.     }
    17.     else{
    18.         perror("输入错误！");
    19.         return 1;
    20.     }
    21.  
    22.     std::unique_ptr server(new udpserver(ip,port));
    23.     server->initServer();
    24.     server->startServer();
    25.     return 0;
    26. }

    3.1.2 echo客户端实现

    1. //udp_client.cpp
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. struct sendData{
    15.     int _sock;
    16.     struct sockaddr_in *server;
    17. };
    18.  
    19. void* sending(void *arg) {
    20.     struct sendData* data = (struct sendData*)arg;
    21.     int sock = data->_sock;
    22.     struct sockaddr_in server = *(data->server);
    23.  
    24.     while (1) {
    25.         std::string massage;
    26.         std::cerr << "请输入内容：" ;
    27.         std::getline(std::cin, massage);
    28.         //发送数据
    29.         sendto(sock, massage.c_str(), massage.size(), 0, (struct sockaddr*)&server, sizeof(server));
    30.     }
    31. }
    32.  
    33. void* receive(void *arg) {
    34.     struct sendData* data = (struct sendData*)arg;
    35.     int sock = data->_sock;
    36.     char buffer[1024];
    37.     while (1) {
    38.         memset(buffer, '\0', sizeof(buffer));
    39.         struct sockaddr_in from;
    40.         socklen_t len = sizeof(from);
    41.         ssize_t recv_size = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&from, &len);
    42.         if(recv_size < 1) {
    43.             continue;
    44.         }
    45.         buffer[recv_size] = '\0';
    46.         //printf("[%s:%u]#%s\n",inet_ntoa(from.sin_addr),ntohs(from.sin_port),buffer);
    47.         std::cout << buffer << std::endl;
    48.     }
    49. }
    50.  
    51. //客户端，负责给服务端发送消息
    52. int main(int argc, char* args[]) {
    53.  
    54.     if (argc != 3) {
    55.         std::cerr << "请正确输入参数！" << std::endl;
    56.         exit(1);
    57.     }
    58.     std::string ip = args[1];
    59.     int16_t port = atoi(args[2]);
    60.  
    61.     //创建套接字
    62.     int _sock = socket(AF_INET, SOCK_DGRAM, 0);
    63.     //这里依然会绑定，但是不需要手动绑定，回自动绑定，在第一次send的时候自动绑定，  
    64.     if (_sock < 0) {
    65.         exit(2);
    66.     }
    67.  
    68.     struct sockaddr_in server;
    69.     server.sin_addr.s_addr = inet_addr(ip.c_str());
    70.     server.sin_family = AF_INET;
    71.     server.sin_port = htons(port);
    72.     socklen_t len = sizeof(server);
    73.  
    74.     sendData data;
    75.     data._sock = _sock;
    76.     data.server = &server;
    77.  
    78.     //创建线程，让线程1负责发送，线程2负责接收
    79.     pthread_t send,recv;
    80.     pthread_create(&send,nullptr,sending,(void*)&data);
    81.     pthread_create(&send,nullptr,receive,(void*)&data);
    82.  
    83.     pthread_join(send,nullptr);
    84.     pthread_join(recv,nullptr);
    85.  
    86.     close(_sock);
    87.     return 0;
    88. }

    3.1.3 运行结果

    3.2  tcp实现echo服务器和客户端

    3.2.1 多进程的echo服务器

    1.  
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. static void servise(int serviseSock, std::string userip, int16_t userport) {
    15.     char buffer[1024];
    16.     while (1) {
    17.         memset(buffer, 0, sizeof(buffer));
    18.         size_t s = read(serviseSock,buffer,sizeof(buffer));    
    19.  
    20.         if (s > 0) {
    21.             buffer[s] = '\0';
    22.             std::cout << userip.c_str() << ":" << userport << "#" << buffer << std::endl;
    23.         }
    24.         else if (s == 0) {
    25.             //表示对方关闭了连接
    26.             std::cerr << userip << ":" << userport << " shutdowm,me too!" << std::endl;
    27.             break;
    28.         }
    29.         else {
    30.             std::cerr << "read socket error," << errno << strerror(errno) << std::endl;
    31.             break;
    32.         }
    33.  
    34.         write(serviseSock, buffer, strlen(buffer));
    35.     }
    36. }
    37.  
    38.  
    39. class tcpServer{
    40. public:
    41.     tcpServer(int16_t port, std::string ip = "")
    42.     :_ip(ip),
    43.     _port(port),
    44.     _listenSock(-1)
    45.     {}
    46.     
    47.     ~tcpServer(){
    48.         if (_listenSock > 0) {
    49.             close(_listenSock);
    50.         }
    51.     }
    52.  
    53.     void initServer(){
    54.         //backlog不能太大也不能太小
    55.         static int gbacklog = 20;
    56.         //申请描述符
    57.         _listenSock = socket(AF_INET, SOCK_STREAM, 0);
    58.         if (_listenSock < 0) {
    59.             std::cerr << "注册socket失败" << std::endl;
    60.             exit(2);
    61.         }
    62.         //绑定端口号和IP地址
    63.         struct sockaddr_in local;
    64.         local.sin_family = AF_INET;
    65.         local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    66.         local.sin_port = htons(_port);
    67.  
    68.         if (bind(_listenSock, (struct sockaddr*)&local, sizeof(local)) < 0) {
    69.             std::cerr << "绑定ip和端口号失败" << std::endl;
    70.             exit(3);
    71.         }
    72.  
    73.         //设置监听状态
    74.         if (listen(_listenSock, gbacklog) < 0) {
    75.             std::cerr << "设置监听失败" << std::endl;
    76.             exit(4);
    77.         }
    78.     }
    79.  
    80.     void start() {
    81.  
    82.         //将子进程的信号改为忽略
    83.         signal(SIGCHLD, SIG_IGN);
    84.         
    85.         while (1) {
    86.  
    87.             struct sockaddr_in user;
    88.             socklen_t len = sizeof(user);
    89.             int serviseSock = accept(_listenSock, (struct sockaddr*)&user, &len);
    90.             std::string userip = inet_ntoa(user.sin_addr);
    91.             int16_t userport = ntohs(user.sin_port);
    92.             
    93.             //servise(serviseSock,userip,userport);
    94.             int pid = fork();
    95.             if (pid == 0) {
    96.                 close(_listenSock);
    97.                 servise(serviseSock,userip,userport);
    98.                 close(serviseSock);
    99.                 exit(0);
    100.             }
    101.             close(serviseSock);
    102.         }
    103.     }
    104.  
    105. private:
    106.     std::string _ip;
    107.     int16_t _port;
    108.     int _listenSock;
    109. };

            但是我们都知道，在操作系统中，进程是资源分配的基本单位，如果使用多进程的方案的话，就非常的浪费资源，所以，相比之下，使用多线程的方式回更好，我们在实现一个基于线程池的实现方式。

    3.2.2 基于线程池tcp的echo服务器

    1. //自己实现的循环队列,当中使用的锁和信号都是自己封装的，这里就不放代码了
    2. //ringqueue.hpp
    3. #include 
    4. #include 
    5. #include "sem.hpp"
    6. #include "mutex.hpp"
    7.  
    8. template<class T>
    9. class ringqueue {
    10.  
    11. public:
    12.     ringqueue(int capacity = 10)
    13.     :_ring_queue(capacity),
    14.     _start(0),
    15.     _tail(0),
    16.     _space_sem(capacity),
    17.     _data_sem(0),
    18.     _mtx()
    19.     {}
    20.  
    21.     void push(const T &in){
    22.  
    23.         _space_sem.p();
    24.         _mtx.lock();
    25.         _ring_queue[_start++] = in;
    26.         _start %= _ring_queue.size();
    27.         _data_sem.v();
    28.         _mtx.unlock();
    29.     }
    30.  
    31.     void pop(T & out){
    32.         _data_sem.p();
    33.         _mtx.lock();
    34.         out = _ring_queue[_tail++];
    35.         _tail %= _ring_queue.size();
    36.         _space_sem.v();
    37.         _mtx.unlock();
    38.     }
    39.  
    40.     ~ringqueue()
    41.     {
    42.         
    43.     }
    44.  
    45. private:
    46.     std::vector _ring_queue;
    47.     int _start;
    48.     int _tail;
    49.     sem _space_sem;
    50.     sem _data_sem;
    51.     mutex _mtx;
    52. };
    1. //单例模式的线程池
    2. //其中的线程也是自己进行封装的，不做代码展示
    3. //thread_pool.hpp
    4. #include "thread.hpp"
    5. #include "ringQueue.hpp"
    6. #include 
    7. #include 
    8.  
    9. template <class T>
    10. struct poolData
    11. {
    12.     Thread* _self;
    13.     ringqueue* _rq;
    14. };
    15.  
    16. template <class T>
    17. class Pool
    18. {
    19.  
    20. public:
    21.     static Pool* getpool(int num = 10){
    22.         if (nullptr == _pool) {
    23.             pthread_mutex_lock(&mtx);
    24.             if (nullptr == _pool) {
    25.                 _pool = new Pool(num);
    26.             }
    27.             pthread_mutex_unlock(&mtx);
    28.         }
    29.         return _pool;
    30.     }
    31.  
    32. private:
    33.     Pool(int num) 
    34.     :_consumer(num),
    35.     _rq(10)
    36.     {}
    37.     Pool(const Pool& pool) = delete;
    38.     Pool& operator=(const Pool& pool) = delete;
    39. public:
    40.     void strat()
    41.     {
    42.         poolData condata[_consumer.size()];
    43.         for (int i = 0; i < _consumer.size(); ++i) {
    44.             _consumer[i] = new Thread(i);
    45.             condata[i]._self = _consumer[i];
    46.             condata[i]._rq = &_rq;
    47.             _consumer[i]->create(consumer,&condata[i]);
    48.         }
    49.     }
    50.  
    51.     // 生产者
    52.     void pushTask(T task)
    53.     {
    54.         _rq.push(task);
    55.     }
    56.     // 消费者
    57.     static void *consumer(void *args)
    58.     {
    59.         poolData *pd = (poolData*)args;
    60.         Thread *self = pd->_self;
    61.         ringqueue *rq = pd->_rq;
    62.         std::cout << self->name() << " Successfully started!" << std::endl;
    63.         while (true) {
    64.             T t;
    65.             rq->pop(t);
    66.             (*t)();
    67.             delete t;
    68.         }
    69.     }
    70.  
    71.     ~Pool()
    72.     {
    73.         for (int i = 0; i < _consumer.size(); ++i) {
    74.             _consumer[i]->join();
    75.             delete _consumer[i];
    76.         }
    77.         
    78.     }
    79.  
    80. private:
    81.     
    82.     ringqueue _rq;
    83.     std::vector _consumer;
    84.     static pthread_mutex_t mtx;
    85.     static Pool* _pool;
    86. };
    87.  
    88. template<class T>
    89. Pool* Pool::_pool = nullptr;
    90.  
    91. template<class T>
    92. pthread_mutex_t Pool::mtx = PTHREAD_MUTEX_INITIALIZER;
    1. //tcp_server.hpp
    2. #include "thread_pool.hpp"
    3. #include "Task.hpp"
    4.  
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16.  
    17. static void servise(int serviseSock, std::string & userip, int16_t userport) {
    18.     char buffer[1024];
    19.     while (1) {
    20.         memset(buffer, 0, sizeof(buffer));
    21.         size_t s = read(serviseSock,buffer,sizeof(buffer));    
    22.         if (s > 0) {
    23.             buffer[s] = '\0';
    24.             std::cout << userip.c_str() << ":" << userport << "#" << buffer << std::endl;
    25.         }
    26.         else if (s == 0) {
    27.             //表示对方关闭了连接
    28.             std::cerr << userip << ":" << userport << " shutdowm,me too!" << std::endl;
    29.             break;
    30.         }
    31.         else {
    32.             std::cerr << "read socket error," << errno << strerror(errno) << std::endl;
    33.             break;
    34.         }
    35.  
    36.         write(serviseSock, buffer, strlen(buffer));
    37.     }
    38.     close(serviseSock);
    39. }
    40.  
    41. class tcpServer{
    42. public:
    43.     tcpServer(int16_t port, std::string ip = "")
    44.     :_ip(ip),
    45.     _port(port),
    46.     _listenSock(-1),
    47.     _pool_ptr(Pool::getpool())
    48.     {}
    49.     
    50.     ~tcpServer(){
    51.         if (_listenSock > 0) {
    52.             close(_listenSock);
    53.         }
    54.     }
    55.  
    56.     void initServer(){
    57.         //backlog不能太大也不能太小
    58.         static int gbacklog = 20;
    59.         //申请描述符
    60.         _listenSock = socket(AF_INET, SOCK_STREAM, 0);
    61.         if (_listenSock < 0) {
    62.             std::cerr << "注册socket失败" << std::endl;
    63.             exit(2);
    64.         }
    65.         //绑定端口号和IP地址
    66.         struct sockaddr_in local;
    67.         local.sin_family = AF_INET;
    68.         local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    69.         local.sin_port = htons(_port);
    70.  
    71.         if (bind(_listenSock, (struct sockaddr*)&local, sizeof(local)) < 0) {
    72.             std::cerr << "绑定ip和端口号失败" << std::endl;
    73.             exit(3);
    74.         }
    75.         //设置监听状态
    76.         if (listen(_listenSock, gbacklog) < 0) {
    77.             std::cerr << "设置监听失败" << std::endl;
    78.             exit(4);
    79.         }
    80.     }
    81.  
    82.     void start() {
    83.         _pool_ptr->strat();
    84.         while (1) {
    85.             struct sockaddr_in user;
    86.             socklen_t len = sizeof(user);
    87.             int serviseSock = accept(_listenSock, (struct sockaddr*)&user, &len);
    88.             std::string userip = inet_ntoa(user.sin_addr);
    89.             int16_t userport = ntohs(user.sin_port);
    90.             Task *task = new Task(serviseSock, userip, userport, servise);
    91.             _pool_ptr->pushTask(task);
    92.         }
    93.     }
    94.  
    95. private:
    96.     std::string _ip;
    97.     int16_t _port;
    98.     int _listenSock;
    99.     Pool* _pool_ptr;
    100. };
    1. //服务器入口，
    2. //tcp_server.cpp
    3. #include "tcp_server.hpp"
    4. #include 
    5.  
    6. int main(int argc, char* args[]) {
    7.     std::string ip;
    8.     int16_t port;
    9.     if (argc == 2) {
    10.         ip = "";
    11.         port = atoi(args[1]);
    12.     }
    13.     else if (argc == 3) {
    14.         ip = args[1];
    15.         port = atoi(args[2]);
    16.     }
    17.     else {
    18.         std::cerr << "输入错误！" << std::endl;
    19.         exit(1);
    20.     }
    21.     std::unique_ptr server(new tcpServer(port,ip));
    22.     server->initServer();
    23.     server->start();
    24.  
    25.     return 0;
    26. }

    3.2.3 运行结果

     3.3 代码中的一些函数

    3.3.1 地址转换函数

            本节基于IPv4的socket网络编程,sockaddr_in中的成员struct in_addr sin_addr表示32位  的IP 地址但是我们通常用点分十进制的字符串表示IP 地址,以下函数可以在字符串表示  和in_addr表示之间转换;

    字符串与in_addr的一些函数:

    1. #include 
    2. #include 
    3. #include 
    4.  
    5. int inet_aton(const char *cp, struct in_addr *inp);
    6. in_addr_t inet_addr(const char *cp);
    7. in_addr_t inet_network(const char *cp);
    8. char *inet_ntoa(struct in_addr in);
    9. struct in_addr inet_makeaddr(int net, int host);
    10. in_addr_t inet_lnaof(struct in_addr in);
    11. in_addr_t inet_netof(struct in_addr in);

    3.3.2 udp使用的的函数

    发送函数sendto:

    1. #include 
    2. #include 
    3.  
    4. ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
    5.                 const struct sockaddr *dest_addr, socklen_t addrlen);

    接收函数recvfrom:

    1. #include 
    2. #include 
    3.  
    4. ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
    5.                   struct sockaddr *src_addr, socklen_t *addrlen);

    3.3.3 tcp使用的函数

    发送函数

    1. #include 
    2. #include 
    3.  
    4. ssize_t send(int sockfd, const void *buf, size_t len, int flags);
    1. #include 
    2.  
    3. ssize_t write(int fd, const void *buf, size_t count);

    接收函数

    1. #include 
    2.  
    3. ssize_t read(int fd, void *buf, size_t count);
    1. #include 
    2. #include 
    3.  
    4. ssize_t recv(int sockfd, void *buf, size_t len, int flags);

    4、结语

            本文中若有错误，请私信或评论指出，谢谢！

  • 相关阅读:
    【SpringBoot】71、SpringBoot中集成多数据源+动态数据源
    VScode如何在敲代码时自动导入包
    首个ChatGPT机器人- Figure 01；李开复旗下零一万物推出Yi系列AI大模型API
    天翎知识管理系统为研究所文档管理组织创新赋能
    Rust中使用Rocket框架返回html网页，返回一个基于 Handlebars (HBS) 模板的响应
    HyperLynx（十四）高级分析技术
    一键同步chromedriver版本
    JVM Metaspace内存溢出问题
    sliver
    【模式识别大作业】
  • 原文地址：https://blog.csdn.net/weixin_59093392/article/details/132738045