• Linux网络编程9——UDP 和 本地/网络套接字

    学习视频链接

    19-本地套接字和网络套接字比较_bilibili_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1iJ411S7UA?p=105&vd_source=0471cde1c644648fafd07b54e303c905

    目录

    一、UDP 和 TCP 的优缺点

    二、UDP 实现的 C/S 模型

    2.1 通信过程

    2.2 函数讲解

    2.3 代码

    三、本地套接字和网络套接字

    3.1 进程间通信方式 (IPC)

    3.2 本地套接字对比网络 TCP 

    一、UDP 和 TCP 的优缺点

    1、TCP 

    面向连接的，可靠数据包传输。对于不稳定的网络层，采取完全弥补的通信方式。丢包重传。

    优点：稳定 (数据流量稳定、速度稳定、顺序)

    缺点：传输速度慢。相率低。开销大

    使用场景：数据的完整型要求较高，不追求效率。大数据传输、文件传输

    2、UDP

    无连接的，不可靠的数据报传递。对于不稳定的网络层，采取完全不弥补的通信方式。默认还原网络状况

    优点：传输速度块。相率高。开销小

    缺点：不稳定 (数据流量。速度。顺序)

    使用场景：对时效性要求较高场合。稳定性其次。游戏、视频会议、视频电话。腾讯、华为、阿里--- 应用层数据校验协议， 弥补 udp 的不足

    二、UDP 实现的 C/S 模型

    2.1 通信过程

    recv() / send() 只能用于 TCP 通信。替代 read、write

    accpet()：--- Connect();  ---被舍弃

    server：

            lfd = socket(AF_INET, STREAM, 0);

            SOCK_DGRAM  ---报式协议

            bind();

            listen(); --- 可有可无

            while(1) {

                    read(cfd, buf, sizeof)  ---被替换  ---recvfrom()  ---涵盖accept传出地址结构体

                    小 -- 大

                    write():---被替换--- sendto()

            }

            close();

    client：

            connfd = socket(AF_INET, SOCK_DGRAI, 0);

            sendto(‘服务器的地址结构’, 地址结构大小)

            recvfrom()

            写到屏幕

            close();

    2.2 函数讲解

    ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);

            sockfd: lfd

            buf: 缓冲区地址

            len: 缓神区大小

            flags: 0

            src_addr: (struct sockaddr *) &addr 传出。对端地址结构

            addrlen: 传入传出

    返回值: 成功接收数据字节数。失败: -1 errn。 0: 对端关闭

    ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);

            sockfd: 套接字

            buf: 存储数据的缓冲区

            len: 数据长度

            flags: 0

            src_addr: (struct sockaddr *) &addr 传入。目标地址结构

            addrlen: 地址结构长度

    返回值：成功接收数据字节数。失败 -1 errno

    2.3 代码

    server.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. #define SERV_PORT 8000
    8.  
    9. int main(void)
    10. {
    11.     struct sockaddr_in serv_addr, clie_addr;
    12.     socklen_t clie_addr_len;
    13.     int sockfd;
    14.     char buf[BUFSIZ];
    15.     char str[INET_ADDRSTRLEN];
    16.     int i, n;
    17.  
    18.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    19.  
    20.     bzero(&serv_addr, sizeof(serv_addr));
    21.     serv_addr.sin_family = AF_INET;
    22.     serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    23.     serv_addr.sin_port = htons(SERV_PORT);
    24.     
    25.     bind(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    26.  
    27.     printf("Accepting connections ...\n");
    28.     while (1) {
    29.         clie_addr_len = sizeof(clie_addr);
    30.         n = recvfrom(sockfd, buf, BUFSIZ, 0, (struct sockaddr *)&clie_addr, &clie_addr_len);
    31.         if (n == -1) {
    32.             perror("recvfrom error");
    33.         }
    34.  
    35.         printf("received from %S at PORT %d\n", 
    36.                 inet_ntop(AF_INET, &clie_addr.sin_addr, str, sizeof(str)), 
    37.                 ntohs(clie_addr.sin_port));
    38.         
    39.         for(i = 0; i < n; i++) {
    40.             buf[i] = toupper(buf[i]);
    41.         }
    42.         
    43.         n = sendto(sockfd, buf, n, 0, (struct sockaddr *)&clie_addr, sizeof(clie_addr));
    44.         if (n == -1) {
    45.             perror("sendto error");
    46.         }
    47.     }
    48.  
    49.     close(sockfd);
    50.     
    51.     return 0;
    52. }

     client.c

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5. #include   
    6.  
    7. #define SERV_PORT 8000  
    8.  
    9. int main(int argc, char *argv[])  
    10. {  
    11.     struct sockaddr_in servaddr;  
    12.     int sockfd, n;  
    13.     char buf[BUFSIZ];  
    14.  
    15.     sockfd = socket(AF_INET, SOCK_DGRAM, 0);  
    16.  
    17.     bzero(&servaddr, sizeof(servaddr));  
    18.     servaddr.sin_family = AF_INET;  
    19.     inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);  
    20.     servaddr.sin_port = htons(SERV_PORT);  
    21.  
    22.     bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));  
    23.  
    24.     while (fgets(buf, BUFSIZ, stdin) != NULL) {  
    25.         n = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)&servaddr, sizeof(servaddr));  
    26.         if (n == -1)  
    27.             perror("sendto error");  
    28.  
    29.         n = recvfrom(sockfd, buf, BUFSIZ, 0, NULL, 0);         //NULL:不关心对端信息  
    30.         if (n == -1)  
    31.             perror("recvfrom error");  
    32.  
    33.         write(STDOUT_FILENO, buf, n);  
    34.     }  
    35.  
    36.     close(sockfd);  
    37.  
    38.     return 0;  
    39. }

    三、本地套接字和网络套接字

    3.1 进程间通信方式 (IPC)

    pipe：易用性是最强的

    fifo：没有血缘关系进程之间的通信

    mmap：没有血缘关系进程之间的通信，可以反复读取

    信号：开销最小

    本地套接字 (domain)：稳定性最好的（CS 模型）

    3.2 本地套接字对比网络 TCP 

    1、int socket(int domain, int type, int protocol);

    参数：

    domin: AF_INET 变为 AF_UNIX/AF_LOCAL

    type: SOCK_STREAM/SOCK_DGRAM 都可以

    2、地址结构 socke_in -> sockaddr_un

    struct sockaddr_in srv_addr; -> struct sockaddr_un srv_addr;

    srv_addr.sin_family = AF_INET; -> srv_adrr.sun_family = AF_UNIX;

    srv_addr.sin_port = htons(8888); -> strcpy(srv_addr.sun_path, "srv.socket")

    srv_addr.sin_addr.s_addr = hton(INADDR_ANY);

    bind(fd, (struct sockaddr *)&srv_addr, sizeof(srv_addr)); -> bind(fd, (struct sockaddr *)&srv_addr, offsetof(struct sockaddr_un, sun_path) + strlen("srv.socket"));

    sockaddr_un

    sockaddr 数据结构

    bind 函数创建出来的这个文件，是一个伪文件

    3.3 代码

    服务端

    1. #include   
    2. #include   
    3. #include   
    4. #include   
    5. #include   
    6. #include   
    7. #include   
    8. #include   
    9. #include   
    10.  
    11. #include "wrap.h"  
    12.  
    13. #define SERV_ADDR  "serv.socket"  
    14.   
    15. int main(void)  
    16. {  
    17.     int lfd, cfd, len, size, i;  
    18.     struct sockaddr_un servaddr, cliaddr;  
    19.     char buf[4096];  
    20.  
    21.     lfd = Socket(AF_UNIX, SOCK_STREAM, 0);  
    22.   
    23.     bzero(&servaddr, sizeof(servaddr));  
    24.     servaddr.sun_family = AF_UNIX;  
    25.     strcpy(servaddr.sun_path, SERV_ADDR);  
    26.  
    27.     len = offsetof(struct sockaddr_un, sun_path) + strlen(servaddr.sun_path);     /* servaddr total len */  
    28.   
    29.     unlink(SERV_ADDR);                              /* 确保bind之前serv.sock文件不存在,bind会创建该文件 */  
    30.     Bind(lfd, (struct sockaddr *)&servaddr, len);           /* 参3不能是sizeof(servaddr) */  
    31.  
    32.     Listen(lfd, 20);  
    33.  
    34.     printf("Accept ...\n");  
    35.     while (1) {  
    36.         len = sizeof(cliaddr);  //AF_UNIX大小+108B  
    37.   
    38.         cfd = Accept(lfd, (struct sockaddr *)&cliaddr, (socklen_t *)&len);  
    39.   
    40.         len -= offsetof(struct sockaddr_un, sun_path);      /* 得到文件名的长度 */  
    41.         cliaddr.sun_path[len] = '\0';                       /* 确保打印时,没有乱码出现 */  
    42.   
    43.         printf("client bind filename %s\n", cliaddr.sun_path);  
    44.  
    45.         while ((size = read(cfd, buf, sizeof(buf))) > 0) {  
    46.             for (i = 0; i < size; i++)  
    47.                 buf[i] = toupper(buf[i]);  
    48.             write(cfd, buf, size);  
    49.         }  
    50.         close(cfd);  
    51.     }  
    52.     close(lfd);  
    53.  
    54.     return 0;  
    55. }

    客户端

    1. #include   
    2. #include 
    3. #include 
    4. #include   
    5. #include   
    6. #include   
    7. #include   
    8. #include   
    9. #include   
    10. #include   
    11.  
    12. #include "wrap.h"  
    13.  
    14. #define SERV_ADDR "serv.socket"
    15. #define CLIE_ADDR "clie.socket" 
    16.   
    17. int main(void)  
    18. {  
    19.     int cfd, len;  
    20.     struct sockaddr_un servaddr, cliaddr;  
    21.     char buf[4096];  
    22.   
    23.     cfd = Socket(AF_UNIX, SOCK_STREAM, 0);  
    24.   
    25.     bzero(&cliaddr, sizeof(cliaddr));  
    26.     cliaddr.sun_family = AF_UNIX;  
    27.     strcpy(cliaddr.sun_path,CLIE_ADDR);  
    28.   
    29.     len = offsetof(struct sockaddr_un, sun_path) + strlen(cliaddr.sun_path);     /* 计算客户端地址结构有效长度 */  
    30.   
    31.     unlink(CLIE_ADDR);  
    32.     Bind(cfd, (struct sockaddr *)&cliaddr, len);                                 /* 客户端也需要bind, 不能依赖自动绑定*/  
    33.       
    34.     bzero(&servaddr, sizeof(servaddr));                                          /* 构造server 地址 */  
    35.     servaddr.sun_family = AF_UNIX;  
    36.     strcpy(servaddr.sun_path, SERV_ADDR);  
    37.   
    38.     len = offsetof(struct sockaddr_un, sun_path) + strlen(servaddr.sun_path);   /* 计算服务器端地址结构有效长度 */  
    39.   
    40.     Connect(cfd, (struct sockaddr *)&servaddr, len);  
    41.   
    42.     while (fgets(buf, sizeof(buf), stdin) != NULL) {  
    43.         write(cfd, buf, strlen(buf));  
    44.         len = read(cfd, buf, sizeof(buf));  
    45.         write(STDOUT_FILENO, buf, len);  
    46.     }
    47.       
    48.     close(cfd);
    49.  
    50.     return 0;  
    51. }

     

    3.4 总结

    对比 本地套 和 网络套

     

  • 相关阅读:
    什么是子网掩码？
    go语言 leetcod1 两数之和
    如何利用InVest模型估算区域产水量
    nginx禁用3DES和DES弱加密算法，保证SSL证书安全
    基于Unity引擎的RPG3D项目开发笔录
    Idea中flume的Interceptor的编写教程
    golang面试题：字符串转成byte数组，会发生内存拷贝吗？
    AC修炼计划（AtCoder Regular Contest 162）
    vue3源码分析——解密nextTick的实现
    Spring 源码阅读 10：自定义的 EntityResolver 是如何帮助 Spring 校验 XML 配置的
  • 原文地址：https://blog.csdn.net/HuanBianCheng27/article/details/127741483