• Linux 网络编程

    套接字（Socket）：

    通过网络实现跨机通信

    作用：一种文件描述符传输层的文件描述符

    整个编程中，需要着重注意htonl/htons、ntohl/ntohs、inet_addr等

    TCP的C/S实现


    循环服务器模型

    TCP服务器实现过程

    1.创建套接字：

    初始化结构体struct sockaddr_in

    2.给套接字绑定ip地址和端口号：bind函数

    #include

    3.将套接字文件描述符，从主动变为被动文件描述符（做监听准备——listen函数）

    4.accept函数：被动监听客户的连接并响应        【实现三次握手（无客户端连接，则会阻塞）】

    5.服务器调用read（recv）和write(send)函数————SIGPIPE忽略

    recv的返回值等于0的时候，证明客户端已经关闭

    6.注意事项：

            字节序转换：

    发送数据:将主机端序转为网络端序

    接收数据:将网络端序转为主机端序

    7.调用close或者shutdown关闭TCP连接

    close：

    缺点1：一次性将读写都关闭——只想关写（读），打开写（读），就实现不了

    缺点2：如果多个文件猫述符指向了同一个连接时。如果只close关闭了其中某个文件猫述符时只要其它的fd还打开着，那么连接不会被断开。直到所有的描述符都被close后才断开连接
    出现多个描述指向同一个连接的原因可能两个:
    1.通过dup方式复制出其它描述符
    2.子进程维承了这个描述符，所以子进程的描述符也指向了连接

    shutdown：

    可以全关掉

    • shutdown(套接字描述符)会关闭整个套接字的发送和接收功能，不管是否有连接建立。
    • shutdown(一个连接描述符)只会关闭与该连接相关的发送和接收功能，不会影响其他连接或套接字描述符。
    • close(套接字描述符)会完全关闭套接字描述符，释放与之相关的资源，并将描述符标记为无效。
    • close(一个连接描述符)的概念上并不存在，连接描述符通常是由套接字描述符派生出来的，因此关闭连接描述符时实际上是关闭了套接字描述符。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include  //*******//
    7. #include  //*******//
    8. #include   //*******//
    9. #include 
    10. #include 
    11. int sockfd;
    12. void my_exit(int sig)
    13. {
    14.     shutdown(sockfd, SHUT_RDWR);
    15.     close(sockfd);
    16.     printf("shutdown socket done\n");
    17.     exit(0);
    18. }
    19. void handle(int sig) // SIGPIPE的信号处理函数————以观察是否产生了SIGPIPE信号
    20. {
    21.     if (sig == SIGPIPE)
    22.     {
    23.         printf("SIGPIPE is going\n");
    24.     }
    25. }
    26.  
    27. int main(int argc, char **argv)
    28. {
    29.     signal(SIGINT, my_exit);
    30.     signal(SIGPIPE, handle);
    31.     signal(SIGPIPE, SIG_IGN);
    32.  
    33.     // 1.
    34.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    35.     if (sockfd < 0)
    36.     {
    37.         perror("socked is error");
    38.         exit(-1);
    39.     }
    40.     printf("socket success\n");
    41.  
    42.     // setsockopt函数
    43.     int i;
    44.     setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
    45.  
    46.     // 2.
    47.     struct sockaddr_in sockaddr_in1;
    48.     sockaddr_in1.sin_family = AF_INET; // IPV4
    49.     // “5555”可以用宏定义
    50.     sockaddr_in1.sin_port = htons(4443);                         // 正确的做法是使用htons函数将主机字节序转换为网络字节序————htons而非htonl因为端口号是16位
    51.     sockaddr_in1.sin_addr.s_addr = inet_addr("192.168.106.128"); //*****//
    52.     if (bind(sockfd, (struct sockaddr *)&sockaddr_in1, sizeof(sockaddr_in1)) < 0)
    53.     {
    54.         perror("bind error");
    55.         exit(-1);
    56.     }
    57.     printf("bind success\n");
    58.  
    59.     // 3.
    60.     if (listen(sockfd, 20) < 0)
    61.     {
    62.         perror("listen error");
    63.         exit(-1);
    64.     }
    65.     printf("listen success\n");
    66.  
    67.     // 4.
    68.     struct sockaddr_in addr2;
    69.     int len_addr2 = sizeof(addr2);
    70.  
    71.     while (1)
    72.     {
    73.         // 强制类型转换
    74.         int sock_fd1 = accept(sockfd, (struct sockaddr *)&addr2, &len_addr2); // 每来一个客户端的连接请求，就会生成一个描述符，只要知道这个描述符，就能通过此通信
    75.         if (sock_fd1 < 0)
    76.         {
    77.             perror("accept error");
    78.             exit(-1);
    79.         }
    80.         printf("client ip = %s ,port = %d\n", inet_ntoa(addr2.sin_addr), ntohs(addr2.sin_port)); // 1.inet_ntoa把ip地址转换为字符————2.把网络的转换为主机的
    81.  
    82.         // 5.
    83.         char buffer[1024] = {0};
    84.         int recv_t = recv(sock_fd1, buffer, sizeof(buffer) - 1, 0);
    85.         printf("recv_t : %d   ", recv_t);
    86.         if (recv_t < 0)
    87.         {
    88.             perror("recv error");
    89.             exit(-1);
    90.         }
    91.         else if (recv_t == 0) // recv的返回值为零的时候，证明客户端关闭了！
    92.         {
    93.             printf("client is closed\n");
    94.         }
    95.         else
    96.         {
    97.             printf("recv :%s\n", buffer);
    98.             while (1)
    99.             {
    100.                 memset(buffer, 0, sizeof(buffer));
    101.                 scanf("%s", buffer);
    102.  
    103.                 // int w_t = send(sock_fd1, buffer, strlen(buffer), 0);
    104.                 int w_t = send(sock_fd1, buffer, strlen(buffer), MSG_NOSIGNAL); // MSG_NOSIGNAL:表示此操作不愿被SIGPIPE信号断开；或注册信号处理函数
    105.                 if (w_t < 0)
    106.                 {
    107.                     perror("send data error");
    108.                     exit(-1);
    109.                 }
    110.             }
    111.         }
    112.         shutdown(sock_fd1, SHUT_RDWR);
    113.     }
    114.     return 0;
    115. }
    8.setsockopt函数

    主要用在服务器端：

    【当有客服端连接到服务器的时候，此时服务器端按下ctrl + c，断开连接，此时需要等待2MSL，才能再次用原来的ip和端口号新建客户端，为了去除这种等待2MSL的】

    SO_REUSEADDR允许完全重复的捆绑：当一个IP地址和端口绑定到某个套接口上时，还允许此IP地址和端口捆绑到另一个套接口上

    setsockopt(server_sockfd,SOL_SOCKET,SO_REUSEADDR,&j,sizeof(j));-CSDN博客

    9.在socket（）和bind（）调用之间，使用下列代码——防止客户端关闭时，要等2MSL的时间

    TCP客服端的实现过程

    1. client.c
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. int main(int argc, char **argv)
    14. {
    15.     if (argc != 3)
    16.     {
    17.         perror("input error");
    18.         exit(-1);
    19.     }
    20.     int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    21.     if (socket_fd < 0)
    22.     {
    23.         perror("socket error");
    24.         exit(-1);
    25.     }
    26.  
    27.     struct sockaddr_in addr_in1;
    28.     addr_in1.sin_family = AF_INET;
    29.     addr_in1.sin_addr.s_addr = inet_addr(argv[1]);
    30.     addr_in1.sin_port = htons(atoi(argv[2]));
    31.  
    32.     if (connect(socket_fd, (struct sockaddr *)&addr_in1, sizeof(addr_in1)) == 0)
    33.     {
    34.         printf("connect ok\n");
    35.     }
    36.     else
    37.     {
    38.         printf("connect error\n");
    39.     }
    40.     while (1)
    41.     {
    42.         char buffer[1024];
    43.         memset(buffer, 0, sizeof(buffer));
    44.         scanf("%s", buffer);
    45.         write(socket_fd, buffer, strlen(buffer) + 1);
    46.  
    47.         memset(buffer, 0, sizeof(buffer));
    48.         read(socket_fd, buffer, sizeof(buffer));
    49.         printf("%s", buffer);
    50.     }
    51.  
    52.     return 0;
    53. }

    UDP的C/S实现

    UDP协议没有建立连接特性，所以UDP协议没有自动记录对方IP和端口的特点，每次发
    送数据时，必须亲自指定对方的IP和端口，只有这样才能将数据发送给对方。
     

    UDP通信过程

    1.调用socket创建套接字文件

    2.bind绑定固定的ip和端口

    3.调用sendto和recvfrom函数，发送和接收数据

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. int main(int argc, char **argv)
    11. {
    12.     // if (argc != 3)
    13.     // {
    14.     //     printf("input error\n");
    15.     //     exit(-1);
    16.     // }
    17.     // 1.
    18.     int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    19.     if (sock_fd < 0)
    20.     {
    21.         perror("socket error");
    22.         exit(-1);
    23.     }
    24.     // 2.
    25.     struct sockaddr_in addr;
    26.     addr.sin_family = AF_INET;
    27.     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    28.     addr.sin_port = htons(5554);
    29.     if (bind(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    30.     {
    31.         perror("bind error");
    32.         exit(-1);
    33.     }
    34.     // 3.
    35.     struct sockaddr_in addr2;
    36.     int addr2_len = sizeof(addr2);
    37.     addr2.sin_family = AF_INET;
    38.     addr2.sin_addr.s_addr = inet_addr(argv[1]);
    39.     addr2.sin_port = htons(atoi(argv[2]));
    40.  
    41.     while (1)
    42.     {
    43.         char buffer[1024];
    44.         scanf("%s", buffer);
    45.         int ret = sendto(sock_fd, buffer, strlen(buffer) + 1,
    46.                          0, (struct sockaddr *)&addr2, addr2_len);
    47.         if (ret < 0)
    48.         {
    49.             perror("sendto error");
    50.             exit(-1);
    51.         }
    52.     }
    53.     return 0;
    54. }
    55.  
    56.  
    57. #include 
    58. #include 
    59. #include 
    60. #include 
    61. #include 
    62. #include 
    63. #include 
    64. #include 
    65. #include 
    66. int main(int argc, char **argv)
    67. {
    68.     // 1.
    69.     int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    70.     if (sock_fd < 0)
    71.     {
    72.         perror("socket error");
    73.         exit(-1);
    74.     }
    75.     // 2.
    76.     struct sockaddr_in addr;
    77.     addr.sin_family = AF_INET;
    78.     addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    79.     addr.sin_port = htons(5555);
    80.     if (bind(sock_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
    81.     {
    82.         perror("bind error");
    83.         exit(-1);
    84.     }
    85.     // 3.
    86.     struct sockaddr_in addr2;
    87.     memset(&addr2, 0, sizeof(addr2));
    88.     int addr2_len = sizeof(addr2);
    89.     char buffer[1024] = {0};
    90.     while (1)
    91.     {
    92.         int ret = recvfrom(sock_fd, buffer, sizeof(buffer),
    93.                            0, (struct sockaddr *)&addr2, &addr2_len);
    94.         if (ret < 0)
    95.         {
    96.             perror("recvfrom error");
    97.             exit(-1);
    98.         }
    99.         printf("from ip = %s ,from port = %d \n", inet_ntoa(addr2.sin_addr), ntohs(addr2.sin_port));
    100.         printf("recv message = %s \n", buffer);
    101.     }
    102.     return 0;
    103. }

    运行结果：

    广播


    一个人发,然后其它所有人都接收,这就是广播。


    广播只能在局域网内部有效，广播数据是无法越过路由器的，也就是说路由器就是广播数据的边界。 广播只能在局域网内部有效，广播数据是无法越过路由器的，也就是说路由器就是广播数据的边界。


    实现方法：

    1.广播的发数据，不需要绑定自己的IP地址

    2.ip地址写成广播地址；例如：192.168.1.255

    3.接收端的ip地址，不能设置为固定ip，要指定为htons（INADDR_ANY）

    4.接收方需要setsockopt函数，设置套接字文件可以重复绑定

       addr1.sin_addr.s_addr = htons(INADDR_ANY);//为什么是htons和htonl！！！！
    1. 广播发送：无需bind
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. int main(int argc, char **argv)
    13. {
    14.     int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    15.     if (sock_fd < 0)
    16.     {
    17.         perror("socket error");
    18.         exit(-1);
    19.     }
    20.     //*****************************************************************************//
    21.     int j = 1;
    22.     setsockopt(sock_fd, SOL_SOCKET, SO_BROADCAST, (void *)&j, sizeof(j));
    23.     //*****************************************************************************//
    24.     struct sockaddr_in addr1;
    25.     addr1.sin_family = AF_INET;
    26.     addr1.sin_addr.s_addr = inet_addr("127.0.0.255");
    27.     addr1.sin_port = htons(5555);
    28.  
    29.     while (1)
    30.     {
    31.         char buffer[1024] = {0};
    32.         scanf("%s", buffer);
    33.         sendto(sock_fd, buffer, sizeof(buffer),
    34.                0, (struct sockaddr *)&addr1, sizeof(addr1));
    35.     }
    36.     return 0;
    37. }
    38.  
    39.  
    40.  
    41. 接受广播：
    42.  
    43. #include 
    44. #include 
    45. #include 
    46. #include 
    47. #include 
    48. #include 
    49. #include 
    50. #include 
    51.  
    52. int main(int argc, char **argv)
    53. {
    54.     int sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
    55.     if (sock_fd < 0)
    56.     {
    57.         perror("socket error");
    58.         exit(-1);
    59.     }
    60.  
    61.     int j = 1;
    62.     setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &j, sizeof(j));
    63.  
    64.     struct sockaddr_in addr1;
    65.     addr1.sin_family = AF_INET;
    66.     //*****************************************************************************//
    67.     addr1.sin_addr.s_addr = htons(INADDR_ANY);//为什么是htons和htonl！！！！
    68.     //*****************************************************************************//
    69.     addr1.sin_port = htons(5555);
    70.  
    71.     int ret = bind(sock_fd, (struct sockaddr *)&addr1, sizeof(addr1));
    72.     if (ret < 0)
    73.     {
    74.         perror("bind error");
    75.         exit(-1);
    76.     }
    77.  
    78.     struct sockaddr_in addr2;
    79.     int len = sizeof(addr2);
    80.     memset(&addr2, 0, sizeof(addr2));
    81.     char buffer[1024];
    82.     while (1)
    83.     {
    84.         memset(buffer, 0, sizeof(buffer));
    85.         recvfrom(sock_fd, buffer, sizeof(buffer),
    86.                  0, (struct sockaddr *)&addr2, &len);
    87.         printf("recv %s\n", buffer);
    88.     }
    89.     return 0;
    90. }

    组播

    把一些ip设置为一个组，给这些组，发消息（后续在QT里涉及到）

  • 相关阅读:
    nacos
    ROS系列：第六章 机器人建模
    ORACLE Linux(OEL) - Primavera P6EPPM 安装及分享
    机器学习 | 模型评估和选择 各种评估指标总结——错误率精度－查准率查全率－真正例率假正例率 PR曲线ROC曲线
    从瀑布模式到水母模式：ChatGPT如何赋能软件研发全流程
    JSP校园导游查询系统myeclipse开发sql数据库bs框架java编程web网页结构
    【测试】使用卷积神经网络（CNN）中的 卷积核 对 图像进行特征提取
    Linux内核调试工具——devmem
    以业务为核心，泛微协助生产制造企业推动销售到生产一体化管理
    在python里如何实现switch函数的功能
  • 原文地址：https://blog.csdn.net/qq_58170320/article/details/133178842