简介：本文详细介绍如何在C语言中实现TCP服务器和客户端套接字编程。我们首先解释TCP协议的基础，然后通过具体步骤指导读者创建和管理TCP连接，包括创建套接字、绑定地址、监听、接受连接、数据传输以及关闭连接。文章还涵盖了UNIX/Linux系统下Socket API的使用，并通过 client.c 和 server.c 的示例代码加深理解。 
1. TCP协议基础
在互联网通信中，TCP协议（Transmission Control Protocol，传输控制协议）扮演着至关重要的角色。它是面向连接的、可靠的、基于字节流的传输层通信协议。TCP协议确保数据包按顺序到达接收端，并在传输过程中提供错误检测和纠正机制。
1.1 TCP三次握手
为了建立一个TCP连接，双方主机需要经过三次握手的过程。以下是握手的步骤：
- 第一次握手 ：客户端发送一个带有SYN标志的数据包给服务器，请求建立连接，进入SYN_SEND状态。
- 第二次握手 ：服务器端接收到SYN请求后，回复一个带有SYN/ACK标志的数据包，表示同意建立连接，此时服务器进入SYN_RCVD状态。
- 第三次握手 ：客户端收到服务器的确认应答后，再发送一个ACK标志的数据包给服务器，完成连接的建立，此时双方都进入ESTABLISHED状态。
1.2 TCP四次挥手
当TCP连接不再需要时，会进行四次挥手过程来断开连接：
- 第一次挥手 ：客户端发送一个FIN标志的数据包给服务器，请求关闭客户端到服务器的数据传输，此时客户端进入FIN_WAIT_1状态。
- 第二次挥手 ：服务器收到FIN请求后，发出ACK标志确认应答，并将剩余的数据发送完毕后，发送FIN标志的数据包给客户端，请求关闭服务器到客户端的数据传输，此时服务器进入CLOSE_WAIT状态。
- 第三次挥手 ：客户端收到FIN请求后，发出ACK标志确认应答，并进入TIME_WAIT状态，等待足够的时间以确保服务器收到了它的ACK。
- 第四次挥手 ：服务器收到客户端的ACK后，关闭连接，客户端等待2MSL（最大报文段生存时间）后若未收到任何数据，则确定服务器已关闭，连接彻底断开。
TCP协议通过严格的序列号和确认应答机制，确保数据的可靠传输。这种机制在数据传输前先建立连接，传输完毕后再断开连接，虽然增加了开销，但保证了通信的可靠性。接下来的章节将深入探讨C语言中如何使用Socket API来实现基于TCP的网络通信。
2. C语言Socket API使用
2.1 Socket API概述
2.1.1 Socket API的基本概念
Socket API是一组函数，允许程序员在不同的网络协议族上编写网络应用程序。它是一种用于网络通信的系统调用接口，可以创建连接到其他机器的网络连接或监听其他机器的连接请求。Socket API在UNIX和类UNIX操作系统中广泛使用，特别是在TCP/IP网络通信中。程序员可以通过这些API控制数据包的发送和接收、端口绑定、连接管理等。
Socket API的应用极其广泛，从简单的服务器和客户端应用程序到复杂的分布式系统，都需要使用Socket API进行通信。通过使用Socket API，开发者可以建立基于TCP的可靠连接，或者使用UDP进行非连接的、快速的、但不可靠的数据传输。
2.1.2 Socket类型和协议族
Socket API支持多种类型的sockets，例如TCP和UDP sockets。在创建socket时，需要指定协议族和socket类型。
- 协议族 : 指定了socket基于哪种网络协议族工作，例如IPv4或IPv6。常用的协议族包括
PF_INET（IPv4）和PF_INET6（IPv6）。协议族的选择依赖于目标地址和网络环境。 - Socket类型 : 决定了Socket的工作模式。常见的Socket类型有
SOCK_STREAM、SOCK_DGRAM和SOCK_RAW。SOCK_STREAM用于可靠的、面向连接的TCP数据传输，而SOCK_DGRAM用于不可靠的、无连接的UDP数据传输。SOCK_RAW提供原始网络协议访问，通常用于开发网络协议的实现。
下面的表格展示了不同类型和协议族的socket组合所适用的场景：
| 协议族 | Socket类型 | 描述 | |--------|------------|------| | PF_INET | SOCK_STREAM | TCP协议（IPv4） | | PF_INET | SOCK_DGRAM | UDP协议（IPv4） | | PF_INET6 | SOCK_STREAM | TCP协议（IPv6） | | PF_INET6 | SOCK_DGRAM | UDP协议（IPv6） | | PF_INET6 | SOCK_RAW | 原始套接字（IPv6） |
2.2 基本Socket函数
2.2.1 socket()的创建
socket() 函数用于创建一个新的socket描述符，它是网络编程中的第一个操作。
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
- domain ：指定协议族，通常用
PF_INET或PF_INET6。 - type ：指定socket类型，比如
SOCK_STREAM。 - protocol ：对于TCP和UDP，通常将其设置为
0，让系统自动选择合适的协议。
创建socket后，通常会得到一个文件描述符，用于后续的函数调用。
接下来，我们会详细探讨 bind() 、 listen() 、 accept() 和 connect() 这些重要的socket函数的使用方法。
3. UNIX/Linux系统编程
UNIX/Linux系统编程涉及与操作系统内核交互的各种高级调用，提供了一种方式来实现资源管理、进程间通信、文件操作和套接字编程等功能。本章将深入探讨UNIX/Linux系统编程的基础知识，着重介绍文件描述符、系统调用与库函数，以及进程和线程的概念与创建。
3.1 系统编程基础
3.1.1 文件描述符
在UNIX/Linux系统中，文件描述符是一个非负整数，用于表示一个打开文件、管道、网络套接字或其他资源。每个进程都有自己的一组文件描述符，由操作系统内核管理。文件描述符通常在使用系统调用进行I/O操作时引用。标准输入、标准输出和标准错误分别对应文件描述符0、1和2。
#include <unistd.h>
#include <stdio.h>
int main() {
// 打印标准输出的文件描述符
printf("Standard Output File Descriptor: %d\n", fileno(stdout));
return 0;
}
在上述代码中， fileno 函数用于获取与特定 FILE 流关联的文件描述符。标准输出的文件描述符输出为1，符合预期。
3.1.2 系统调用与库函数
系统调用是程序向操作系统请求服务的一种方式，它们是由操作系统内核提供的底层接口，比如 read() , write() , open() 和 close() 。系统调用直接与内核通信，运行效率高，但使用起来相对复杂，且通常局限于C语言。
库函数是建立在系统调用之上的封装，提供更易用的接口。例如， fread() 和 fwrite() 是标准C库中的文件读写函数，它们内部可能使用 read() 和 write() 系统调用，但提供了缓冲和更简洁的参数处理。
#include <stdio.h>
int main() {
FILE *fp = fopen("example.txt", "r");
if (fp != NULL) {
// 使用库函数读取文件内容
char buffer[100];
fread(buffer, sizeof(char), 100, fp);
fclose(fp);
}
return 0;
}
3.2 进程和线程
进程和线程是UNIX/Linux系统中实现并发执行的两种基本方式。进程是系统资源分配的基本单位，拥有独立的地址空间；线程则是轻量级的进程，共享进程的地址空间和其他资源。
3.2.1 进程的概念与创建
进程是正在执行的程序的一个实例，它包含了程序代码、变量、打开的文件描述符集合、程序计数器、寄存器和栈等。UNIX/Linux系统通过 fork() 系统调用创建新进程。
#include <stdio.h>
#include <unistd.h>
int main() {
pid_t pid = fork();
if (pid == -1) {
// 创建失败
perror("fork");
} else if (pid == 0) {
// 子进程中
printf("This is the child process with PID: %d\n", getpid());
} else {
// 父进程中
printf("This is the parent process with PID: %d and child PID: %d\n", getpid(), pid);
}
return 0;
}
在这个例子中，调用 fork() 时，新创建的子进程是当前进程的副本，包括所有文件描述符和变量状态。
3.2.2 线程的概念与创建
线程允许并发执行同一程序的不同部分。在UNIX/Linux中，使用 pthread_create() 创建新线程。线程相比进程有着更低的创建和上下文切换开销。
#include <pthread.h>
#include <stdio.h>
void* thread_function(void* arg) {
printf("Hello from the thread!\n");
return NULL;
}
int main() {
pthread_t thread_id;
if (pthread_create(&thread_id, NULL, thread_function, NULL) != 0) {
// 创建失败
perror("pthread_create");
} else {
printf("Thread created successfully!\n");
}
pthread_join(thread_id, NULL);
return 0;
}
以上代码展示了如何创建和启动一个简单的线程。 pthread_create() 创建了一个新线程， pthread_join() 等待线程结束。
在UNIX/Linux系统中，进程和线程是系统编程的核心概念，它们帮助开发者编写更高效、更灵活的程序，以充分利用现代计算资源。下一章将深入讨论服务器端套接字的实现，为连接、数据交互和资源管理提供实践案例。
4. 服务器端套接字实现
4.1 创建套接字
4.1.1 socket()的调用和参数设置
套接字是网络通信的基础，它提供了一种进程间通信的机制。在服务器端，首先要做的就是创建一个套接字。在UNIX/Linux系统中，这可以通过调用 socket() 函数来实现。 socket() 函数是C语言Socket API中的一个核心函数，用于创建一个新的套接字。
以下是 socket() 函数的标准调用形式：
int socket(int domain, int type, int protocol);
-
domain参数指定套接字使用的协议族，例如IPv4使用AF_INET，IPv6使用AF_INET6。 -
type参数指定套接字的类型，对于服务器端来说，常用的类型是SOCK_STREAM，表示基于TCP协议的面向连接的套接字。 -
protocol参数允许你指定在给定协议族和套接字类型下的具体协议。对于SOCK_STREAM类型，通常设置为0，因为该类型通常只对应一种协议（即TCP）。
一个典型的服务器端创建套接字的例子：
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
int main() {
int sockfd;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0) {
perror("socket failed");
exit(1);
}
// 接下来的绑定、监听和接受连接的步骤...
}
在上述代码中，首先包含了必要的头文件。然后，在 main() 函数中创建了一个新的套接字，类型为TCP（ SOCK_STREAM ），并指定了IPv4协议族（ AF_INET ）。如果 socket() 调用成功，它将返回一个非负的整数，即新创建的套接字的文件描述符。如果失败，返回-1，并设置 errno 以表示错误类型。错误处理使用 perror() 函数来打印错误信息，并退出程序。
参数说明 ： - domain ：协议族，可以是 AF_INET 或 AF_INET6 等。 - type ：套接字类型，服务器端多用 SOCK_STREAM 。 - protocol ：指定具体协议，0表示系统默认。
代码逻辑分析 ： 该段代码中，创建套接字的步骤是实现网络服务的第一步。套接字创建后，还需要进一步绑定到一个IP地址和端口上，然后监听这个端口，以接收客户端的连接请求。创建套接字后，服务器端可以继续设置其他参数，并进入监听状态，等待客户端的连接。
4.2 绑定地址
4.2.1 bind()的使用和地址结构配置
服务器端创建套接字后，需要将该套接字绑定到一个地址上，这样才能监听特定的IP地址和端口上的连接请求。这一步骤由 bind() 函数完成。
bind() 函数的原型如下：
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
-
sockfd是socket()函数返回的文件描述符。 -
addr是一个指向sockaddr结构的指针，这个结构包含了要绑定的地址信息。 -
addrlen是地址结构的长度。
对于IPv4，地址结构是 sockaddr_in ，它包含以下成员：
struct sockaddr_in {
sa_family_t sin_family; // 地址族，对于IPv4是AF_INET
in_port_t sin_port; // 端口号，网络字节序
struct in_addr sin_addr; // IP地址，网络字节序
unsigned char sin_zero[8]; // 不使用，应初始化为0
};
服务器端绑定地址的示例代码如下：
#include <arpa/inet.h>
int sockfd;
struct sockaddr_in servaddr;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // 接受任何地址
servaddr.sin_port = htons(12345); // 使用12345端口
if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
perror("bind failed");
exit(1);
}
在这段代码中，首先创建了一个 sockaddr_in 结构体，并将其清零。 sin_family 设置为 AF_INET ， sin_addr 设置为 INADDR_ANY ，表示服务器将接受任何网络接口的连接请求。 sin_port 设置为12345端口（网络字节序）。使用 htons() 函数将端口号从主机字节序转换为网络字节序，以避免字节序问题。
参数说明 ： - sockfd ：由 socket() 函数返回的套接字文件描述符。 - addr ：指向 sockaddr 结构的指针，包含IP和端口信息。 - addrlen ：地址结构的大小。
代码逻辑分析 ： 服务器通过 bind() 函数将套接字绑定到指定的地址和端口上。这样，当网络上出现到这个地址和端口的连接请求时，系统就会将请求传递给对应的套接字。如果 bind() 操作失败，可能是因为指定的端口已被其他进程占用，或者该地址不是一个有效的本地IP地址。出错时，同样需要进行错误处理。
4.3 监听连接
4.3.1 listen()的参数和作用
在服务器端的套接字绑定了地址后，它还需要监听是否有客户端的连接请求。这是通过调用 listen() 函数来实现的。
listen() 函数的原型如下：
int listen(int sockfd, int backlog);
-
sockfd是之前通过socket()创建的套接字文件描述符。 -
backlog是一个整数值，它指定了操作系统内核可以接受的、但尚未被accept()处理的最大连接数。
调用 listen() 函数后，服务器端的套接字就进入了被动监听状态，可以接受来自客户端的连接请求。当有新的连接请求到达时，内核将创建一个新的套接字来处理这个连接，并将新套接字加入到内部的连接请求队列中。
以下是 listen() 函数的一个使用示例：
#define BACKLOG 10 // 同时可以处理的连接请求个数
if (listen(sockfd, BACKLOG) < 0) {
perror("listen failed");
exit(1);
}
在上述代码中，定义了一个名为 BACKLOG 的宏，表示内核接受队列的最大长度。如果 listen() 函数调用成功，服务器端的套接字就会开始监听指定端口上的连接请求。如果失败，则输出错误信息并退出。
参数说明 ： - sockfd ：由 socket() 函数返回的文件描述符。 - backlog ：最大队列长度，定义了内核中可以排队的最大连接数。
代码逻辑分析 ： listen() 函数为服务器端套接字开启了监听模式，使得该套接字能够接收连接请求。 backlog 参数是非常重要的，它决定了系统可以保存多少个未被接受的连接请求。如果队列满，内核将拒绝新的连接请求，直到队列中的某个请求被 accept() 函数处理。如果 listen() 失败，通常是因为套接字并没有绑定到一个地址上，或者 backlog 参数的值不合法。错误处理是必要的，因为它可以提示开发者及时纠正配置错误。
5. 客户端套接字实现
5.1 创建套接字
5.1.1 socket()的调用和参数设置
客户端与服务器之间的通信起点是套接字的创建。在UNIX/Linux系统中，客户端套接字的创建通常使用 socket() 函数，该函数不仅创建了一个套接字，还为其指定了一个地址族、套接字类型以及协议。地址族通常指的是IP协议族，即 AF_INET 。套接字类型通常为 SOCK_STREAM ，表示使用TCP协议进行面向连接的可靠数据传输。
在实际的代码实现中， socket() 函数的基本调用格式如下：
int socket(int domain, int type, int protocol);
其中， domain 参数指定了通信的协议族，对于TCP/IP通信来说，该参数通常是 AF_INET 。 type 参数指定了套接字的类型，对于面向连接的TCP协议来说，该参数为 SOCK_STREAM 。 protocol 参数通常设为 0 ，让系统自动选择所需的协议。
下面是一个简单的示例代码，展示了如何在C语言中创建一个TCP客户端套接字：
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
int main() {
int sock;
struct sockaddr_in server_addr;
socklen_t server_addr_len = sizeof(server_addr);
// 创建一个TCP套接字
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror("socket error");
return -1;
}
// ...后续连接服务器的步骤
}
在这个例子中，我们首先包含了必要的头文件，然后在 main() 函数中定义了套接字描述符 sock 。 socket() 函数调用创建了一个新的套接字并将其与TCP/IP协议族关联起来，返回套接字描述符存储在 sock 变量中。如果 socket() 调用失败，将返回负值，并输出错误信息。
创建套接字只是客户端与服务器建立连接的第一步。在创建套接字后，客户端需要指定要连接的服务器地址和端口，然后使用 connect() 函数发起连接请求。这一过程将在下一部分详细介绍。
6. 多路复用I/O机制
6.1 select()机制
6.1.1 select()的原理和使用方法
select()是UNIX/Linux系统编程中用于实现I/O多路复用的一个函数。它允许单个进程监视多个文件描述符，当任何一个文件描述符准备好读写操作时，select()会返回，告知调用者哪些文件描述符可以进行操作。这种机制提高了程序处理多个并发网络连接的能力，因为它允许使用单一的线程来管理多个网络连接，而不是为每个连接创建一个单独的线程。
select()的基本原理是通过三个集合来跟踪文件描述符的状态变化：readfds（读取）、writefds（写入）和exceptfds（异常条件）。这三个集合通过fd_set类型来定义。select()的调用者需要设置这些集合，然后传递给select()函数。select()会阻塞当前线程，直到集合中的任一文件描述符状态发生变化，或者超时发生，或者达到文件描述符的上限。
使用select()的步骤通常包括： 1. 初始化fd_set集合，并将所有需要监视的文件描述符加入到相应的集合中。 2. 调用select()函数，并传入三个fd_set集合的指针，以及超时时间。 3. select()返回后，检查每个集合中的文件描述符，以确定哪些文件描述符已就绪。 4. 清空fd_set集合，并重复第一步，以便进行下一轮监视。
下面是一个简化的select()函数的使用示例代码：
#include <sys/select.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int main() {
fd_set readfds;
struct timeval tv;
int retval;
// 清空文件描述符集合
FD_ZERO(&readfds);
// 将文件描述符1加入集合
FD_SET(1, &readfds);
// 设置超时时间
tv.tv_sec = 5;
tv.tv_usec = 0;
// 等待文件描述符1可读
retval = select(1, &readfds, NULL, NULL, &tv);
// 检查select()是否超时
if (retval == 0) {
printf("select() timeout\n");
return 1;
} else if (retval > 0) {
// 文件描述符1可读，可以进行I/O操作
if (FD_ISSET(1, &readfds)) {
char buf[1024];
read(1, buf, sizeof(buf));
printf("Read from file descriptor: %s\n", buf);
}
} else {
// select()出错
perror("select()");
return 2;
}
return 0;
}
在这段代码中，我们首先定义了一个fd_set类型的变量readfds，并用FD_ZERO()宏将所有位清零。之后，FD_SET()宏被用于将文件描述符1加入到集合中。我们还设置了一个超时结构体tv，设置了5秒的等待时间。select()调用后，通过检查返回值和FD_ISSET()宏的使用，我们可以确定文件描述符1是否有可读数据。
需要注意的是，select()虽然可以在旧的UNIX/Linux系统上运行良好，但在处理大量文件描述符时，它会显现出效率问题，因为它必须遍历整个文件描述符集合来确定哪些描述符是活跃的。另外，每次调用select()后，fd_set集合中的信息会丢失，因此每次调用之前都要重新填充集合，这也是它的局限之一。
select()的局限性导致了其他机制如poll()和epoll()的出现，它们提供了更高效的方式来处理大量并发的I/O事件。尽管如此，select()依然在许多场合下被使用，特别是因为它简单易用且具有跨平台的特性。
7. client.c 和 server.c 代码示例
在前面的章节中，我们已经介绍了TCP协议、Socket API的使用、UNIX/Linux系统编程、服务器端和客户端套接字的实现以及多路复用I/O机制。本章，我们将深入探讨 server.c 和 client.c 这两个实际的代码示例。通过分析这两个程序的主要函数和流程，我们将更具体地了解网络编程的实际应用。
7.1 服务器端代码剖析
服务器端的主要任务是监听端口，接受客户端的连接请求，并为每个连接创建一个新的进程或者线程来处理客户端的请求。下面是一个简单的 server.c 程序示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
#define PORT 8888
int main() {
int serv_sock, clnt_sock;
char message[] = "Hello, World!";
char buf[BUF_SIZE];
int str_len;
socklen_t clnt_adr_sz;
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&clnt_adr, 0, sizeof(clnt_adr));
clnt_adr.sin_family = AF_INET;
clnt_adr.sin_addr.s_addr = htonl(INADDR_ANY);
clnt_adr.sin_port = htons(PORT);
bind(serv_sock, (struct sockaddr*)&clnt_adr, sizeof(clnt_adr));
listen(serv_sock, 5);
clnt_adr_sz = sizeof(clnt_adr);
clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &clnt_adr_sz);
read(clnt_sock, buf, BUF_SIZE);
printf("Message from client: %s\n", buf);
write(clnt_sock, message, strlen(message));
close(clnt_sock);
close(serv_sock);
return 0;
}
7.2 客户端代码剖析
客户端的任务相对简单，主要是在成功建立连接之后，向服务器发送数据并接收服务器的响应。下面是一个简单的 client.c 程序示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
#define PORT 8888
int main() {
int sock;
char message[] = "Hello, Server!";
char buf[BUF_SIZE];
struct sockaddr_in serv_addr;
sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
serv_addr.sin_port = htons(PORT);
connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
write(sock, message, strlen(message));
read(sock, buf, BUF_SIZE);
printf("Message from server: %s\n", buf);
close(sock);
return 0;
}
7.3 代码实践中的问题与解决方案
在实际编写和运行 client.c 和 server.c 时，可能会遇到各种问题，如连接失败、数据传输错误等。本节将讨论一些常见的错误类型以及调试技巧。
7.3.1 常见错误分析和调试技巧
- 错误类型1: "Address already in use" 当尝试运行服务器程序时，可能会遇到“Address already in use”的错误。这通常是因为之前的服务器实例没有正确关闭，或者端口仍被占用。解决这个问题可以使用
setsockopt()设置SO_REUSEADDR选项，允许重用本地地址和端口。
int opt = 1;
setsockopt(serv_sock, SOL_SOCKET, SO_REUSEADDR, (void*)&opt, sizeof(opt));
-
错误类型2: "Connection refused" 当客户端尝试连接服务器时，如果服务器没有运行或者无法访问，会出现“Connection refused”的错误。确保服务器已经启动，并且防火墙设置允许相应的连接。
-
错误类型3: 数据传输错误 数据在传输过程中可能会出现截断或乱码。确保使用
send()和recv()而不是write()和read()来处理套接字，因为后者不会自动处理数据分片。 -
调试技巧
- 使用
strace跟踪系统调用。 - 使用
tcpdump捕获网络包，分析网络数据流。 - 在关键的网络函数前后打印日志，以便于跟踪程序执行流程。 以上是
client.c和server.c代码示例的分析，包括服务器端和客户端程序的主要函数、流程以及在实际应用中可能遇到的问题和解决策略。掌握这些基本的网络编程知识，将有助于您在IT领域中进行更深入的探索和应用。
简介：本文详细介绍如何在C语言中实现TCP服务器和客户端套接字编程。我们首先解释TCP协议的基础，然后通过具体步骤指导读者创建和管理TCP连接，包括创建套接字、绑定地址、监听、接受连接、数据传输以及关闭连接。文章还涵盖了UNIX/Linux系统下Socket API的使用，并通过 client.c 和 server.c 的示例代码加深理解。
扫一扫
506
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
