• 项目：UDP聊天室

    UDP

    UDP（User Datagram Protocol）是一种无连接、不可靠、面向数据报的传输协议。与TCP相比，UDP更加轻量级，不提供像TCP那样的可靠性和流控制机制，但具备较低的通信延迟和较少的开销。

    UDP具有以下几个特点：

    1. 无连接性：UDP在通信之前不需要进行握手或建立连接，可以直接向目标主机发送数据报。这使得UDP的开销较低，适用于实时数据传输或需要快速响应的应用场景。

    2. 不可靠性：UDP不保证数据报的可靠性传输，发送端一旦发送数据包就不会去确认是否到达目标主机。这意味着UDP数据包可能会在传输过程中丢失、重复、乱序，接收方需要自行处理这些问题。

    3. 面向数据报：UDP将应用层交给它的数据封装成单个数据报发送，每个数据报都是独立的。接收方以数据报为单位进行处理，不会像TCP一样存在拆包和粘包的问题。

    4. 快速：由于UDP没有连接的建立和断开过程，且不需要进行可靠性的保证，因此UDP的通信延迟较低。这使得UDP适用于需要实时性和高性能的应用，例如音视频传输、实时游戏等。

    UDP常见的应用场景包括以下几个方面：

    1. 实时数据传输：UDP适合用于实时数据传输，如音视频流、实时视频会议等。由于UDP的低延迟和快速性能，可以保证数据的及时到达，并避免了TCP的可靠性机制带来的可能的延迟。

    2. DNS（Domain Name System）：UDP常用于DNS查询，客户端通过UDP向DNS服务器发送域名解析请求，DNS服务器返回响应信息。

    3. 移动应用：UDP适合用于移动应用，如移动终端上的实时定位、实时数据传输等场景。由于UDP不需要进行连接的建立和断开，更加适应移动网络环境的不稳定性。

    需要注意的是，由于UDP不提供可靠性保证，需要在应用层面上考虑数据的可靠性和完整性，例如通过应用层协议、数据校验和重传机制等手段来确保数据的正确传输。

    要求

    利用UDP协议，实现一套聊天室软件。服务器端记录客户端的地址，客户端发送消息后，服务器群发给各个客户端软件

    问题思考：

    l 客户端会不会知道其它客户端地址？
    UDP客户端不会直接互连，所以不会获知其它客户端地址，所有客户端地址存储在服务器端。

    l 有几种消息类型？
    登录：服务器存储新的客户端的地址。把某个客户端登录的消息发给其它客户端。
    聊天：服务器只需要把某个客户端的聊天消息转发给所有其它客户端。 退出：服务器删除退出客户端的地址，并把退出消息发送给其它客户端。

    l 服务器如何存储客户端的地址？
    数据结构使用链表最为简单

    流程图

    服务器

    server.png

    客户端

    client.png

    思路：

    1.首先要实现客户端和服务器端的全双工通信，因此要用到多进程，多线程或IO多路复用，IO多路复用包括select，poll，epoll。其中epoll效率最高，支持百万级别的并发。

    三种IO多路复用特点以及流程如下

    2023-08-29T15:02:22.png

    2.服务器采用有头单向链表，存储每个客户端的IP地址，链表节点结构体如下。

    1. /* 链表结点结构体 */
    2. typedef struct node_t
    3. {
    4.     struct sockaddr_in addr;   //IP地址结构体
    5.     struct node_t *next;       //指针域
    6. }node_t;

    3.建立传送消息的结构体，结构体分为三部分，分别是消息类型，昵称和消息正文。服务器端根据判断消息类型进行不同的操作。消息结构体如下。
    / 消息对应的结构体(同一个协议) /

    1. typedef struct msg_t
    2. {
    3.     int type;       //L登录  M聊天  Q退出
    4.     char name[32];  //用户名
    5.     char text[128]; //消息正文
    6. } MSG_t;

    4.客户端运行时，首先发送链接类型信息，进行链接。链接后发送信息，根据信息内容判断是否退出。

    实现

    此项目可以使用多进程，多线程，select，poll，epoll实现，此次我会用 多线程和epoll两种方式实现。其余方法相差不大。

    多进程实现

    head.h

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16.  
    17. /* 链表结点结构体 */
    18. typedef struct node_t
    19. {
    20.     struct sockaddr_in addr;   //IP地址结构体
    21.     struct node_t *next;       //指针域
    22. }node_t;
    23.  
    24. /* 消息对应的结构体(同一个协议) */
    25. typedef struct msg_t
    26. {
    27.     int type;       //L登录  M聊天  Q退出
    28.     char name[32];  //用户名
    29.     char text[128]; //消息正文
    30. } MSG_t;
    31.  
    32.  
    33. enum type_t
    34. {
    35.   login,      //枚举后面要用逗号隔开  ---0
    36.   message,    // ---1
    37.   quit,       // ---2 
    38. };
    39. #endif
    40.

    server.c

    1. #include "head.h"
    2. struct sockaddr_in saddr, caddr;
    3. //创建链表
    4. node_t *CreateList()
    5. {
    6.     node_t *p = (node_t *)malloc(sizeof(node_t));
    7.     if (NULL == p)
    8.     {
    9.         perror("CreateList is err");
    10.         return NULL;
    11.     }
    12.     p->next = NULL;
    13.     return p;
    14. }
    15.  
    16. //客户端链接
    17. void server_link(int socked, node_t *p, MSG_t *msg)
    18. {
    19.     sprintf(msg->text, "%s连接", msg->name);
    20.     printf("%s\n", msg->text);
    21.     while (p->next)
    22.     {
    23.         p = p->next;
    24.         sendto(socked, msg, sizeof(*msg), 0, (struct sockaddr *)(&(p->addr)), sizeof(p->addr));
    25.     }
    26.     node_t *new = (node_t *)malloc(sizeof(node_t));
    27.     new->next = NULL;
    28.     new->addr=caddr;
    29.     p->next = new;
    30. }
    31.  
    32. //客户端发送正文消息
    33. void server_message(int socked, node_t *p, MSG_t *msg)
    34. {
    35.     while (p->next)
    36.     {
    37.         p = p->next;
    38.         if ((memcmp(&(p->addr), &caddr, sizeof(caddr))) == 0)
    39.             continue;
    40.         sendto(socked, msg, sizeof(*msg), 0, (struct sockaddr *)(&(p->addr)), sizeof(p->addr));
    41.     }
    42. }
    43.  
    44. //客户端退出
    45. void server_quit(int socked, node_t *p, MSG_t *msg)
    46. {
    47.     node_t *pdel = NULL;
    48.     sprintf(msg->text, "%s退出", msg->name);
    49.     printf("%s\n", msg->text);
    50.     while (p->next)
    51.     {
    52.         if ((memcmp(&(p->next->addr), &caddr, sizeof(caddr))) == 0)
    53.         {
    54.             pdel = p->next;
    55.             p->next = pdel->next;
    56.             free(pdel);
    57.             pdel = NULL;
    58.         }
    59.         else
    60.         {
    61.             p = p->next;
    62.             sendto(socked, msg, sizeof(*msg), 0, (struct sockaddr *)(&(p->addr)), sizeof(p->addr));
    63.         }
    64.     }
    65. }
    66.  
    67. //6.服务器端发送消息,所有客户端接收
    68. void *mypthread(void *socked)
    69. {
    70.     MSG_t msg;
    71.     msg.type = message;
    72.     strcpy(msg.name, "服务器");
    73.     while (1)
    74.     {
    75.  
    76.         fgets(msg.text, sizeof(msg.text), stdin);
    77.         if (msg.text[strlen(msg.text) - 1] == '\n')
    78.             msg.text[strlen(msg.text) - 1] = '\0';
    79.         sendto(*(int *)(socked), &msg, sizeof(msg), 0, (struct sockaddr *)(&saddr), sizeof(saddr));
    80.     }
    81.     pthread_exit(NULL);
    82. }
    83.  
    84. int main(int argc, char const *argv[])
    85. {
    86.     //1.建立socket套接字
    87.     int socked = socket(AF_INET, SOCK_DGRAM, 0);
    88.     if (socked < 0)
    89.     {
    90.         perror("socket is err");
    91.         return -1;
    92.     }
    93.  
    94.     //2.bind服务器端口号和ip地址
    95.     saddr.sin_family = AF_INET;
    96.     saddr.sin_port = htons(atoi(argv[1]));
    97.     saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    98.     int len = sizeof(caddr);
    99.     if ((bind(socked, (struct sockaddr *)(&saddr), sizeof(saddr))) < 0)
    100.     {
    101.         perror("bind is err");
    102.         return -1;
    103.     }
    104.  
    105.     //3.建立多进程,主进程服务器接收,一个服务器发送
    106.     pthread_t pid;
    107.     pthread_create(&pid, NULL, mypthread, &socked);
    108.     pthread_detach(pid);
    109.  
    110.     //4.主线程不断接收客户端发送的消息
    111.     node_t *p = CreateList();
    112.     MSG_t msg;
    113.     while (1)
    114.     {
    115.         if ((recvfrom(socked, &msg, sizeof(msg), 0, (struct sockaddr *)(&caddr), &len)) < 0)
    116.         {
    117.             perror("recvfrom is err");
    118.             return -1;
    119.         }
    120.  
    121.         //5.根据消息类型进行分类讨论
    122.         switch (msg.type)
    123.         {
    124.         case login:
    125.             server_link(socked, p, &msg);
    126.             break;
    127.         case message:
    128.             server_message(socked, p, &msg);
    129.             break;
    130.         case quit:
    131.             server_quit(socked, p, &msg);
    132.             break;
    133.         default:
    134.             break;
    135.         }
    136.     }
    137.     close(socked);
    138.     return 0;
    139. }

    client.c

    1. #include "head.h"
    2. struct sockaddr_in saddr, caddr;
    3. int len;
    4. //5.子线程接收客户端数据
    5. void *mypthread(void *socked)
    6. {
    7.     MSG_t msg;
    8.     while (1)
    9.     {
    10.         int temp = recvfrom(*(int *)(socked), &msg, sizeof(msg), 0, (struct sockaddr *)(&caddr), &len);
    11.         if (temp < 0)
    12.         {
    13.             perror("recvfrom err");
    14.             exit(-1);
    15.         }
    16.         else
    17.         {
    18.             printf("\t\t\t\t%s(%s)\n",msg.text,msg.name);
    19.         }
    20.     }
    21. }
    22.  
    23. int main(int argc, char const *argv[])
    24. {
    25.     //1.建立socket套接字
    26.     int socked = socket(AF_INET, SOCK_DGRAM, 0);
    27.     if (socked < 0)
    28.     {
    29.         perror("socket is err");
    30.         return -1;
    31.     }
    32.  
    33.     //2.绑定服务器ip和端口号
    34.     saddr.sin_port = htons(atoi(argv[2]));
    35.     saddr.sin_addr.s_addr = inet_addr(argv[1]);
    36.     saddr.sin_family = AF_INET;
    37.     len = sizeof(caddr);
    38.  
    39.     //3.连接服务器
    40.     MSG_t msg;
    41.     msg.type = login;
    42.     printf("请输入名称:\n");
    43.     fgets(msg.name, sizeof(msg.name), stdin);
    44.     if (msg.name[strlen(msg.name) - 1] == '\n')
    45.         msg.name[strlen(msg.name) - 1] = '\0';
    46.     sendto(socked, &msg, sizeof(msg), 0, (struct sockaddr *)(&saddr), sizeof(saddr));
    47.  
    48.     //4.创建子进程接收服务器数据,主进程发送数据
    49.     pthread_t pid;
    50.     pthread_create(&pid, NULL, mypthread, &socked);
    51.     pthread_detach(pid);
    52.  
    53.     //5.主线程发送客户端数据
    54.     while (1)
    55.     {
    56.         fgets(msg.text, sizeof(msg.text), stdin);
    57.         if (msg.text[strlen(msg.text) - 1] == '\n')
    58.             msg.text[strlen(msg.text) - 1] = '\0';
    59.         if (strcmp(msg.text, "quit") == 0)
    60.             msg.type = quit;
    61.         else
    62.             msg.type = message;
    63.         sendto(socked, &msg, sizeof(msg), 0, (struct sockaddr *)(&saddr), sizeof(saddr));
    64.     }
    65.     close(socked);
    66.     return 0;
    67. }

    Makefile

    1. all:
    2.     gcc client.c -o client -lpthread
    3.     gcc server.c -o server -lpthread
    4. .PHONY:clean
    5. clean:
    6.     rm *.o

    epoll实现

    head.h

    1. #ifndef __HEAD_H__
    2. #define __HEAD_H__
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17.  
    18. /* 链表结点结构体 */
    19. typedef struct node_t
    20. {
    21.     struct sockaddr_in addr;   //IP地址结构体
    22.     struct node_t *next;       //指针域
    23. }node_t;
    24.  
    25. /* 消息对应的结构体(同一个协议) */
    26. typedef struct msg_t
    27. {
    28.     int type;       //L登录  M聊天  Q退出
    29.     char name[32];  //用户名
    30.     char text[128]; //消息正文
    31. } MSG_t;
    32.  
    33.  
    34. enum type_t
    35. {
    36.   login,      //枚举后面要用逗号隔开  ---0
    37.   message,    // ---1
    38.   quit,       // ---2 
    39. };
    40. #endif

    server.c

    1. #include "head.h"
    2. struct sockaddr_in saddr, caddr;
    3. //创建链表
    4. node_t *CreateList()
    5. {
    6.     node_t *p = (node_t *)malloc(sizeof(node_t));
    7.     if (NULL == p)
    8.     {
    9.         perror("CreateList is err");
    10.         return NULL;
    11.     }
    12.     p->next = NULL;
    13.     return p;
    14. }
    15.  
    16. //客户端链接
    17. void server_link(int socked, node_t *p, MSG_t *msg)
    18. {
    19.     sprintf(msg->text, "%s连接", msg->name);
    20.     printf("%s\n", msg->text);
    21.     while (p->next)
    22.     {
    23.         p = p->next;
    24.         sendto(socked, msg, sizeof(*msg), 0, (struct sockaddr *)(&(p->addr)), sizeof(p->addr));
    25.     }
    26.     node_t *new = (node_t *)malloc(sizeof(node_t));
    27.     new->next = NULL;
    28.     new->addr = caddr;
    29.     p->next = new;
    30. }
    31.  
    32. //客户端发送正文消息
    33. void server_message(int socked, node_t *p, MSG_t *msg)
    34. {
    35.     while (p->next)
    36.     {
    37.         p = p->next;
    38.         if ((memcmp(&(p->addr), &caddr, sizeof(caddr))) == 0)
    39.             continue;
    40.         sendto(socked, msg, sizeof(*msg), 0, (struct sockaddr *)(&(p->addr)), sizeof(p->addr));
    41.     }
    42. }
    43.  
    44. //客户端退出
    45. void server_quit(int socked, node_t *p, MSG_t *msg)
    46. {
    47.     node_t *pdel = NULL;
    48.     sprintf(msg->text, "%s退出", msg->name);
    49.     printf("%s\n", msg->text);
    50.     while (p->next)
    51.     {
    52.         if ((memcmp(&(p->next->addr), &caddr, sizeof(caddr))) == 0)
    53.         {
    54.             pdel = p->next;
    55.             p->next = pdel->next;
    56.             free(pdel);
    57.             pdel = NULL;
    58.         }
    59.         else
    60.         {
    61.             p = p->next;
    62.             sendto(socked, msg, sizeof(*msg), 0, (struct sockaddr *)(&(p->addr)), sizeof(p->addr));
    63.         }
    64.     }
    65. }
    66.  
    67.  
    68. int main(int argc, char const *argv[])
    69. {
    70.     //1.建立socket套接字
    71.     int socked = socket(AF_INET, SOCK_DGRAM, 0);
    72.     if (socked < 0)
    73.     {
    74.         perror("socket is err");
    75.         return -1;
    76.     }
    77.  
    78.     //2.bind服务器端口号和ip地址
    79.     saddr.sin_family = AF_INET;
    80.     saddr.sin_port = htons(atoi(argv[1]));
    81.     saddr.sin_addr.s_addr = inet_addr("0.0.0.0");
    82.     int len = sizeof(caddr);
    83.     if ((bind(socked, (struct sockaddr *)(&saddr), sizeof(saddr))) < 0)
    84.     {
    85.         perror("bind is err");
    86.         return -1;
    87.     }
    88.  
    89.    
    90.     //3.主线程不断接收客户端发送的消息
    91.     node_t *p = CreateList();
    92.     MSG_t msg;
    93.  
    94.     //1).创建红黑树以及链表
    95.     //树的跟节点/树的句柄
    96.     int epfd = epoll_create(1);
    97.     //2).上树
    98.     struct epoll_event event;
    99.     struct epoll_event events[32];
    100.     event.events = EPOLLET | EPOLLIN;
    101.  
    102.     event.data.fd = 0;
    103.     epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event);
    104.  
    105.     event.data.fd = socked;
    106.     epoll_ctl(epfd, EPOLL_CTL_ADD, socked, &event);
    107.  
    108.     while (1)
    109.     {
    110.  
    111.         //3).阻塞等待文件描述符产生事件
    112.         int ret = epoll_wait(epfd, events, 32, -1);
    113.         if (ret < 0)
    114.         {
    115.             perror("epoll err");
    116.             return -1;
    117.         }
    118.         //4).根据文件描述符号,进行处理
    119.         for (int i = 0; i < ret; ++i)
    120.         {
    121.             if (events[i].data.fd == 0)
    122.             {
    123.  
    124.                 msg.type = message;
    125.                 strcpy(msg.name, "客户端");
    126.                 fgets(msg.text, sizeof(msg.text), stdin);
    127.                 if (msg.text[strlen(msg.text) - 1] == '\n')
    128.                     msg.text[strlen(msg.text) - 1] = '\0';
    129.                 sendto(*(int *)(socked), &msg, sizeof(msg), 0, (struct sockaddr *)(&saddr), sizeof(saddr));
    130.             }
    131.             else if (events[i].data.fd == socked)
    132.             {
    133.                 if ((recvfrom(socked, &msg, sizeof(msg), 0, (struct sockaddr *)(&caddr), &len)) < 0)
    134.                 {
    135.                     perror("recvfrom is err");
    136.                     return -1;
    137.                 }
    138.  
    139.                 //4.根据消息类型进行分类讨论
    140.                 switch (msg.type)
    141.                 {
    142.                 case login:
    143.                     server_link(socked, p, &msg);
    144.                     break;
    145.                 case message:
    146.                     server_message(socked, p, &msg);
    147.                     break;
    148.                 case quit:
    149.                     server_quit(socked, p, &msg);
    150.                     break;
    151.                 default:
    152.                     break;
    153.                 }
    154.             }
    155.         }
    156.     }
    157.     close(socked);
    158.     return 0;
    159. }

    client.c

    1. #include "head.h"
    2. struct sockaddr_in saddr, caddr;
    3. int len;
    4. //5.子线程接收客户端数据
    5. void *mypthread(void *socked)
    6. {
    7.     MSG_t msg;
    8.     while (1)
    9.     {
    10.         int temp = recvfrom(*(int *)(socked), &msg, sizeof(msg), 0, (struct sockaddr *)(&caddr), &len);
    11.         if (temp < 0)
    12.         {
    13.             perror("recvfrom err");
    14.             exit(-1);
    15.         }
    16.         else
    17.         {
    18.             printf("\t\t\t\t%s(%s)\n", msg.text, msg.name);
    19.         }
    20.     }
    21. }
    22.  
    23. int main(int argc, char const *argv[])
    24. {
    25.     //1.建立socket套接字
    26.     int socked = socket(AF_INET, SOCK_DGRAM, 0);
    27.     if (socked < 0)
    28.     {
    29.         perror("socket is err");
    30.         return -1;
    31.     }
    32.  
    33.     //2.绑定服务器ip和端口号
    34.     saddr.sin_port = htons(atoi(argv[2]));
    35.     saddr.sin_addr.s_addr = inet_addr(argv[1]);
    36.     saddr.sin_family = AF_INET;
    37.     len = sizeof(caddr);
    38.  
    39.     //3.连接服务器
    40.     MSG_t msg;
    41.     msg.type = login;
    42.     printf("请输入名称:\n");
    43.     fgets(msg.name, sizeof(msg.name), stdin);
    44.     if (msg.name[strlen(msg.name) - 1] == '\n')
    45.         msg.name[strlen(msg.name) - 1] = '\0';
    46.     sendto(socked, &msg, sizeof(msg), 0, (struct sockaddr *)(&saddr), sizeof(saddr));
    47.  
    48.     //4.创建子进程接收服务器数据,主进程发送数据
    49.     pthread_t pid;
    50.     pthread_create(&pid, NULL, mypthread, &socked);
    51.     pthread_detach(pid);
    52.  
    53.     //5.主线程发送客户端数据
    54.     while (1)
    55.     {
    56.         fgets(msg.text, sizeof(msg.text), stdin);
    57.         if (msg.text[strlen(msg.text) - 1] == '\n')
    58.             msg.text[strlen(msg.text) - 1] = '\0';
    59.         if (strcmp(msg.text, "quit") == 0)
    60.         {
    61.             msg.type = quit;
    62.             sendto(socked, &msg, sizeof(msg), 0, (struct sockaddr *)(&saddr), sizeof(saddr));
    63.             break;
    64.         }
    65.  
    66.         else
    67.             msg.type = message;
    68.         sendto(socked, &msg, sizeof(msg), 0, (struct sockaddr *)(&saddr), sizeof(saddr));
    69.     }
    70.  
    71.     return 0;
    72. }

    Makefile

    1. all: 
    2.     gcc client.c -o client -lpthread 
    3.     gcc server.c -o server -lpthread
    4.  .PHONY:clean 
    5.     clean: rm *.o

  • 相关阅读:
    webm格式转换成mp4？
    有刷电机的速度pid-位置pid算法
    SpringBoot统一功能处理
    Vue 父子组件传值有哪些方式
    【C++11】lambda匿名函数和包装器
    EXCEL单元格中提取部分文本
    EN 14342木地板产品—CE认证
    预告|易天光通信将亮相第24届CIOE光博会
    微信小程序游戏开发│石头剪刀布游戏（附源码）
    java字符串类的使用
  • 原文地址：https://blog.csdn.net/m0_73731708/article/details/132893004