devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

简单的TCP网络程序·单进程(后端服务器)_tcp服务端程序

作者：小丑西瓜9 | 2024-05-17 20:08:31

赞

踩

tcp服务端程序

目录

文件1：tcpServer.cc

文件2：tcpServer.hpp

1.提出日志概念 -- 在后续完善

日志格式 -- 暂定简单的打印功能

2.创建套接字

SOCK_STREAM -- socket参数

3.bind自己的套接字

4.设置socket 为监听状态 *

新接口1：listen

函数1：initServer()

新接口2：accept *

接口1：read

接口2：write

文件描述符本质是数组下标 -- 有限

ulimit -- 查看本机可以开多少个文件描述符

函数2：serviceIO()

至此基本的功能完成 -- 测试1

准备工作

文件3：tcpClient.cc

文件4：tcpClient.hpp

函数3：initClient()

新接口3：connect *

函数4：start()

至此TCP通信的功能完成 -- 测试2

全部代码

log.hpp

makefile

tcpClient.cc

tcpClient.hpp

tcpServer.cc

tcpServer.hpp

直接代码开整

文件1：tcpServer.cc

准备阶段 -- 目前和UDP是一样的

  1. #include "tcpServer.hpp"
  2. #include <memory>
  3.  
  4. using namespace std;
  5. using namespace server;
  6.  
  7. static void Usage(string proc)
  8. {
  9.     cout << "Usage:\n\t" << proc << " local_port\n\n"; // 命令提示符
  10. }
  11.  
  12. // tcp服务器，启动和 udp server 一模一样
  13. // ./tcpserver lock_port
  14. int main(int argc, char *argv[])
  15. {
  16.     if (argc != 2)
  17.     {
  18.         Usage(argv[0]);
  19.         exit(USAGE_ERR);
  20.     }
  21.     uint16_t port = atoi(argv[1]);
  22.  
  23.     unique_ptr<TcpServer> tsvr(new TcpServer());
  24.     tsvr->initServer();
  25.     tsvr->start();
  26.      
  27.     return 0;
  28. }

文件2：tcpServer.hpp

1.提出日志概念 -- 在后续完善

日志格式 -- 暂定简单的打印功能

这个日志在后序完善TCP之后再进行修改，现在只实现简单的打印功能

2.创建套接字

SOCK_STREAM -- socket参数

3.bind自己的套接字

        这里有个细节，我们会发现当我们接受数据的时候是不需要主机转网路序列的，因为关于IO类的接口，内部都帮我们实现了这一功能，这里不帮我们做是因为我们传入的是一个结构体，系统做不到

4.设置socket 为监听状态 *

新接口1：listen

底层链接的长度+1，先不管他，在后序讲原理再讲述

函数1：initServer()

  1.         void initServer()
  2.         {
  3.             // 1. 创建socket文件套接字对象 -- 流式套接字
  4.             _sock = socket(AF_INET, SOCK_STREAM, 0); // 第三个参数默认 0
  5.             if (_sock < 0)
  6.             {
  7.                 logMessage(FATAL, "create socket error");
  8.                 exit(SOCKET_ERR);
  9.             }
  10.             logMessage(NORMAL, "create socket success");
  11.  
  12.             // 2.bind绑定自己的网路信息 -- 注意包含头文件
  13.             struct sockaddr_in local;
  14.             memset(&local, 0, sizeof(local));
  15.             local.sin_family = AF_INET;
  16.             local.sin_port = htons(_port);      // 这里有个细节，我们会发现当我们接受数据的时候是不需要主机转网路序列的，因为关于IO类的接口，内部都帮我们实现了这一功能，这里不帮我们做是因为我们传入的是一个结构体，系统做不到
  17.             local.sin_addr.s_addr = INADDR_ANY; // 接受任意ip地址
  18.             if (bind(_sock, (struct sockaddr *)&local, sizeof(local)) < 0)
  19.             {
  20.                 logMessage(FATAL, "bind socket error");
  21.                 exit(BIND_ERR);
  22.             }
  23.             logMessage(NORMAL, "bind socket success");
  24.  
  25.             // 3. 设置socket 为监听状态 -- TCP与UDP不同，它先要建立链接之后，TCP是面向链接的，后面还会有“握手”过程
  26.             if (listen(_sock, gbacklog) < 0) // 第二个参数backlog后面再填这个坑
  27.             {
  28.                 logMessage(FATAL, "listen socket error");
  29.                 exit(LISTEN_ERR);
  30.             }
  31.             logMessage(FATAL, "listen socket success");
  32.         }

注意这里是起始版本，在认识下面的一个接口的时候，需要整改

新接口2：accept *

        一个比喻：就像一家饭店的门口招呼人的张三，当张三从外边招呼人进来的时候，就向饭店里面喊人，让李四去服务客人，但是张三不会进来，又返回去在门口拉客

        因为随着客户端的不断增多，TCP服务器上可能存在多个套接字，就像饭店里面会有多个客人有多个服务员

至此我们需要把之前的_sock 修改为 _listensock

至此我们获取的sock就是一个文件操作符，可以使用文件操作类的函数进行处理，例如read之类的

接口1：read

从一个文件描述符中读取

接口2：write

文件描述符本质是数组下标 -- 有限

ulimit -- 查看本机可以开多少个文件描述符

函数2：serviceIO()

  1.         void serviceIO(int sock)
  2.         {
  3.             // 先用最简单的，读取再写回去
  4.             char buffer[1024];
  5.             while (true)
  6.             {
  7.                 ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
  8.                 if (n > 0)
  9.                 {
  10.                     // 截至目前，我们把读到的数据当作字符串
  11.                     buffer[n] = 0;
  12.                     std::cout << "recv message: " << buffer << std::endl;
  13.  
  14.                     std::string outbuffer = buffer;
  15.                     outbuffer += "server[echo]";
  16.  
  17.                     write(sock, outbuffer.c_str(), outbuffer.size()); // 在多路转接的时候再详谈write的返回值
  18.                 }
  19.                 else if(n == 0)
  20.                 {
  21.                     // 代表client退出 -- 把它想象成一个建立好的管道，客户端不写了，并且把它的文件描述符关了，读端就会像管道一样读到 0 TCP同理
  22.                     logMessage(NORMAL, "client quit, me too!");
  23.                 }
  24.             }
  25.         }

至此基本的功能完成 -- 测试1

准备工作

文件3：tcpClient.cc

调用逻辑 

  1. #include "tcpClient.hpp"
  2. #include <memory>
  3.  
  4. using namespace std;
  5.  
  6. static void Usage(string proc)
  7. {
  8.     cout << "Usage:\n\t" << proc << " serverip serverport\n\n"; // 命令提示符
  9. }
  10.  
  11. // ./tcpclient serverip serverport  调用逻辑
  12. int main(int argc, char *argv[])
  13. {
  14.     if(argc != 3)
  15.     {
  16.         Usage(argv[0]);
  17.         exit(1);
  18.     }
  19.     string serverip = argv[1];
  20.     uint16_t serverport = atoi(argv[2]);
  21.  
  22.     unique_ptr<TcpClient> tcli(new TcpClient(serverip, serverport));
  23.     tcli->initClient();
  24.     tcli->start();
  25.  
  26.     return 0;
  27. }

文件4：tcpClient.hpp

函数3：initClient()

  1.     void initClient()
  2.     {
  3.         // 1. 创建socket
  4.         _sock = socket(AF_INET, SOCK_STREAM, 0);
  5.         if (_sock < 0)
  6.         {
  7.             // 客户端也可以有日志，不过这里就不再实现了，直接打印错误
  8.             std::cout << "socket create error" << std::endl;
  9.             exit(2);
  10.         }
  11.  
  12.         // 2. tcp的客户端要不要bind？ 要的！ 但是不需要显示bind，这里的client port要让OS自定！
  13.         // 3. 要不要listen？ -- 不需要！客户端不需要建立链接
  14.         // 4. 要不要accept？ -- 不要！
  15.         // 5. 要什么？ 要发起链接！
  16.     }

新接口3：connect *

函数4：start()

  1.  void start()
  2.     {
  3.         struct sockaddr_in server;
  4.         memset(&server, 0, sizeof(server));
  5.         server.sin_family = AF_INET;
  6.         server.sin_port = htons(_serverport);
  7.         server.sin_addr.s_addr = inet_addr(_serverip.c_str());
  8.  
  9.         if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
  10.         {
  11.             std::cerr << "socket connect error" << std::endl;
  12.         }
  13.         else
  14.         {
  15.             std::string msg;
  16.             while (true)
  17.             {
  18.                 std::cout << "Enter# ";
  19.                 std::getline(std::cin, msg);
  20.                 write(_sock, msg.c_str(), msg.size());
  21.  
  22.                 char buffer[NUM];
  23.                 int n = read(_sock, buffer, sizeof(buffer) - 1);
  24.                 if (n > 0)
  25.                 {
  26.                     // 目前我们把读到的数据当成字符串， 截至目前
  27.                     buffer[n] = 0;
  28.                     std::cout << "Server回显# " << buffer << std::endl;
  29.                 }
  30.                 else
  31.                 {
  32.                     break;
  33.                 }
  34.             }
  35.         }
  36.     }

至此TCP通信的功能完成 -- 测试2

        但是至此，我们所写的不过是一个单进程版的，所以会出现下面的情况，后续需要进一步修改成为多进程形式的

全部代码

log.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5.  
  6. // 定义五种不同的信息
  7. #define DEBUG 0
  8. #define NORMAL 1
  9. #define WARNING 2
  10. #define ERROR 3     //一种不影响服务器的错误
  11. #define FATAL 4     //致命错误
  12.  
  13. void logMessage(int level, const std::string message)
  14. {
  15.     // 格式如下
  16.     // [日志等级] [时间戳/时间] [pid] [message]
  17.     // [FATAL0] [2023-06-11 16:46:07] [123] [创建套接字失败]
  18.  
  19.     // 暂定
  20.     std::cout << message << std::endl;
  21. }

makefile

  1. cc=g++
  2. .PHONY:all
  3. all:tcpserver tcpclient
  4.  
  5. tcpclient:tcpClient.cc
  6. 	$(cc) -o $@ $^ -std=c++11
  7.  
  8. tcpserver:tcpServer.cc
  9. 	$(cc) -o $@ $^ -std=c++11
  10.  
  11. .PHONY:clean
  12. clean:
  13. 	rm -f tcpserver tcpclient

tcpClient.cc

  1. #include "tcpClient.hpp"
  2. #include <memory>
  3.  
  4. using namespace std;
  5.  
  6. static void Usage(string proc)
  7. {
  8.     cout << "Usage:\n\t" << proc << " serverip serverport\n\n"; // 命令提示符
  9. }
  10.  
  11. // ./tcpclient serverip serverport  调用逻辑
  12. int main(int argc, char *argv[])
  13. {
  14.     if(argc != 3)
  15.     {
  16.         Usage(argv[0]);
  17.         exit(1);
  18.     }
  19.     string serverip = argv[1];
  20.     uint16_t serverport = atoi(argv[2]);
  21.  
  22.     unique_ptr<TcpClient> tcli(new TcpClient(serverip, serverport));
  23.     tcli->initClient();
  24.     tcli->start();
  25.  
  26.     return 0;
  27. }

tcpClient.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <sys/socket.h>
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>
  11. #include <unistd.h>
  12.  
  13. #define NUM 1024
  14.  
  15. class TcpClient
  16. {
  17. public:
  18.     TcpClient(const std::string &serverip, const uint16_t &port)
  19.         : _sock(1), _serverip(serverip), _serverport(port)
  20.     {
  21.     }
  22.     void initClient()
  23.     {
  24.         // 1. 创建socket
  25.         _sock = socket(AF_INET, SOCK_STREAM, 0);
  26.         if (_sock < 0)
  27.         {
  28.             // 客户端也可以有日志，不过这里就不再实现了，直接打印错误
  29.             std::cout << "socket create error" << std::endl;
  30.             exit(2);
  31.         }
  32.  
  33.         // 2. tcp的客户端要不要bind？ 要的！ 但是不需要显示bind，这里的client port要让OS自定！
  34.         // 3. 要不要listen？ -- 不需要！客户端不需要建立链接
  35.         // 4. 要不要accept？ -- 不要！
  36.         // 5. 要什么？ 要发起链接！
  37.     }
  38.  
  39.     void start()
  40.     {
  41.         struct sockaddr_in server;
  42.         memset(&server, 0, sizeof(server));
  43.         server.sin_family = AF_INET;
  44.         server.sin_port = htons(_serverport);
  45.         server.sin_addr.s_addr = inet_addr(_serverip.c_str());
  46.  
  47.         if (connect(_sock, (struct sockaddr *)&server, sizeof(server)) != 0)
  48.         {
  49.             std::cerr << "socket connect error" << std::endl;
  50.         }
  51.         else
  52.         {
  53.             std::string msg;
  54.             while (true)
  55.             {
  56.                 std::cout << "Enter# ";
  57.                 std::getline(std::cin, msg);
  58.                 write(_sock, msg.c_str(), msg.size());
  59.  
  60.                 char buffer[NUM];
  61.                 int n = read(_sock, buffer, sizeof(buffer) - 1);
  62.                 if (n > 0)
  63.                 {
  64.                     // 目前我们把读到的数据当成字符串， 截至目前
  65.                     buffer[n] = 0;
  66.                     std::cout << "Server回显# " << buffer << std::endl;
  67.                 }
  68.                 else
  69.                 {
  70.                     break;
  71.                 }
  72.             }
  73.         }
  74.     }
  75.     ~TcpClient()
  76.     {
  77.         if(_sock >= 0) close(_sock);    //不写也行，因为文件描述符的生命周期随进程，所以进程退了，自然也就会自动回收了
  78.     }
  79.  
  80. private:
  81.     int _sock;
  82.     std::string _serverip;
  83.     uint16_t _serverport;
  84. };

tcpServer.cc

  1. #include "tcpServer.hpp"
  2. #include <memory>
  3.  
  4. using namespace server;
  5. using namespace std;
  6.  
  7. static void Usage(string proc)
  8. {
  9.     cout << "Usage:\n\t" << proc << " local_port\n\n"; // 命令提示符
  10. }
  11.  
  12. // tcp服务器，启动上和udp server一模一样
  13. // ./tcpserver local_port
  14. int main(int argc, char *argv[])
  15. { 
  16.     if (argc != 2)
  17.     {
  18.         Usage(argv[0]);
  19.         exit(USAGE_ERR);
  20.     }
  21.     uint16_t port = atoi(argv[1]);
  22.  
  23.     unique_ptr<TcpServer> tsvr(new TcpServer(port));
  24.     tsvr->initServer();
  25.     tsvr->start();
  26.  
  27.     return 0;
  28. }

tcpServer.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <cstdlib>
  7. #include <sys/types.h>
  8. #include <sys/socket.h>
  9. #include <sys/socket.h>
  10. #include <netinet/in.h>
  11. #include <arpa/inet.h>
  12. #include <unistd.h>
  13. #include "log.hpp"
  14.  
  15. namespace server
  16. {
  17.     enum
  18.     {
  19.         USAGE_ERR = 1,
  20.         SOCKET_ERR,
  21.         BIND_ERR,
  22.         LISTEN_ERR
  23.  
  24.     };
  25.  
  26.     static const uint16_t gport = 8080;
  27.     static const int gbacklog = 5; // 10、20、50都可以，但是不要太大比如5千，5万
  28.  
  29.     class TcpServer
  30.     {
  31.     public:
  32.         TcpServer(const uint16_t &port = gport) : _listensock(-1), _port(port)
  33.         {
  34.         }
  35.         void initServer()
  36.         {
  37.             // 1. 创建socket文件套接字对象 -- 流式套接字
  38.             _listensock = socket(AF_INET, SOCK_STREAM, 0); // 第三个参数默认 0
  39.             if (_listensock < 0)
  40.             {
  41.                 logMessage(FATAL, "create socket error");
  42.                 exit(SOCKET_ERR);
  43.             }
  44.             logMessage(NORMAL, "create socket success");
  45.  
  46.             // 2.bind绑定自己的网路信息 -- 注意包含头文件
  47.             struct sockaddr_in local;
  48.             memset(&local, 0, sizeof(local));
  49.             local.sin_family = AF_INET;
  50.             local.sin_port = htons(_port);      // 这里有个细节，我们会发现当我们接受数据的时候是不需要主机转网路序列的，因为关于IO类的接口，内部都帮我们实现了这一功能，这里不帮我们做是因为我们传入的是一个结构体，系统做不到
  51.             local.sin_addr.s_addr = INADDR_ANY; // 接受任意ip地址
  52.             if (bind(_listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
  53.             {
  54.                 logMessage(FATAL, "bind socket error");
  55.                 exit(BIND_ERR);
  56.             }
  57.             logMessage(NORMAL, "bind socket success");
  58.  
  59.             // 3. 设置socket 为监听状态 -- TCP与UDP不同，它先要建立链接之后，TCP是面向链接的，后面还会有“握手”过程
  60.             if (listen(_listensock, gbacklog) < 0) // 第二个参数backlog后面再填这个坑
  61.             {
  62.                 logMessage(FATAL, "listen socket error");
  63.                 exit(LISTEN_ERR);
  64.             }
  65.             logMessage(NORMAL, "listen socket success");
  66.         }
  67.  
  68.         void start()
  69.         {
  70.             for (;;) // 一个死循环
  71.             {
  72.                 // 4. server 获取新链接
  73.                 // sock 和client 进行通信的fd
  74.                 struct sockaddr_in peer;
  75.                 socklen_t len = sizeof(peer);
  76.                 int sock = accept(_listensock, (struct sockaddr *)&peer, &len);
  77.                 if (sock < 0)
  78.                 {
  79.                     logMessage(ERROR, "accept error, next"); // 这个不影响服务器的运行，用ERROR，就像张三不会因为没有把人招呼进来就不干了
  80.                     continue;
  81.                 }
  82.                 logMessage(NORMAL, "accept a new link success");
  83.                 std::cout << "sock: " << sock << std::endl;
  84.  
  85.                 // 5. 这里就是一个sock， 未来通信我们就用这个sock， 面向字节流的，后续全部都是文件操作！
  86.                 // 我们就可以直接使用read之类的面向字节流的操作都行
  87.                 // version 1
  88.                 serviceIO(sock);
  89.                 close(sock); // 走到这里就说明客户端已经关闭
  90.                              // 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符会越来越少，因为文件描述符本质就是一个数组下标
  91.                              // 只要是数组下标就会有尽头，提供服务的上限 就等于文件描述符的上限
  92.                              // 对一个已经使用完毕的sock，我们要关闭这个sock，要不然会导致，文件描述符泄漏
  93.             }
  94.         }
  95.  
  96.         void serviceIO(int sock)
  97.         {
  98.             // 先用最简单的，读取再写回去
  99.             char buffer[1024];
  100.             while (true)
  101.             {
  102.                 ssize_t n = read(sock, buffer, sizeof(buffer) - 1);
  103.                 if (n > 0)
  104.                 {
  105.                     // 截至目前，我们把读到的数据当作字符串
  106.                     buffer[n] = 0;
  107.                     std::cout << "recv message: " << buffer << std::endl;
  108.  
  109.                     std::string outbuffer = buffer;
  110.                     outbuffer += "server[echo]";
  111.  
  112.                     write(sock, outbuffer.c_str(), outbuffer.size()); // 在多路转接的时候再详谈write的返回值
  113.                 }
  114.                 else if (n == 0)
  115.                 {
  116.                     // 代表client退出 -- 把它想象成一个建立好的管道，客户端不写了，并且把它的文件描述符关了，读端就会像管道一样读到 0 TCP同理
  117.                     logMessage(NORMAL, "client quit, me too!");
  118.                     break;
  119.                 }
  120.             }
  121.         }
  122.  
  123.         ~TcpServer() {}
  124.  
  125.     private:
  126.         int _listensock; // 修改二：改为listensock 不是用来进行数据通信的，它是用来监听链接到来，获取新链接的！
  127.         uint16_t _port;
  128.     };
  129.  
  130. } // namespace server

转下文：简单的TCP网络程序·多进程、多线程(后端服务器）_

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/585051
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号