1. Socket通信基础概念
在嵌入式Linux开发中，Socket通信是最基础也是最重要的网络编程技术之一。想象一下，当你需要让两个嵌入式设备通过网线或WiFi交换数据时，Socket就是它们之间的"电话线"。
Socket本质上是一个编程接口（API），它抽象了底层网络协议的复杂性，让我们可以用简单的函数调用来实现设备间的通信。就像打电话不需要了解电话交换机的具体工作原理一样，使用Socket编程时，我们也不需要深入理解TCP/IP协议栈的每个细节。
1.1 Socket通信模型
Socket通信遵循客户端-服务器模型，这个模型有三个关键阶段：
-
连接建立阶段：
- 服务器端：创建一个Socket并绑定到特定端口，然后开始监听连接请求
- 客户端：创建Socket并主动向服务器发起连接请求
- 服务器接受连接后，双方建立通信通道
-
数据传输阶段：
- 双方通过读写操作交换数据
- TCP保证数据可靠有序传输，UDP则不保证
-
连接终止阶段：
- 任一方可以主动关闭连接
- 系统资源被释放
1.2 协议选择：TCP vs UDP
在嵌入式系统中选择TCP还是UDP，需要根据具体应用场景决定：
TCP（传输控制协议）特点：
- 面向连接：通信前需建立连接
- 可靠传输：确保数据不丢失、不重复、按序到达
- 流量控制：避免发送方淹没接收方
- 拥塞控制：根据网络状况调整发送速率
- 典型应用：文件传输、远程登录、Web访问
UDP（用户数据报协议）特点：
- 无连接：直接发送数据报
- 不可靠：不保证送达，不保证顺序
- 开销小：没有连接建立和维护的开销
- 速度快：适合实时性要求高的应用
- 典型应用：视频流、VoIP、DNS查询
提示：在嵌入式系统中，如果设备资源有限且对实时性要求高，UDP通常是更好的选择。但如果数据可靠性更重要，则应选择TCP。
2. Socket编程基础
2.1 创建Socket
在Linux中，使用socket()函数创建Socket：
c复制#include <sys/socket.h>
int socket(int domain, int type, int protocol);
参数说明：
- domain：协议族，常用AF_INET(IPv4)或AF_INET6(IPv6)
- type：Socket类型，SOCK_STREAM(TCP)或SOCK_DGRAM(UDP)
- protocol：通常设为0，让系统自动选择
返回值：
- 成功：返回Socket文件描述符
- 失败：返回-1
示例：
c复制// 创建TCP Socket
int tcp_sock = socket(AF_INET, SOCK_STREAM, 0);
// 创建UDP Socket
int udp_sock = socket(AF_INET, SOCK_DGRAM, 0);
2.2 地址结构体
网络通信需要指定IP地址和端口号，使用sockaddr_in结构体：
c复制#include <netinet/in.h>
struct sockaddr_in {
sa_family_t sin_family; // 地址族，如AF_INET
in_port_t sin_port; // 端口号
struct in_addr sin_addr; // IP地址
};
struct in_addr {
uint32_t s_addr; // 32位IPv4地址
};
字节序转换：
网络字节序是大端序，而主机字节序可能是小端序，需要使用转换函数：
c复制#include <arpa/inet.h>
uint16_t htons(uint16_t hostshort); // 主机到网络(short)
uint32_t htonl(uint32_t hostlong); // 主机到网络(long)
uint16_t ntohs(uint16_t netshort); // 网络到主机(short)
uint32_t ntohl(uint32_t netlong); // 网络到主机(long)
IP地址转换：
c复制// 字符串IP转二进制
int inet_pton(int af, const char *src, void *dst);
// 二进制IP转字符串
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
3. TCP Socket编程详解
3.1 服务器端实现
TCP服务器需要依次调用socket()、bind()、listen()和accept()：
c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
#define BACKLOG 5 // 最大等待连接数
int main() {
int server_fd, new_socket;
struct sockaddr_in address;
int opt = 1;
int addrlen = sizeof(address);
char buffer[BUFFER_SIZE] = {0};
// 1. 创建Socket
if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
perror("socket failed");
exit(EXIT_FAILURE);
}
// 设置Socket选项，避免地址占用错误
if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) {
perror("setsockopt failed");
close(server_fd);
exit(EXIT_FAILURE);
}
// 2. 绑定地址和端口
address.sin_family = AF_INET;
address.sin_addr.s_addr = INADDR_ANY; // 监听所有网络接口
address.sin_port = htons(PORT);
if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) {
perror("bind failed");
close(server_fd);
exit(EXIT_FAILURE);
}
// 3. 开始监听
if (listen(server_fd, BACKLOG) < 0) {
perror("listen failed");
close(server_fd);
exit(EXIT_FAILURE);
}
printf("Server listening on port %d\n", PORT);
// 4. 接受连接
if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) {
perror("accept failed");
close(server_fd);
exit(EXIT_FAILURE);
}
printf("Connection accepted from %s:%d\n",
inet_ntoa(address.sin_addr), ntohs(address.sin_port));
// 5. 读取客户端数据
int valread = read(new_socket, buffer, BUFFER_SIZE);
printf("Received: %s\n", buffer);
// 6. 发送响应
char *response = "Hello from server";
send(new_socket, response, strlen(response), 0);
printf("Response sent\n");
// 7. 关闭连接
close(new_socket);
close(server_fd);
return 0;
}
3.2 客户端实现
TCP客户端需要调用socket()和connect()：
c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
int sock = 0;
struct sockaddr_in serv_addr;
char buffer[BUFFER_SIZE] = {0};
// 1. 创建Socket
if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
perror("socket creation failed");
return -1;
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
// 2. 转换IP地址
if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) {
perror("invalid address");
close(sock);
return -1;
}
// 3. 连接服务器
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
perror("connection failed");
close(sock);
return -1;
}
printf("Connected to server\n");
// 4. 发送数据
char *message = "Hello from client";
send(sock, message, strlen(message), 0);
printf("Message sent\n");
// 5. 读取响应
int valread = read(sock, buffer, BUFFER_SIZE);
printf("Server response: %s\n", buffer);
// 6. 关闭连接
close(sock);
return 0;
}
3.3 多客户端处理
实际服务器需要同时处理多个客户端连接，可以使用多进程或多线程：
c复制// 在accept后创建子进程处理连接
while (1) {
int new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen);
if (new_socket < 0) {
perror("accept failed");
continue;
}
pid_t pid = fork();
if (pid == 0) { // 子进程
close(server_fd); // 子进程不需要监听Socket
// 处理客户端请求
handle_client(new_socket);
close(new_socket);
exit(0);
} else if (pid > 0) { // 父进程
close(new_socket); // 父进程不需要客户端Socket
} else {
perror("fork failed");
}
}
4. UDP Socket编程
4.1 UDP服务器实现
UDP服务器不需要listen()和accept()，直接使用recvfrom()接收数据：
c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
int sockfd;
struct sockaddr_in servaddr, cliaddr;
socklen_t len;
char buffer[BUFFER_SIZE];
// 1. 创建UDP Socket
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
memset(&cliaddr, 0, sizeof(cliaddr));
// 2. 绑定地址和端口
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(PORT);
if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind failed");
close(sockfd);
exit(EXIT_FAILURE);
}
printf("UDP Server listening on port %d\n", PORT);
len = sizeof(cliaddr);
// 3. 接收数据
int n = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
(struct sockaddr *)&cliaddr, &len);
buffer[n] = '\0';
printf("Received from client: %s\n", buffer);
// 4. 发送响应
char *response = "Hello from UDP server";
sendto(sockfd, response, strlen(response), 0,
(const struct sockaddr *)&cliaddr, len);
printf("Response sent\n");
// 5. 关闭Socket
close(sockfd);
return 0;
}
4.2 UDP客户端实现
UDP客户端不需要connect()，直接使用sendto()发送数据：
c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#define PORT 8080
#define BUFFER_SIZE 1024
int main() {
int sockfd;
struct sockaddr_in servaddr;
char buffer[BUFFER_SIZE];
// 1. 创建UDP Socket
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr, 0, sizeof(servaddr));
// 2. 设置服务器地址
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(PORT);
servaddr.sin_addr.s_addr = INADDR_ANY;
// 3. 发送数据
char *message = "Hello from UDP client";
sendto(sockfd, message, strlen(message), 0,
(const struct sockaddr *)&servaddr, sizeof(servaddr));
printf("Message sent\n");
// 4. 接收响应
socklen_t len = sizeof(servaddr);
int n = recvfrom(sockfd, buffer, BUFFER_SIZE, 0,
(struct sockaddr *)&servaddr, &len);
buffer[n] = '\0';
printf("Server response: %s\n", buffer);
// 5. 关闭Socket
close(sockfd);
return 0;
}
5. 高级应用：实现HTTP客户端
虽然实际开发中我们会使用现成的HTTP库，但了解底层实现很有必要：
c复制#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netdb.h>
#define PORT 80
#define BUFFER_SIZE 4096
int main(int argc, char const *argv[]) {
if (argc != 2) {
printf("Usage: %s <hostname>\n", argv[0]);
return -1;
}
const char *hostname = argv[1];
// 1. 解析主机名
struct hostent *host = gethostbyname(hostname);
if (host == NULL) {
herror("gethostbyname failed");
return -1;
}
// 2. 创建Socket
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
return -1;
}
// 3. 设置服务器地址
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(PORT);
memcpy(&serv_addr.sin_addr.s_addr, host->h_addr, host->h_length);
// 4. 连接服务器
if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
perror("connection failed");
close(sockfd);
return -1;
}
// 5. 构造HTTP请求
char request[BUFFER_SIZE];
snprintf(request, sizeof(request),
"GET / HTTP/1.1\r\n"
"Host: %s\r\n"
"Connection: close\r\n"
"\r\n", hostname);
// 6. 发送HTTP请求
if (send(sockfd, request, strlen(request), 0) < 0) {
perror("send failed");
close(sockfd);
return -1;
}
// 7. 接收响应
char response[BUFFER_SIZE];
int total_bytes = 0;
int bytes_received;
printf("HTTP Response:\n");
while ((bytes_received = recv(sockfd, response, BUFFER_SIZE - 1, 0)) > 0) {
response[bytes_received] = '\0';
printf("%s", response);
total_bytes += bytes_received;
}
printf("\nTotal received: %d bytes\n", total_bytes);
// 8. 关闭连接
close(sockfd);
return 0;
}
6. 常见问题与调试技巧
6.1 错误处理
Socket编程中常见的错误及解决方法：
-
Address already in use：
- 原因：端口被占用
- 解决：设置SO_REUSEADDR选项或等待一段时间
-
Connection refused：
- 原因：目标端口没有服务监听
- 解决：检查服务器是否运行，端口是否正确
-
Connection timed out：
- 原因：网络不通或防火墙阻止
- 解决：检查网络连接和防火墙设置
-
Broken pipe：
- 原因：向已关闭的连接写数据
- 解决：检查连接状态，添加错误处理
6.2 性能优化
-
设置非阻塞模式：
c复制int flags = fcntl(sockfd, F_GETFL, 0); fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); -
使用select/poll/epoll处理多连接：
c复制fd_set readfds; FD_ZERO(&readfds); FD_SET(sockfd, &readfds); struct timeval timeout; timeout.tv_sec = 5; timeout.tv_usec = 0; int activity = select(sockfd + 1, &readfds, NULL, NULL, &timeout); -
调整缓冲区大小：
c复制int buf_size = 1024 * 1024; // 1MB setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size)); setsockopt(sockfd, SOL_SOCKET, SO_SNDBUF, &buf_size, sizeof(buf_size));
6.3 调试工具
-
netstat：查看网络连接状态
bash复制
netstat -tulnp -
tcpdump：抓包分析
bash复制
tcpdump -i eth0 port 8080 -nn -vv -
strace：跟踪系统调用
bash复制
strace -f -e trace=network ./server -
Wireshark：图形化网络分析工具
7. 嵌入式系统中的特殊考虑
在嵌入式Linux系统中进行Socket编程时，还需要注意：
-
资源限制：
- 嵌入式设备内存有限，需合理设置缓冲区大小
- 连接数不宜过多，避免耗尽资源
-
实时性要求：
- 对于实时性要求高的应用，优先考虑UDP
- 可以调整内核网络参数优化性能
-
电源管理：
- 无线网络模块耗电大，需优化通信频率
- 考虑使用低功耗协议如MQTT-SN
-
交叉编译：
- 确保交叉编译工具链包含必要的网络库
- 静态链接可以减少运行时依赖
-
硬件加速：
- 某些嵌入式处理器提供网络硬件加速功能
- 可以启用TCP/IP协议栈硬件卸载减轻CPU负担
在实际嵌入式项目中，虽然我们通常会使用现成的网络库（如libcurl、Paho MQTT等），但深入理解Socket编程原理对于调试网络问题、优化性能以及实现定制协议都非常有帮助。