devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【TCP】socket套接字——快速上手

作者：从前慢现在也慢 | 2024-04-19 13:33:35

赞

踩

【TCP】socket套接字——快速上手

前言

socket套接字的有些知识在上一篇【UDP】socket套接字带你快速上手中已经讲过了，这里就不在过多的叙述了。

初识TCP

 TCP的主要特点

  1. TCP是面向连接的传输层协议
  2. TCP提供可靠交付的服务
  3. TCP提供全双工通信
  4. TCP是面向字节流的

TCP socket API 

 socket()

  • 此函数是用来创建socket文件描述符的。创建成功则返回socket文件描述符，失败则返回-1并且设置对应的错误码
  • 第一个参数是用来指定通信域的，也就是选择用于通信的协议族的，这里用的是IPv4协议，参数指定就是AF_INET
  • 第二个参数是用来指定通信类型的。这里所用到的是TCP，所以参数指定为SOCK_STREAM，表示面向流的传输协议
  • 第三个参数暂时用不到，设置为0即可

bind() 

  • 此函数是用来将用户设置的IP地址和port端口号在内核中和当前进程强关联。成功返回0，失败返回-1并且设置对应的错误码
  • 第一个参数是你创建好的socket文件描述符
  • 第二个参数是一个struct sockaddr的结构体指针
  • 第三个参数是这个sockaddr的大小

listen() 

  • 此函数用来声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接等待状态，如果接收到更多的连接请求就忽略
  • listen成功返回0，失败返回-1并且设置对应的错误码

accept()

  • 三次握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到客户端连接上来
  • 第一个参数是创建好的socket文件描述符

  • 第二个参数是一个struct sockaddr的结构体指针

  • 第三个参数是此结构体的大小

  • 返回值为socket文件描述符

理解accept的返回值

accept中传入了一个socket文件描述符，但是它返回的依然是一个文件描述符，那么如何理解这两个文件描述符呢？

举个例子，假如你家有个饭店，刚好这时到了饭点了，你就派出了张三到饭店门口去拉客，此时来了一名顾客正好被张三拉进到店里去了，你又派出了李四服务员去服务这位顾客，并且让张三又返回到店门口继续拉客。

在上述例子中，张三就是我们传入accept中的socket文件描述符，是获取到的新连接的，而李四就是accept返回的socket文件描述符，是真正提供服务的。

 connect()

  • 在客户端中调用，用来连接服务器
  • 参数形式和bind的一致，区别在于bind传入的是自己的地址，为connect传入的是对方的地址
  • listen成功返回0，失败返回-1并且设置对应的错误码

tcp_client.cc

  1. #include <iostream>
  2. #include <string>
  3. #include <cstring>
  4. #include <cstdio>
  5. #include <unistd.h>
  6. #include <sys/socket.h>
  7. #include <sys/types.h>
  8. #include <arpa/inet.h>
  9. #include <netinet/in.h>
  10.  
  11. void Usage(std::string proc)
  12. {
  13.     std::cout << "\nUsage: " << proc << " serverIp serverPort\n"
  14.               << std::endl;
  15. }
  16.  
  17. int main(int argc, char *argv[])
  18. {
  19.     if (argc != 3)
  20.     {
  21.         Usage(argv[0]);
  22.         exit(1);
  23.     }
  24.     std::string serverip = argv[1];
  25.     uint16_t serverport = atoi(argv[2]);
  26.  
  27.     bool alive = false;
  28.     int sock = 0;
  29.     std::string line;
  30.     while (true)
  31.     {
  32.         if (!alive)
  33.         {
  34.             sock = socket(AF_INET, SOCK_STREAM, 0);
  35.             if (sock < 0)
  36.             {
  37.                 std::cerr << "socket error" << std::endl;
  38.                 exit(2);
  39.             }
  40.             struct sockaddr_in server;
  41.             memset(&server, 0, sizeof(server));
  42.             server.sin_family = AF_INET;
  43.             server.sin_port = htons(serverport);
  44.             server.sin_addr.s_addr = inet_addr(serverip.c_str());
  45.  
  46.             if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
  47.             {
  48.                 std::cerr << "connect error" << std::endl;
  49.                 exit(3);
  50.             }
  51.             alive = true;
  52.             std::cout << "connect success" << std::endl;
  53.         }
  54.         std::cout << "请输入你的内容# ";
  55.         std::getline(std::cin, line);
  56.         if (line == "quit")
  57.             break;
  58.  
  59.         ssize_t s = send(sock, line.c_str(), line.size(), 0);
  60.         if (s > 0)
  61.         {
  62.             char buffer[1024];
  63.             ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
  64.             if (s > 0)
  65.             {
  66.                 buffer[s] = 0;
  67.                 std::cout << "server 回应# " << buffer << std::endl;
  68.             }
  69.             else if (s == 0)
  70.             {
  71.                 close(sock);
  72.             }
  73.         }
  74.         else
  75.         {
  76.             close(sock);
  77.         }
  78.         alive = false;
  79.     }
  80.  
  81.     return 0;
  82. }

 tcp_server.cc

  1. #include "tcp_server.hpp"
  2. #include <memory>
  3.  
  4. static void Usage(std::string proc)
  5. {
  6.     std::cout << "\nUsage" << proc << " port\n" << std::endl;
  7. }
  8.  
  9. int main(int argc, char* argv[])
  10. {
  11.     if(argc != 2)
  12.     {
  13.         Usage(argv[0]);
  14.         exit(1);
  15.     }
  16.     uint16_t port = atoi(argv[1]);
  17.     std::unique_ptr<Tcp_Server> svr(new Tcp_Server(port));
  18.     svr->InitServer();
  19.     svr->Start();
  20.     return 0;
  21. }

 tcp_server.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <cstring>
  6. #include <strings.h>
  7. #include <assert.h>
  8. #include <unistd.h>
  9. #include <signal.h>
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  12. #include <arpa/inet.h>
  13. #include <netinet/in.h>
  14. #include <pthread.h>
  15. #include <sys/wait.h>
  16. #include "log.hpp"
  17.  
  18. static void service(int sock, const std::string &clientip, const uint16_t &clientport)
  19. {
  20.     char buffer[1024];
  21.     while (true)
  22.     {
  23.         ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
  24.         if (s > 0)
  25.         {
  26.             buffer[s] = 0;
  27.             std::cout << clientip << ":" << clientport << "# " << buffer << std::endl;
  28.         }
  29.         else if (s == 0) // 对端关闭连接
  30.         {
  31.             logMessage(NORMAL, "%s:%d shutdown, me too", clientip.c_str(), clientport);
  32.             break;
  33.         }
  34.         else
  35.         {
  36.             logMessage(ERROR, "read socket error, %d:%s", errno, strerror(errno));
  37.             break;
  38.         }
  39.         
  40.         write(sock, buffer, strlen(buffer));
  41.     }
  42.     close(sock);
  43. }
  44.  
  45. class ThreadDate
  46. {
  47. public:
  48.     int _sock;
  49.     std::string _ip;
  50.     uint16_t _port;
  51. };
  52.  
  53. class Tcp_Server
  54. {
  55. private:
  56.     const static int gbacklog = 20;
  57.     static void *threadRoutine(void *args)//必须得是static，因为不是static的话会多出一个this指针
  58.     {
  59.         pthread_detach(pthread_self());//线程分离
  60.         ThreadDate *td = static_cast<ThreadDate*> (args);
  61.         service(td->_sock, td->_ip, td->_port);
  62.         delete td;
  63.         
  64.         return nullptr;
  65.     }
  66.  
  67. public:
  68.     Tcp_Server(uint16_t port, std::string ip = "")
  69.         : _port(port), _ip(ip), listensock(-1)
  70.     {
  71.     }
  72.     ~Tcp_Server()
  73.     {
  74.     }
  75.  
  76.     void InitServer()
  77.     {
  78.         // 1.创建socket
  79.         listensock = socket(AF_INET, SOCK_STREAM, 0);
  80.         if (listensock < 0)
  81.         {
  82.             //创建socket失败
  83.             logMessage(FATAL, "create socket error, %d:%S", errno, strerror(errno));
  84.             exit(2);
  85.         }
  86.         logMessage(NORMAL, "create socket success, listensock:%d", listensock);
  87.  
  88.         // 2.bind
  89.         struct sockaddr_in local;
  90.         memset(&local, 0, sizeof local);
  91.         local.sin_family = AF_INET;
  92.         local.sin_port = htons(_port);
  93.         local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str()); //INADDR_ANY：任意IP
  94.         if (bind(listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
  95.         {
  96.             //bind失败
  97.             logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
  98.             exit(3);
  99.         }
  100.  
  101.         // 3.建立连接
  102.         if (listen(listensock, gbacklog) < 0)
  103.         {
  104.             //建立连接失败
  105.             logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
  106.             exit(4);
  107.         }
  108.  
  109.         logMessage(NORMAL, "init server success");
  110.     }
  111.  
  112.     void Start()
  113.     {
  114.         // signal(SIGCHLD, SIG_IGN);//多进程版
  115.         while (true)
  116.         {
  117.             // 4.获取连接
  118.             struct sockaddr_in src;
  119.             socklen_t len = sizeof(src);
  120.             int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
  121.             // 获取连接失败
  122.             if (servicesock < 0)
  123.             {
  124.                 logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));
  125.                 continue;
  126.             }
  127.             // 获取连接成功
  128.             uint16_t client_port = ntohs(src.sin_port);
  129.             std::string client_ip = inet_ntoa(src.sin_addr);
  130.             logMessage(NORMAL, "link success, servicesock: %d | %s : %d |\n", servicesock, client_ip.c_str(), client_port);
  131.  
  132.             // 5.开始通信
  133.             // 版本1——单进程循环版
  134.             // 缺点：一次只能处理一个客户端，处理完后才能处理下一个
  135.             // service(servicesock, client_ip, client_port);
  136.             // close(servicesock);
  137.  
  138.             //版本2.0——多进程（创建子进程）
  139.             // pid_t id = fork();
  140.             // assert(id != -1);
  141.             // if(id == 0)
  142.             // {
  143.                 //子进程
  144.                 // close(listensock);
  145.                 // service(servicesock, client_ip, client_port);
  146.                 // exit(0);
  147.             // }
  148.             //父进程
  149.             // close(servicesock);
  150.  
  151.             //版本2.1——多进程版本（孤儿进程）
  152.             // pid_t id = fork();
  153.             // assert(id != -1);
  154.             // if(id == 0)
  155.             // {
  156.                 //子进程
  157.                 // close(listensock);
  158.                 // if(fork() > 0) exit(0);//子进程退出，由操作系统领养
  159.                 //孙子进程
  160.                 // service(servicesock, client_ip, client_port);
  161.                 // exit(0);
  162.             // }
  163.             //父进程
  164.             // waitpid(id, nullptr, 0);
  165.             // close(servicesock);
  166.  
  167.             //版本3——多线程版
  168.             ThreadDate *td = new ThreadDate();
  169.             td->_sock = servicesock;
  170.             td->_ip = client_ip;
  171.             td->_port = client_port;
  172.             pthread_t tid;
  173.             pthread_create(&tid, nullptr, threadRoutine, td);
  174.         }
  175.     }
  176.  
  177. private:
  178.     uint16_t _port;
  179.     std::string _ip;
  180.     int listensock;
  181. };

完整代码链接

TCP socket：TCP Socket 

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

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

  

闽ICP备14008679号