Linux C语言套接字编程入门
1. 套接字概述
套接字（Socket）是一种网络编程接口，它提供了一种在不同计算机之间进行通信的机制。在 Linux 环境下，使用 C 语言进行套接字编程是实现网络应用程序的基础。套接字可以看作是应用层与传输层之间的桥梁，使得应用程序能够方便地使用底层网络协议进行数据传输。
套接字起源于 20 世纪 70 年代的 Unix 操作系统，最初是为了支持同一台主机上不同进程之间的通信，后来逐渐发展为支持网络环境下不同主机之间的进程通信。它的设计理念是将复杂的网络通信抽象为类似文件操作的方式，这样开发人员可以利用熟悉的文件 I/O 函数来处理网络数据。
套接字有多种类型，常见的包括流套接字（SOCK_STREAM）、数据报套接字（SOCK_DGRAM）和原始套接字（SOCK_RAW）。流套接字提供面向连接、可靠的字节流传输服务，基于 TCP 协议实现，适合对数据准确性和顺序要求较高的应用，如文件传输、远程登录等。数据报套接字提供无连接、不可靠的数据传输服务，基于 UDP 协议实现，适合对实时性要求较高但能容忍一定数据丢失的应用，如实时视频流、音频流传输等。原始套接字允许直接访问底层网络协议，通常用于网络协议开发、网络监测等高级应用场景。
2. Linux 下 C 语言套接字编程环境搭建
在开始套接字编程之前，需要确保开发环境具备相应的工具和库。一般来说，只要安装了标准的 Linux 发行版，系统就已经自带了基本的开发工具和套接字相关的库文件。
首先，需要安装 GCC（GNU C Compiler），它是 Linux 下最常用的 C 语言编译器。在大多数 Linux 发行版中，可以使用包管理器来安装 GCC。例如，在 Debian 或 Ubuntu 系统中，可以运行以下命令：
sudo apt-get install build-essential
在 Fedora 或 CentOS 系统中，可以使用以下命令：
sudo yum groupinstall "Development Tools"
安装完成后，可以通过编译一个简单的 C 程序来验证 GCC 是否安装成功。创建一个名为 test.c 的文件，内容如下：
#include <stdio.h>
int main() {
printf("Hello, World!\n");
return 0;
}
然后在终端中执行编译命令：
gcc test.c -o test
如果编译成功，会生成一个名为 test 的可执行文件，运行该文件：
./test
应该能够看到输出 Hello, World!。
3. 流套接字编程（TCP）
3.1 服务器端编程步骤
- 创建套接字：使用
socket函数创建一个套接字描述符。socket函数的原型如下：
#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
对于 TCP 流套接字，domain 参数通常设置为 AF_INET（表示使用 IPv4 协议），type 参数设置为 SOCK_STREAM，protocol 参数一般设置为 0，表示使用默认协议（对于 TCP 就是 TCP 协议本身）。例如：
int sockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
- 绑定地址和端口：将套接字与本地的 IP 地址和端口号绑定，使用
bind函数。bind函数原型如下：
#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
这里需要构造一个 struct sockaddr_in 结构体来指定地址和端口信息。示例代码如下：
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(8080);
if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind failed");
close(sockfd);
exit(EXIT_FAILURE);
}
INADDR_ANY 表示服务器可以绑定到本地任何可用的 IP 地址，htons 函数用于将主机字节序的端口号转换为网络字节序。
3. 监听连接：使用 listen 函数使套接字进入监听状态，等待客户端的连接请求。listen 函数原型如下：
#include <sys/socket.h>
int listen(int sockfd, int backlog);
backlog 参数指定了等待连接队列的最大长度。例如：
if (listen(sockfd, 5) < 0) {
perror("listen failed");
close(sockfd);
exit(EXIT_FAILURE);
}
- 接受连接：使用
accept函数接受客户端的连接请求。accept函数原型如下：
#include <sys/types.h>
#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
该函数会阻塞等待客户端连接，成功时返回一个新的套接字描述符，用于与客户端进行通信。示例代码如下：
struct sockaddr_in cliaddr;
socklen_t clilen = sizeof(cliaddr);
int connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &clilen);
if (connfd < 0) {
perror("accept failed");
close(sockfd);
exit(EXIT_FAILURE);
}
- 数据传输：使用
read和write函数（或者send和recv函数，它们在套接字编程中有更灵活的选项）在服务器和客户端之间进行数据传输。例如，从客户端读取数据并回显给客户端：
char buffer[1024];
ssize_t n = read(connfd, buffer, sizeof(buffer));
if (n < 0) {
perror("read failed");
close(connfd);
close(sockfd);
exit(EXIT_FAILURE);
}
buffer[n] = '\0';
printf("Received: %s\n", buffer);
n = write(connfd, buffer, strlen(buffer));
if (n < 0) {
perror("write failed");
close(connfd);
close(sockfd);
exit(EXIT_FAILURE);
}
- 关闭套接字：通信完成后，使用
close函数关闭套接字，释放资源。
close(connfd);
close(sockfd);
3.2 客户端编程步骤
- 创建套接字：与服务器端类似，使用
socket函数创建套接字描述符。
int sockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
- 连接服务器：使用
connect函数连接到服务器。connect函数原型如下：
#include <sys/types.h>
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
构造 struct sockaddr_in 结构体指定服务器的地址和端口信息，然后调用 connect 函数。示例代码如下：
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
servaddr.sin_port = htons(8080);
if (connect(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("connect failed");
close(sockfd);
exit(EXIT_FAILURE);
}
inet_addr 函数将点分十进制格式的 IP 地址转换为网络字节序的二进制格式。
3. 数据传输：同样使用 write 函数向服务器发送数据，read 函数从服务器接收数据。例如，向服务器发送一条消息并接收服务器的回显：
char buffer[1024] = "Hello, Server!";
ssize_t n = write(sockfd, buffer, strlen(buffer));
if (n < 0) {
perror("write failed");
close(sockfd);
exit(EXIT_FAILURE);
}
n = read(sockfd, buffer, sizeof(buffer));
if (n < 0) {
perror("read failed");
close(sockfd);
exit(EXIT_FAILURE);
}
buffer[n] = '\0';
printf("Received from server: %s\n", buffer);
- 关闭套接字：通信完成后，关闭套接字。
close(sockfd);
4. 数据报套接字编程（UDP）
4.1 服务器端编程步骤
- 创建套接字：使用
socket函数创建 UDP 套接字，domain参数为AF_INET，type参数为SOCK_DGRAM，protocol参数为 0。
int sockfd;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
- 绑定地址和端口：与 TCP 服务器类似，构造
struct sockaddr_in结构体并使用bind函数绑定地址和端口。
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(8080);
if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind failed");
close(sockfd);
exit(EXIT_FAILURE);
}
- 接收和发送数据：使用
recvfrom和sendto函数进行数据的接收和发送。recvfrom函数用于从客户端接收数据，同时获取客户端的地址信息。sendto函数用于向指定的客户端地址发送数据。函数原型如下：
#include <sys/types.h>
#include <sys/socket.h>
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen);
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
示例代码如下：
char buffer[1024];
struct sockaddr_in cliaddr;
socklen_t clilen = sizeof(cliaddr);
ssize_t n = recvfrom(sockfd, (char *)buffer, sizeof(buffer),
MSG_WAITALL, (struct sockaddr *) &cliaddr, &clilen);
buffer[n] = '\0';
printf("Received from client: %s\n", buffer);
n = sendto(sockfd, (const char *)buffer, strlen(buffer),
MSG_CONFIRM, (const struct sockaddr *) &cliaddr, clilen);
if (n < 0) {
perror("sendto failed");
close(sockfd);
exit(EXIT_FAILURE);
}
- 关闭套接字：通信完成后，关闭套接字。
close(sockfd);
4.2 客户端编程步骤
- 创建套接字：与服务器端相同，使用
socket函数创建 UDP 套接字。
int sockfd;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
- 发送和接收数据：构造
struct sockaddr_in结构体指定服务器的地址和端口，使用sendto函数向服务器发送数据，使用recvfrom函数从服务器接收数据。
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
servaddr.sin_port = htons(8080);
char buffer[1024] = "Hello, UDP Server!";
ssize_t n = sendto(sockfd, (const char *)buffer, strlen(buffer),
MSG_CONFIRM, (const struct sockaddr *) &servaddr, sizeof(servaddr));
if (n < 0) {
perror("sendto failed");
close(sockfd);
exit(EXIT_FAILURE);
}
n = recvfrom(sockfd, (char *)buffer, sizeof(buffer),
MSG_WAITALL, (struct sockaddr *) &servaddr, &clilen);
buffer[n] = '\0';
printf("Received from server: %s\n", buffer);
- 关闭套接字：通信完成后，关闭套接字。
close(sockfd);
5. 套接字选项
套接字提供了一系列选项，可以通过 setsockopt 和 getsockopt 函数来设置和获取这些选项。setsockopt 函数原型如下：
#include <sys/types.h>
#include <sys/socket.h>
int setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);
getsockopt 函数原型如下：
#include <sys/types.h>
#include <sys/socket.h>
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
其中，sockfd 是套接字描述符，level 表示选项的层次，常见的有 SOL_SOCKET（通用套接字选项）、IPPROTO_TCP（TCP 特定选项）、IPPROTO_IP（IP 特定选项）等。optname 是具体的选项名，optval 是选项的值，optlen 是选项值的长度。
例如，设置套接字的 SO_REUSEADDR 选项，允许在程序退出后立即重用地址：
int optval = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) {
perror("setsockopt failed");
close(sockfd);
exit(EXIT_FAILURE);
}
6. 错误处理
在套接字编程中，错误处理非常重要。每个套接字相关的函数在失败时都会返回 -1，并设置 errno 变量来指示具体的错误原因。可以使用 perror 函数输出错误信息。例如：
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
常见的错误包括地址绑定失败（可能是端口被占用）、连接失败（服务器未启动或网络问题）等。在实际编程中，需要根据具体的错误类型进行适当的处理，如提示用户、重试操作或进行优雅的程序退出。
7. 多线程与多路复用在套接字编程中的应用
7.1 多线程套接字编程
在服务器端，当有多个客户端同时连接时，为了能够同时处理多个客户端的请求，可以使用多线程技术。每个客户端连接由一个单独的线程来处理，这样可以提高服务器的并发处理能力。
例如，在 TCP 服务器中，当接受一个客户端连接后，创建一个新线程来处理该连接的通信：
#include <pthread.h>
void *handle_client(void *arg) {
int connfd = *((int *)arg);
char buffer[1024];
ssize_t n = read(connfd, buffer, sizeof(buffer));
if (n < 0) {
perror("read failed in thread");
close(connfd);
pthread_exit(NULL);
}
buffer[n] = '\0';
printf("Received in thread: %s\n", buffer);
n = write(connfd, buffer, strlen(buffer));
if (n < 0) {
perror("write failed in thread");
close(connfd);
pthread_exit(NULL);
}
close(connfd);
pthread_exit(NULL);
}
int main() {
int sockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(8080);
if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind failed");
close(sockfd);
exit(EXIT_FAILURE);
}
if (listen(sockfd, 5) < 0) {
perror("listen failed");
close(sockfd);
exit(EXIT_FAILURE);
}
while (1) {
struct sockaddr_in cliaddr;
socklen_t clilen = sizeof(cliaddr);
int connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &clilen);
if (connfd < 0) {
perror("accept failed");
close(sockfd);
exit(EXIT_FAILURE);
}
pthread_t tid;
if (pthread_create(&tid, NULL, handle_client, (void *)&connfd) != 0) {
perror("pthread_create failed");
close(connfd);
} else {
pthread_detach(tid);
}
}
close(sockfd);
return 0;
}
7.2 多路复用
多路复用是另一种处理多个并发连接的技术，它允许在一个线程中同时监控多个套接字的状态。常见的多路复用技术有 select、poll 和 epoll。
以 select 为例，select 函数可以监控一组套接字，当其中任何一个套接字有数据可读、可写或发生错误时，select 函数会返回。select 函数原型如下：
#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
nfds 是需要监控的套接字描述符中的最大值加 1，readfds、writefds 和 exceptfds 分别是需要监控读、写和异常事件的套接字描述符集合，timeout 是等待的超时时间。
示例代码如下：
#include <sys/select.h>
int main() {
int sockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = INADDR_ANY;
servaddr.sin_port = htons(8080);
if (bind(sockfd, (const struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind failed");
close(sockfd);
exit(EXIT_FAILURE);
}
if (listen(sockfd, 5) < 0) {
perror("listen failed");
close(sockfd);
exit(EXIT_FAILURE);
}
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(sockfd, &read_fds);
int max_fd = sockfd;
while (1) {
fd_set tmp_fds = read_fds;
int activity = select(max_fd + 1, &tmp_fds, NULL, NULL, NULL);
if (activity < 0) {
perror("select error");
break;
} else if (activity > 0) {
if (FD_ISSET(sockfd, &tmp_fds)) {
struct sockaddr_in cliaddr;
socklen_t clilen = sizeof(cliaddr);
int connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &clilen);
if (connfd < 0) {
perror("accept failed");
continue;
}
FD_SET(connfd, &read_fds);
if (connfd > max_fd) {
max_fd = connfd;
}
}
for (int i = sockfd + 1; i <= max_fd; i++) {
if (FD_ISSET(i, &tmp_fds)) {
char buffer[1024];
ssize_t n = read(i, buffer, sizeof(buffer));
if (n < 0) {
perror("read failed");
FD_CLR(i, &read_fds);
close(i);
} else if (n == 0) {
FD_CLR(i, &read_fds);
close(i);
} else {
buffer[n] = '\0';
printf("Received: %s\n", buffer);
n = write(i, buffer, strlen(buffer));
if (n < 0) {
perror("write failed");
FD_CLR(i, &read_fds);
close(i);
}
}
}
}
}
}
close(sockfd);
return 0;
}
poll 和 epoll 与 select 类似，但在性能和使用方式上有所不同。poll 使用 struct pollfd 结构体数组来表示需要监控的套接字集合，而 epoll 是 Linux 特有的高效多路复用机制，适合处理大量并发连接的场景。
8. 网络字节序与地址转换
在网络通信中，不同的计算机可能使用不同的字节序（大端序或小端序）。为了保证数据在网络传输中的一致性，需要进行字节序的转换。
常见的字节序转换函数有 htons（主机字节序到网络字节序（短整型））、htonl（主机字节序到网络字节序（长整型））、ntohs（网络字节序到主机字节序（短整型））和 ntohl（网络字节序到主机字节序（长整型））。
例如，在设置服务器端口时，使用 htons 函数将主机字节序的端口号转换为网络字节序：
servaddr.sin_port = htons(8080);
在地址转换方面，除了前面提到的 inet_addr 函数将点分十进制格式的 IP 地址转换为网络字节序的二进制格式外，还有 inet_ntoa 函数将网络字节序的二进制 IP 地址转换为点分十进制格式的字符串。例如：
struct sockaddr_in cliaddr;
socklen_t clilen = sizeof(cliaddr);
int connfd = accept(sockfd, (struct sockaddr *)&cliaddr, &clilen);
char *ip = inet_ntoa(cliaddr.sin_addr);
printf("Client IP: %s\n", ip);
9. 原始套接字编程
原始套接字允许直接访问底层网络协议，如 IP、ICMP 等。这在开发网络协议测试工具、网络监测程序等方面非常有用。
创建原始套接字时，type 参数设置为 SOCK_RAW，protocol 参数指定具体的协议，如 IPPROTO_ICMP 表示 ICMP 协议。
以下是一个简单的发送 ICMP 回显请求（Ping）的示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#define DEST_IP "127.0.0.1"
#define PACKET_SIZE 1024
void send_icmp_packet(int sockfd, const char *dest_ip) {
struct sockaddr_in dest_addr;
memset(&dest_addr, 0, sizeof(dest_addr));
dest_addr.sin_family = AF_INET;
dest_addr.sin_addr.s_addr = inet_addr(dest_ip);
struct icmphdr icmp_hdr;
memset(&icmp_hdr, 0, sizeof(icmp_hdr));
icmp_hdr.type = ICMP_ECHO;
icmp_hdr.code = 0;
icmp_hdr.un.echo.id = getpid();
icmp_hdr.un.echo.sequence = 1;
icmp_hdr.checksum = 0;
char data[PACKET_SIZE - sizeof(struct icmphdr)] = "Hello, ICMP!";
icmp_hdr.checksum = in_cksum((unsigned short *)&icmp_hdr, sizeof(icmp_hdr));
sendto(sockfd, &icmp_hdr, sizeof(icmp_hdr), MSG_CONFIRM,
(const struct sockaddr *) &dest_addr, sizeof(dest_addr));
sendto(sockfd, data, strlen(data), MSG_CONFIRM,
(const struct sockaddr *) &dest_addr, sizeof(dest_addr));
}
unsigned short in_cksum(unsigned short *addr, int len) {
register int nleft = len;
register unsigned short *w = addr;
register unsigned short answer;
register int sum = 0;
while (nleft > 1) {
sum += *w++;
nleft -= 2;
}
if (nleft > 0) {
sum += *(unsigned char *)w;
}
sum = (sum >> 16) + (sum & 0xFFFF);
sum += (sum >> 16);
answer = ~sum;
return answer;
}
int main() {
int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
if (sockfd < 0) {
perror("socket creation failed");
exit(EXIT_FAILURE);
}
send_icmp_packet(sockfd, DEST_IP);
close(sockfd);
return 0;
}
在这个示例中，构造了一个 ICMP 回显请求数据包，并使用原始套接字发送出去。需要注意的是，原始套接字编程通常需要较高的权限，一般需要以 root 权限运行程序。
通过以上对 Linux C 语言套接字编程的介绍，从基本概念、编程步骤、套接字选项、错误处理到多线程、多路复用等高级应用，以及网络字节序、地址转换和原始套接字编程等方面，希望读者能够对 Linux 下的 C 语言套接字编程有一个较为全面和深入的理解，并能够开发出各种网络应用程序。在实际编程中，还需要不断实践和优化，以提高程序的性能和稳定性。同时，随着网络技术的不断发展，新的网络编程模型和技术也在不断涌现，开发者需要持续学习和跟进，以适应不断变化的网络环境。