【Linux网络#3】：Socket编程应用层UDP

1.媒介

UDP（User Datagram Protocol）是面向无毗连的不可靠数据报传输协议，其特点如下：

• 低开销 ：无需建立毗连（三次握手），直接发送数据
  
• 实时性强 ：适合音视频传输等对实时性要求高的场景
  
• 数据独立 ：每个数据报携带完备地址信息
  
• 无流量控制 ：可能导致数据丢失，但服从更高
  

典范应用场景：

• DNS查询
  
• DHCP协议
  
• 多媒体流传输
  
• 在线游戏数据同步
  

2.代码框架计划

项目结构

1. udp_project/
2. ├── include/
3. │   ├── UdpServer.hpp     // 服务器核心类
4. │   ├── Common.hpp        // 公共定义
5. │   └── Log.hpp           // 日志系统
6. ├── src/
7. │   ├── UdpServerMain.cc  // 服务器入口
8. │   └── UdpClientMain.cc  // 客户端入口
9. └── Makefile              // 编译脚本

复制代码

3.基本实现 - EchoServer

UdpServer.hpp 核心实现

1. class UdpServer
2. {
3. public:
4.     UdpServer(const std::string &ip = gdefaultip, uint16_t port = gdefaultport)
5.         : _sockfd(gsockfd), _ip(ip), _port(port), _isrunning(false) {}
7.     void InitServer()
8.     {
9.         // 创建套接字
10.         _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
11.         if (_sockfd < 0) {
12.             LOG(FATAL) << "Socket creation failed: " << strerror(errno);
13.             Die(SOCKET_ERR);
14.         }
15.         LOG(INFO) << "Socket created successfully, FD: " << _sockfd;
17.         // 绑定地址
18.         sockaddr_in local;
19.         bzero(&local, sizeof(local));
20.         local.sin_family = AF_INET;
21.         local.sin_port = htons(_port);
22.         local.sin_addr.s_addr = inet_addr(_ip.c_str());
24.         if (bind(_sockfd, CONV(&local), sizeof(local)) < 0) {
25.             LOG(FATAL) << "Binding failed: " << strerror(errno);
26.             Die(BIND_ERR);
27.         }
28.         LOG(INFO) << "Binding successful";
29.     }
31.     void Start()
32.     {
33.         _isrunning = true;
34.         while (true) {
35.             char inbuffer[1024];
36.             sockaddr_in peer;
37.             socklen_t len = sizeof(peer);
38.             
39.             // 接收数据
40.             ssize_t n = recvfrom(_sockfd, inbuffer, sizeof(inbuffer)-1, 0,
41.                                 CONV(&peer), &len);
42.             if (n > 0) {
43.                 inbuffer[n] = '\0';
44.                 LOG(DEBUG) << "Client says: " << inbuffer;
45.                
46.                 // 构建响应
47.                 std::string response = "Echo from server: ";
48.                 response += inbuffer;
49.                
50.                 // 发送响应
51.                 sendto(_sockfd, response.c_str(), response.size(), 0,
52.                       CONV(&peer), sizeof(peer));
53.             }
54.         }
55.     }
57. private:
58.     int _sockfd;
59.     uint16_t _port;
60.     std::string _ip;
61.     bool _isrunning;
62. };

复制代码

代码片断分析

InitServer() 方法详解

1. void InitServer()
2. {
3.     // 1. 创建套接字
4.     _sockfd = ::socket(AF_INET, SOCK_DGRAM, 0);
5.     if(_sockfd < 0) {
6.         // 错误处理：使用日志系统记录错误信息
7.         LOG(LogLevel::FATAL) << "socket: " << strerror(errno);
8.         Die(SOCKET_ERR);
9.     }
10.    
11.     // 2. 填充地址结构
12.     struct sockaddr_in local;
13.     bzero(&local, sizeof(local)); // 清空结构体
14.     local.sin_family = AF_INET;  // IPv4协议
15.     local.sin_port = htons(_port); // 主机字节序转网络字节序
16.     local.sin_addr.s_addr = inet_addr(_ip.c_str()); // IP地址转换
17.    
18.     // 3. 绑定套接字
19.     int n = ::bind(_sockfd, CONV(&local), sizeof(local));
20.     if(n < 0) {
21.         LOG(LogLevel::FATAL) << "bind: " << strerror(errno);
22.         Die(BIND_ERR);
23.     }
24. }

复制代码

关键点分析：

• socket()函数 ：
  
  
  
  • AF_INET：IPv4协议族
    
  • SOCK_DGRAM：数据报套接字
    
  • protocol=0：主动选择UDP协议
    
  
  

    sockaddr_in结构体 ：

1. struct sockaddr_in {
2.     sa_family_t    sin_family; // 地址族
3.     in_port_t      sin_port;   // 端口号
4.     struct in_addr sin_addr;   // IPv4地址
5.     char           sin_zero[8]; // 填充字段
6. };

复制代码

• 地址转换函数 ：
  
  
  
  • htons()：主机字节序转网络字节序（16位）
    
  • htonl()：32位版本
    
  • inet_addr()：将点分IP转为32位网络序整数
    
  
  

Start() 方法详解

1. void Start()
2. {
3.     _isrunning = true;
4.     while(true) {
5.         char inbuffer[1024];
6.         struct sockaddr_in peer;
7.         socklen_t len = sizeof(peer);
8.         
9.         // 接收数据报
10.         ssize_t n = recvfrom(_sockfd, inbuffer, sizeof(inbuffer)-1, 0,
11.                             CONV(&peer), &len);
12.         
13.         if(n > 0) {
14.             inbuffer[n] = '\0'; // 添加字符串结束符
15.             
16.             // 构建响应数据
17.             std::string echo_string = "echo# ";
18.             echo_string += inbuffer;
19.             
20.             // 发送响应
21.             sendto(_sockfd, echo_string.c_str(), echo_string.size(), 0,
22.                   CONV(&peer), sizeof(peer));
23.         }
24.     }
25. }

复制代码

核心API分析：

1.recvfrom() ：

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

复制代码

• sockfd：套接字描述符
  
• buf：接收缓冲区
  
• len：缓冲区大小
  
• flags：0表现阻塞接收
  
• src_addr：对端地址信息
  
• addrlen：地址结构长度
  

2.sendto() ：

1. ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
2.               const struct sockaddr *dest_addr, socklen_t addrlen);

复制代码

• dest_addr：目标地址
  
• addrlen：地址长度
  

3.UdpClientMain.cc 客户端实现

1. #include "UdpClient.hpp"
2. #include <iostream>
3. #include <cstring>
4. #include <string>
5. #include <cstdlib>
6. #include <sys/socket.h>
7. #include <netinet/in.h>
8. #include <arpa/inet.h>
9. #include "Common.hpp"
11. int main(int argc, char *argv[])
12. {
13.     if(argc != 3) {
14.         std::cerr << "Usage: " << argv[0] << " serverIp serverPort" << std::endl;
15.         Die(USAGE_ERR);
16.     }
18.     std::string serverip = argv[1];
19.     uint16_t serverport = std::stoi(argv[2]);
21.     // 创建套接字
22.     int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
23.     if(sockfd < 0) {
24.         std::cerr << "Socket creation failed: " << strerror(errno) << std::endl;
25.         Die(SOCKET_ERR);
26.     }
28.     // 填充服务器地址
29.     sockaddr_in server;
30.     memset(&server, 0, sizeof(server));
31.     server.sin_family = AF_INET;
32.     server.sin_port = htons(serverport);
33.     server.sin_addr.s_addr = inet_addr(serverip.c_str());
35.     // 通信循环
36.     while(true) {
37.         std::cout << "Client> ";
38.         std::string message;
39.         std::getline(std::cin, message);
41.         // 发送请求
42.         sendto(sockfd, message.c_str(), message.size(), 0,
43.               CONV(&server), sizeof(server));
45.         // 接收响应
46.         char buffer[64];
47.         sockaddr_in tmp;
48.         socklen_t len = sizeof(tmp);
49.         ssize_t n = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0,
50.                             CONV(&tmp), &len);
51.         
52.         if(n > 0) {
53.             buffer[n] = '\0';
54.             std::cout << "Server> " << buffer << std::endl;
55.         }
56.     }
58.     return 0;
59. }

复制代码

注意事项

• 客户端绑定机制 ：
  
  
  
  • 不需要显式调用bind()，操纵体系会主动分配端口
    
  • 初次调用sendto()时，OS会主动完成绑定
    
  
  
• 端口选择原则 ：
  
  
  
  • 0-1023：体系端口（需root权限）
    
  • 1024-49151：注册端口
    
  • 49152-65535：动态/私有端口
    
  • 发起使用8080/8081等未被占用的端口
    
  
  

地址转换技巧 ：

1. // 字符串IP转网络序整数
2. uint32_t ip = inet_addr("192.168.1.1");
4. // 网络序整数转字符串
5. char ip_str[INET_ADDRSTRLEN];
6. inet_ntop(AF_INET, &ip, ip_str, INET_ADDRSTRLEN);

复制代码

4.UdpServer.hpp 修改 - 打印客户端信息

1. void Start()
2. {
3.     _isrunning = true;
4.     while (true) {
5.         char inbuffer[1024];
6.         sockaddr_in peer;
7.         socklen_t len = sizeof(peer);
8.         
9.         ssize_t n = recvfrom(_sockfd, inbuffer, sizeof(inbuffer)-1, 0,
10.                             CONV(&peer), &len);
11.         
12.         if (n > 0) {
13.             inbuffer[n] = '\0';
14.             
15.             // 获取客户端信息
16.             std::string client_ip = inet_ntoa(peer.sin_addr);
17.             uint16_t client_port = ntohs(peer.sin_port);
18.             
19.             LOG(DEBUG) << "Client[" << client_ip << ":" << client_port
20.                        << "] says: " << inbuffer;
21.             
22.             // 构建响应
23.             std::string response = "Echo from server: ";
24.             response += inbuffer;
25.             
26.             sendto(_sockfd, response.c_str(), response.size(), 0,
27.                   CONV(&peer), sizeof(peer));
28.         }
29.     }
30. }

复制代码

5.通讯验证（Linux-Linux）

启动服务器

1. # 编译服务器
2. g++ -o server UdpServerMain.cc -Iinclude
4. # 运行服务器
5. ./server 127.0.0.1 8080

复制代码

启动客户端

1. # 编译客户端
2. g++ -o client UdpClientMain.cc -Iinclude
4. # 运行客户端
5. ./client 127.0.0.1 8080

复制代码

交互示例

服务器端日志

1. [INFO] Socket created successfully, FD: 3
2. [INFO] Binding successful
3. [DEBUG] Client[127.0.0.1:34567] says: Hello Server
4. [DEBUG] Client[127.0.0.1:34567] says: UDP Test

复制代码

客户端交互：

1. Client> Hello Server
2. Server> Echo from server: Hello Server
4. Client> UDP Test
5. Server> Echo from server: UDP Test

复制代码

6.核心API总结

7.错误处理机制

错误码定义（Common.hpp）

1. enum ErrorType {
2.     USAGE_ERR = 1,
3.     SOCKET_ERR,
4.     BIND_ERR,
5.     // ...其他错误码
6. };

复制代码

日志体系（Log.hpp）

1. namespace LogModule {
2.     enum LogLevel {
3.         DEBUG = 0,
4.         INFO,
5.         WARNING,
6.         ERROR,
7.         FATAL
8.     };
9. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。