[Linux#49][UDP] 2w字详解 | socketaddr | 常用API | 实操：实现简易Udp传输

Socket API 是一层网络编程接口，抽象了底层的网络协议，定义在 netinet/in.h 中。它适用于多种网络通信方式，如 IPv4、IPv6，以及 UNIX 域套接字（用于本地进程间通信）。通过 Socket API，程序可以实现跨网络的进程间通信（如通过IP地址和端口号进行的网络通信），也可以实现本地的进程间通信。

常见 API（感知）：

复制代码

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
int socket(int domain, int type, int protocol);

// 绑定端口号 (TCP/UDP, 服务器) 
int bind(int socket, const struct sockaddr *address, socklen_t address_len);

// 开始监听socket (TCP, 服务器)
int listen(int socket, int backlog);

// 接收请求 (TCP, 服务器)
int accept(int socket, struct sockaddr* address,socklen_t* address_len);

// 建立连接 (TCP, 客户端)
int connect(int sockfd, const struct sockaddr *addr,
 socklen_t addrlen);

2.sockaddr结构

我们可以看到上面struct sockaddr *addr出现次数挺多的。实际上在网络上通信的时候套接字种类是比较多的，下面是常见的三种：

unix 域间套接字编程--同一个机器内
原始套接字编程--网络工具
网络套接字编程--用户间的网络通信

设计者想将网络接口统一抽象化--参数的类型必须是统一的，底层是一种多态的设计

运用场景：

网络套接字：运用于网络跨主机之间通信+本地通信
unix域间套接字: 本地通信
我们现在在使用网络编程通信时是应用层调传输层的接口，而原始套接字：跳过传输层访问其他层协议中的有效数据。主要用于抓包，侦测网络情况。。

我们现在知道++套接字种类很多，它们应用的场景也是不一样的++。所以未来要完成这三种通信就需要有三套不同接口，但是思想上用的都是套接字的思想。因此接口设计者不想设计三套接口，只想设计一套接口，可以通过不通的参数，解决所有网络或者其他场景下的通信网络。

由于不同的通信方式（跨网络或本地通信）有不同的地址格式，套接字使用不同的结构体来封装地址信息：

sockaddr_in**：用于跨网络通信（例如通过 IP 和端口号进行通信）。**
sockaddr_un**：用于本地通信（通过文件路径进行通信）。**

为了解决这些不同地址格式的兼容性问题，套接字提供了一个通用的地址结构体 sockaddr，用于统一处理不同的地址结构。

3. `sockaddr`、`sockaddr_in` 和 `sockaddr_un` 的关系

sockaddr 是一个通用的套接字地址结构，它为所有不同类型的通信方式提供了统一的接口。具体通信时，sockaddr 实际上指向特定的地址结构（如 sockaddr_in 或 sockaddr_un），然后通过强制类型转换来区分是哪种通信方式。

这种设计类似于面向对象编程中的"多态"：sockaddr****可以看作一个"父类"，而 sockaddr_in****和 sockaddr_un****是它的"子类 "。在程序中，套接字函数接受 sockaddr* 类型的参数，然后根据具体的通信类型进行处理。

`sockaddr` 结构体

复制代码

struct sockaddr {
    __SOCKADDR_COMMON(sa_); /* 公共数据：地址家族和长度 */
    char sa_data[14];       /* 地址数据 */
};

`sockaddr_in` 结构体（IPv4 套接字地址）

复制代码

struct sockaddr_in {
    __SOCKADDR_COMMON(sin_);
    in_port_t sin_port;      /* 端口号 */
    struct in_addr sin_addr; /* IP地址 */
    unsigned char sin_zero[sizeof(struct sockaddr) - 
                           __SOCKADDR_COMMON_SIZE - 
                           sizeof(in_port_t) - 
                           sizeof(struct in_addr)];
};

`sockaddr_un` 结构体（Unix域套接字地址）

复制代码

struct sockaddr_un {
    __SOCKADDR_COMMON(sun_);
    char sun_path[108]; /* 文件路径 */
};

4. `sockaddr` 通用结构的意义

sockaddr 作为通用结构，它的前16个比特用于存储协议家族（sa_family 字段）。这个字段用来表明使用的是哪种通信方式：

AF_INET：IPv4网络通信。
AF_INET6：IPv6网络通信。
AF_UNIX：本地通信（UNIX 域套接字）。

通过这种设计，++Socket API 可以通过统一的函数接口，处理不同类型的地址格式。开发者只需要将具体的地址结构转换为 sockaddr++，并设置协议家族字段，套接字函数就能识别出应该进行哪种通信。

5. 通用性带来的优势

Socket API 的这种设计带来了极大的通用性，使得开发者在同一套代码中可以处理不同的协议类型。例如，函数 sendto()**或 recvfrom()**可以接受 sockaddr作为参数，无论是处理 IPv4、IPv6 还是 UNIX Domain Socket，代码都不需要做出太大改动。*

复制代码

int sendto(int sockfd, const void *msg, size_t len, int flags,
           const struct sockaddr *dest_addr, socklen_t addrlen);

在这个函数中，dest_addr 是一个通用的 sockaddr*，程序只需根据实际使用的通信方式（如 IPv4 或 IPv6）对其进行强制类型转换即可。

6. IPv4 与 IPv6 的地址表示

IPv4 地址格式 使用 sockaddr_in 结构体，地址类型是 AF_INET，端口号和IP地址需要转换为网络字节序（大端序）。
IPv6 地址格式 使用 sockaddr_in6 结构体，地址类型是 AF_INET6。

7. 代码示例

`in_addr` 结构体（用于表示IPv4地址）

复制代码

typedef uint32_t in_addr_t;
struct in_addr {
    in_addr_t s_addr; // 32位IP地址
};

in_addr 是一个32位的整数，用来表示IPv4的IP地址。通信过程中，IP地址通常是通过字符串格式（如 "192.168.1.1"）转换为 in_addr_t 类型的数值来表示。

总结

通过 sockaddr 结构体，Socket API 实现了网络通信和本地通信的统一接口
它的设计理念类似于"多态"，即通过一个通用的接口来处理多种类型的地址格式

Socket 接口

1. 创建 Socket 文件描述符

在 TCP 和 UDP 通信中，首先要创建一个 Socket 文件描述符，它本质上是一个网络文件。其函数原型为：

功能：打开一个网络通讯端口，返回一个文件描述符，如果失败，返回 -1。
参数：

- domain：协议域，如 AF_INET（IPv4）、AF_INET6（IPv6）、AF_LOCAL（Unix域套接字）。
- type：套接字类型，如 SOCK_STREAM（字节流，TCP）、SOCK_DGRAM（数据报，UDP）。
- protocol：协议类别，通常设置为 0，自动推导出对应的协议，如 TCP/UDP。

2. 绑定 bind 端口号 (服务器)

在服务器端，必须绑定一个 IP 地址和端口号，以便客户端可以与服务器建立通信。bind() 函数用于将套接字与 IP 和端口号绑定：

功能：将指定的 IP 和端口号绑定到套接字，使之监听指定地址。
参数：

- socket：套接字文件描述符。
- address：存储地址和端口号的结构体指针。
- address_len：地址结构体的长度。

3. 开始监听 Socket (TCP 服务器)

在服务器中，调用 listen() 函数使套接字进入监听状态，准备接受连接请求：

功能：让服务器套接字进入监听状态，准备接收客户端连接。
参数：

- socket：监听套接字描述符。
- backlog：全连接队列的最大长度，用于处理多个客户端连接请求。

4. 接收连接请求 (TCP 服务器)

服务器使用 accept() 从连接队列中提取下一个连接请求，并返回新的套接字用于与客户端通信：

功能：获取一个已完成的连接请求，并返回新的套接字用于客户端通信。
参数：

- socket：监听套接字。
- address：存储客户端的地址信息。
- address_len：地址结构的长度。

5. 建立连接 (TCP 客户端)

客户端通过 connect() 向服务器发起连接请求：

功能：TCP 客户端使用该函数建立与服务器的连接。
参数：

- sockfd：用于通信的套接字文件描述符。
- addr：服务器的地址。
- addrlen：地址长度。

6. 设置套接字选项 (进阶)

通过 setsockopt() 可以设置套接字的各种属性，例如端口重用等高级功能：

功能：设置套接字的选项，如端口重用等。
参数：

- sockfd：套接字文件描述符。
- level：选项的层次（如 SOL_SOCKET，IPPROTO_TCP 等）。
- optname：选项名。
- optval：指向设置值的指针。
- optlen：设置值的长度。

7. 地址转换函数

IP 地址可以以字符串或整数形式存在。常见的地址转换函数包括：

字符串 IP 转整数 IP：

in_addr_t inet_addr(const char *strptr);
int inet_pton(int family, const char *strptr, void *addrptr);
整数 IP 转字符串 IP：

char *inet_ntoa(struct in_addr addr);
const char *inet_ntop(int family, const void *src, char *dest, size_t len);

8. 数据传输函数

`sendto()` (UDP)

用于在 UDP 协议下发送数据：

功能：发送数据到指定地址。
参数：

- sockfd：套接字文件描述符。
- buf：要发送的数据。
- len：数据长度。

`recvfrom()` (UDP)

接收来自远程主机的数据：

功能：接收数据。
参数：

- sockfd：套接字文件描述符。
- buf：存放接收数据的缓冲区。

`send()` 和 `recv()` (TCP)

send() 用于在 TCP 协议下发送数据。

ssize_t send(int sockfd, const void *buf, size_t len, int flags);
recv() 用于接收 TCP 协议下的数据。

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

9. 实际使用中的注意事项

INADDR_ANY

在服务器端，INADDR_ANY（0.0.0.0）可以让服务器监听所有可用的网络接口，而不必指定具体的 IP 地址。这种方式提高了代码的可移植性。

复制代码

local.sin_addr.s_addr = INADDR_ANY;

客户端是否需要绑定？

客户端不需要手动绑定端口，操作系统会自动选择一个可用的端口。除非明确需要使用固定的端口，否则不建议手动绑定。

Listening Socket vs Connected Socket

Listening Socket：服务器使用它来监听连接请求。它在整个服务器生命周期内存在。
Connected Socket：服务器接收连接请求后，用于与客户端通信的套接字。每个客户端有一个独立的连接套接字。

10. TCP 通信流程

服务器初始化 ：调用 socket() 创建套接字，调用 bind() 绑定地址和端口，调用 listen() 进入监听状态。
客户端连接 ：客户端通过 socket() 创建套接字，使用 connect() 发起连接请求。
三次握手：TCP 客户端与服务器通过三次握手建立连接。
数据传输 ：连接建立后，双方可以通过 send() 和 recv() 进行数据传输。
断开连接：通过四次挥手，客户端和服务器断开连接。

这里只是简单提一下，要有个印象，下篇文章将详细讲解~

11. TCP vs UDP

TCP ：可靠的连接，字节流传输，保证数据顺序。
UDP ：不可靠传输，数据报传输，适用于实时通信。

12. `popen()` 和 `pclose()`

popen() 创建一个管道用于与子进程通信：来实现命令行通信

复制代码

FILE *popen(const char *command, const char *type);

pclose() 关闭通过 popen() 打开的文件指针：

复制代码

int pclose(FILE *stream);

使用场景：Udpcommand

结语

Socket 编程是网络编程的基础，通过 Socket API，开发者可以实现 TCP 和 UDP 通信。了解每个函数的作用、参数和使用场景，可以帮助开发者在构建高效、稳定的网络应用时得心应手。

预备知识

这个部分的设计非常重要

复制代码

struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(port_); //主机转网络，16位
        local.sin_addr.s_addr = inet_addr(ip_.c_str()); 
//1. string -> uint32_t 2. uint32_t必须是网络序列的 // ??
        // local.sin_addr.s_addr = htonl(INADDR_ANY);

端口号，是要在网络部分，来回传递的

一个关于绑定 IP 的问题

转化代码 local.sin_addr.s_addr = inet_addr(ip_.c_str());

一个关于 port 的问题

转化代码 local.sin_addr.s_addr = htonl(INADDR_ANY);

关于 port 的测试报错，要 sudo 用超级用户去绑

0,1023\]: 系统内定的端口号，一般都要有固定的应用层协议使用，http:80,https:443,mysql:3306... *** ** * ** *** ## 简易的实验 ![](https://img-blog.csdnimg.cn/img_convert/5275f16521d819c0568fc710ead01633.png) ## Log.hpp #pragma once #include #include #include//这个头文件是干啥的 #include #include #include//? #include #include #define SIZE 1024 #define Info 0 #define Debug 1 #define Warning 2 #define Error 3 #define Fatal 4 #define Screen 1 #define Onefile 2 #define Classfile 3 #define LogFile "log.txt" class Log { public: Log() { printfMethod=Screen; path="./log/"; } void Enable(int method) { printfMethod=method; } //将日志级别转化为对应的字符串表示形式 std::string levelToString(int level) { switch (level) { case Info: return "Info"; case Debug: return "Debug"; case Warning: return "Warning"; case Error: return "Error"; case Fatal: return "Fatal"; default: return "None"; } } //根据日志的输出方式，将日志输出到相应的目标 void printLog(int level, const std::string &logtxt) { switch (printMethod) { case Screen: std::cout << logtxt << std::endl; break; case Onefile: printOneFile(LogFile, logtxt); break; case Classfile: printClassFile(level, logtxt); break; default: break; } } //将日志输出到指定文件，文件名通过将路径和文件名拼接得到，并以追加的方式写入日志 void printOneFile(const std::string &logname,const std::string &logtxt) { std::string _logname=path+logname; int fd=open(_logname.c_str(),O_WRONLY | O_CREAT | O_APPEND,0666); if(fd<0) return; write(fd, logtxt.c_str(), logtxt.size()); close(fd); } //根据日志级别输出到不同的文件 void printClassFile(int level, const std::string &logtxt) { std::string filename = LogFile; filename += "."; filename += levelToString(level); printOneFile(filename, logtxt); } //重载的operator()使得Log类的实例可以像函数一样调用，简化日志记录的使用 //使用可变参数处理日志消息的格式化 void operator()(int level, const char *format, ...) { time_t t = time(nullptr); struct tm *ctime = localtime(&t); char leftbuffer[SIZE]; snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(), ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec); va_list s; va_start(s, format); char rightbuffer[SIZE]; vsnprintf(rightbuffer, sizeof(rightbuffer), format, s); va_end(s); char logtxt[SIZE * 2]; snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer); printLog(level, logtxt); } private: int printfMethod; std::string path; }; 这段代码实现了一个简单的日志系统，允许将日志输出到控制台、单一日志文件或根据日志级别分类的不同文件中。下面是对代码的详细解释和整理。分析： #### 1. 头文件的引用 #include #include #include #include #include #include #include #include 这些头文件提供了实现该日志系统所需的基本库功能： * `` 用于控制台输入输出。 * `` 用于处理时间。 * `` 用于处理可变参数列表。 * ``, ``, ``, `` 提供文件操作相关的系统调用。 * `` 提供了一些标准库函数，如 `exit()` 等。 #### 2. 宏定义 #define SIZE 1024 #define Info 0 #define Debug 1 #define Warning 2 #define Error 3 #define Fatal 4 #define Screen 1 #define Onefile 2 #define Classfile 3 #define LogFile "log.txt" 这些宏定义了一些常量： * `SIZE` 定义了缓冲区的大小。 * `Info`, `Debug`, `Warning`, `Error`, `Fatal` 定义了日志级别。 * `Screen`, `Onefile`, `Classfile` 定义了日志的输出方式。 * `LogFile` 定义了默认的日志文件名。 #### 3. `Log` 类 `Log` 类是日志系统的核心，包含了日志输出的主要功能。 ##### 成员变量 private: int printMethod; std::string path; * `printMethod` 用于保存日志的输出方式（屏幕、单一文件、分类文件）。 * `path` 保存日志文件的路径。 ##### 构造函数 public: Log() { printMethod = Screen; path = "./log/"; } * 构造函数初始化日志输出方式为屏幕输出 (`Screen`)，并设置日志文件的默认路径为 `"./log/"`。 ##### `Enable` 方法 void Enable(int method) { printMethod = method; } * 这个方法用于设置日志的输出方式。 ##### `levelToString` 方法 std::string levelToString(int level) { switch (level) { case Info: return "Info"; case Debug: return "Debug"; case Warning: return "Warning"; case Error: return "Error"; case Fatal: return "Fatal"; default: return "None"; } } * 将日志级别转换为对应的字符串表示形式。 ##### `printLog` 方法 void printLog(int level, const std::string &logtxt) { switch (printMethod) { case Screen: std::cout << logtxt << std::endl; break; case Onefile: printOneFile(LogFile, logtxt); break; case Classfile: printClassFile(level, logtxt); break; default: break; } } * 根据日志输出方式，将日志输出到相应的目标（屏幕、单一文件或分类文件）。 ##### `printOneFile` 方法 void printOneFile(const std::string &logname, const std::string &logtxt) { std::string _logname = path + logname; int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666); if (fd < 0) return; write(fd, logtxt.c_str(), logtxt.size()); close(fd); } * 将日志输出到指定文件。文件名通过将路径和文件名拼接得到，并以追加方式写入日志。 ##### `printClassFile` 方法 void printClassFile(int level, const std::string &logtxt) { std::string filename = LogFile; filename += "."; filename += levelToString(level); printOneFile(filename, logtxt); } * 根据日志级别输出到不同的文件，例如 `log.txt.Debug` 或 `log.txt.Error`。 ##### 重载的 `operator()` void operator()(int level, const char *format, ...) { time_t t = time(nullptr); struct tm *ctime = localtime(&t); char leftbuffer[SIZE]; snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(), ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec); va_list s; va_start(s, format); char rightbuffer[SIZE]; vsnprintf(rightbuffer, sizeof(rightbuffer), format, s); va_end(s); char logtxt[SIZE * 2]; snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer); printLog(level, logtxt); } * 重载的 `operator()` 使得 `Log` 类的实例可以像函数一样调用，简化了日志记录的使用。 * 使用可变参数处理日志消息的格式化，并根据当前时间戳和日志级别生成日志消息。 #### 4. 总结 实现了一个简单而灵活的日志系统，可以根据用户需求将日志输出到不同的目标。日志级别和输出方式都可以通过方法进行配置，使用方便。预留了部分扩展功能，例如注释掉的 `logmessage` 方法，可以进行进一步扩展和定制。 ## Makefile .PHONY:all all:udpserver udpclient udpserver:Main.cc g++ -o $@ $^ -std=c++11 udpclient:UdpClient.cc g++ -o $@ $^ -std=c++11 .PHONY:clean clean: rm -f udpserver udpclient ## UdpServer.hpp #pragma once #include #include #include #include #include #include #include #include #include #include "Log.hpp" // using func_t = std::function; typedef std::function func_t; Log lg; enum{ SOCKET_ERR=1, BIND_ERR }; uint16_t defaultport = 8080; std::string defaultip = "0.0.0.0"; const int size = 1024; class UdpServer{ public: UdpServer(const uint16_t &port = defaultport, const std::string &ip = defaultip):sockfd_(0), port_(port), ip_(ip),isrunning_(false) {} void Init() { // 1. 创建udp socket sockfd_ = socket(AF_INET, SOCK_DGRAM, 0); // PF_INET if(sockfd_ < 0) { lg(Fatal, "socket create error, sockfd: %d", sockfd_); exit(SOCKET_ERR); } lg(Info, "socket create success, sockfd: %d", sockfd_); // 2. bind socket struct sockaddr_in local; bzero(&local, sizeof(local)); local.sin_family = AF_INET; local.sin_port = htons(port_); //需要保证我的端口号是网络字节序列，因为该端口号是要给对方发送的 local.sin_addr.s_addr = inet_addr(ip_.c_str()); //1. string -> uint32_t 2. uint32_t必须是网络序列的 // ?? // local.sin_addr.s_addr = htonl(INADDR_ANY); if(bind(sockfd_, (const struct sockaddr *)&local, sizeof(local)) < 0) { lg(Fatal, "bind error, errno: %d, err string: %s", errno, strerror(errno)); exit(BIND_ERR); } lg(Info, "bind success, errno: %d, err string: %s", errno, strerror(errno)); } void Run(func_t func) // 对代码进行分层 { isrunning_ = true; char inbuffer[size]; while(isrunning_) { struct sockaddr_in client; socklen_t len = sizeof(client); ssize_t n = recvfrom(sockfd_, inbuffer, sizeof(inbuffer) - 1, 0, (struct sockaddr*)&client, &len); if(n < 0) { lg(Warning, "recvfrom error, errno: %d, err string: %s", errno, strerror(errno)); continue; } inbuffer[n] = 0; std::string info = inbuffer; std::string echo_string = func(info); sendto(sockfd_, echo_string.c_str(), echo_string.size(), 0, (const sockaddr*)&client, len); } } ~UdpServer() { if(sockfd_>0) close(sockfd_); } private: int sockfd_; // 网路文件描述符 std::string ip_; // 任意地址bind 0 uint16_t port_; // 表明服务器进程的端口号 bool isrunning_; }; 这段代码实现了一个简单的UDP服务器，提供了初始化和运行的功能，并通过一个回调函数处理接收到的数据。以下是对代码的详细解释和整理。 #### 1. 头文件的引用 #include #include #include #include #include #include #include #include #include #include "Log.hpp" * ``：用于标准输入输出流。 * ``：提供了 `std::string` 类。 * ``：提供了 `bzero` 函数用于清空内存。 * ``：用于C字符串操作，比如 `strerror` 函数。 * ``：定义了系统数据类型，如 `socklen_t`。 * ``：提供了套接字接口。 * `