TCP 协议的基本概念、特征及报文格式，详细解析了三次握手与四次挥手过程。内容涵盖 TCP 状态机、常用 Socket 函数（socket、bind、listen、accept 等）、字节序转换以及缓冲区机制。最后提供了基于多线程和多进程的多连接服务端 C 语言示例代码，帮助读者理解 Linux 网络编程的核心实现。
#include <sys/socket.h>
#include <sys/types.h>
/**
* @brief 在通信域中创建一个未绑定的 socket，并返回一个文件描述符，该描述符可以在后续对 socket 进行操作的函数调用中使用
*
* @param domain 指定要创建套接字的通信域。
* AF_INET：IPv4 互联网协议。
* @param type 指定要创建的 socket 类型
* SOCK_STREAM：提供序列化、可靠的、双向的、基于连接的字节流。可以支持带外数据传输机制。
* SOCK_DGRAM：支持数据报（无连接、不可靠的固定最大长度的消息）。
* @param protocol 通常写 0，让系统自动选择默认协议
* @return int 文件描述符，如果失败返回 -1
*/
int socket(int domain, int type, int protocol);
/**
* @param sockfd 套接字文件描述符
* @param addr 指定的地址。地址的长度和格式取决于 socket 的地址族
* @param addrlen addr 指向的地址结构的大小（以字节为单位）。
* @return int 成功 0
* 失败 -1
*/
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
sockaddr_in，最后写回去函数需要强制转换。sin_family 一般使用 AF_INET，代表 IPv4 网络协议的地址族，使用 32 位地址，主要用于互联网上的通信。地址格式通常为点分十进制，如 192.168.1.1。sin_addr 比较特别不能直接赋值，需要使用相关函数去转换 IP 地址。/**
* @brief 将 sockfd 指定的套接字标记为被动套接字，即将用于使用 accept 接受传入的连接请求。
*
* @param sockfd 套接字文件描述符
* @param backlog 指定还未 accept 但是已经完成链接的队列长度 (说明最多有多少个客户端连接)。
* @return int 成功 0
* 失败 -1
*/
int listen(int sockfd, int backlog);
/**
* @brief 从监听套接字 sockfd 的待处理连接队列中提取第一个连接请求，创建一个新的连接套接字，并返回指向该套接字的新文件描述符。新创建的套接字不处于监听状态。原始套接字 sockfd 不受此调用的影响。
*
* @param sockfd 一个使用 socket 创建、使用 bind 绑定到本地地址，并在 listen 后监听连接的套接字。
* @param addr 要么是一个空指针，要么是一个指向 sockaddr 结构的指针，用于返回连接 socket 的地址。
* @param addrlen 如果 address 是空指针，则为一个空指针；如果 address 不是空指针，则为一个指向 socklen_t 对象的指针，该对象在调用前指定提供的 sockaddr 结构的长度，并在调用后指定存储地址的长度。
* @return int 返回一个新的套接字文件描述符，用于与客户端通信，如果失败返回 -1，并设置 errno 来表示错误原因
*/
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
/**
* @brief 由客户端调用，来与服务端建立连接。
*
* @param sockfd 客户端套接字的文件描述符
* @param addr 指向 sockaddr 结构体的指针，包含目的地地址信息
* @param addrlen 指定 addr 指向的结构体的大小
* @return int 成功 0
* 失败 -1，并设置 errno 以指示错误原因
*/
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
/**
* @brief 用于向另一个套接字传输消息。
*
* @param sockfd 发送套接字的文件描述符。
* @param buf 发送缓冲区，并非操作系统分配为服务端和客户端分配的缓冲区，而是用户为了发送数据，自己维护的字节序列。const 修饰表名它是'只读'的，即 send 函数不会修改这块内存的内容。
* @param len 要发送的数据的字节长度。它决定了从 buf 指向的缓冲区中将发送多少数据。
* @param flags flags 参数是以下标志之一或多个的按位或。对于大多数应用，这个参数被设置为 0，表示不使用任何特殊行为。
* @return ssize_t 成功发送的字节数。如果出现错误，它将返回 -1，并设置 errno 以指示错误的具体原因。
*/
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
/**
* @brief 从套接字关联的连接中接收数据。
*
* @param sockfd 套接字文件描述符。
* @param buf 接收缓冲区，同样地，此处也并非内核维护的缓冲区。
* @param len 缓冲区长度，即 buf 可以接收的最大字节数。
* @param flags flags 参数是以下标志之一或多个的按位或。对于大多数应用，这个参数被设置为 0，表示不使用任何特殊行为。
* @return ssize_t 返回接收到的字节数，如果连接已经正常关闭，返回值将是 0。如果出现错误，返回 -1，并且 errno 变量将被设置为指示错误的具体原因。
*/
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
/**
* @brief 关闭套接字的一部分或全部连接
*
* @param sockfd 套接字文件描述符
* @param how 指定关闭的类型。其取值如下：
* SHUT_RD：关闭读。之后，该套接字不再接收数据。任何当前阻塞在 recv 调用上的操作都将返回 0，表示连接的另一端已经关闭。
* SHUT_WR：关闭写。之后，试图通过该套接字发送数据将导致错误。如果使用此选项，TCP 连接将发送一个 FIN 包给连接的对端，表明此方向上的数据传输已经完成。此时对端的 recv 调用将接收到 0。
* SHUT_RDWR：关闭读写。同时关闭套接字的读取和写入部分，等同于分别调用 SHUT_RD 和 SHUT_WR。之后，该套接字既不能接收数据也不能发送数据。
* @return int 成功 0
* 失败 -1，并设置 errno 变量以指示具体的错误原因。
*/
int shutdown(int sockfd, int how);
#include <unistd.h> /* 用于关闭一个之前通过 open()、socket() 等函数打开的文件描述符
int __fd: 这是一个整数值，表示要关闭的文件描述符
return: 成功关闭文件描述符时，close() 函数返回 0
发送失败，例如试图关闭一个已经关闭的文件描述符或系统资源不足，close() 会返回 -1
*/
int close(int __fd);
#include <arpa/inet.h>
/**
* @brief 将无符号整数 hostlong 从主机字节顺序（h）转换为网络字节顺序（n）。
*/
uint32_t htonl(uint32_t hostlong);
/**
* @brief 将无符号短整数 hostshort 从主机字节顺序（h）转换为网络字节顺序 (n）。
*/
uint16_t htons(uint16_t hostshort);
/**
* @brief 将无符号整数 netlong 从网络字节顺序（n）转换为主机字节顺序（h）。
*/
uint32_t ntohl(uint32_t netlong);
/**
* @brief 将无符号短整数 netshort 从网络字节顺序（n）转换为主机字节顺序（h）。
*/
uint16_t ntohs(uint16_t netshort);
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/**
* @brief 将来自 IPv4 点分十进制表示法的 Internet 主机地址 cp 转换为二进制形式（以网络字节顺序）并将其存储在 inp 指向的结构体中。
* @return int 成功返回 1;失败 返回 0
*/
int inet_aton(const char *cp, struct in_addr *inp);
/**
* @brief 将来自 IPv4 点分十进制表示法的 Internet 主机地址 cp 转换为网络字节顺序的二进制数据。
* @return 如果输入无效，则返回 INADDR_NONE（通常为 -1）。使用此函数存在问题，因为 -1 是一个有效地址（255.255.255.255）。请优先使用 inet_aton()、inet_pton() 或 getaddrinfo()，它们提供了更清晰的错误返回方式。
*/
in_addr_t inet_addr(const char *cp);
/**
* @brief 函数将字符串 cp（以 IPv4 点分十进制表示法表示）转换为适合用作 Internet 网络地址的主机字节顺序中的数字。
* @return in_addr_t 成功时，返回转换后的地址。如果输入无效，则返回 -1。
*/
in_addr_t inet_network(const char *cp);
/* @brief 字符串格式转换为 sockaddr_in 格式
@param int af: 通常为 AF_INET 用于 IPv4 地址，或 AF_INET6 用于 IPv6 地址
@param char *src: 包含 IP 地址字符串的字符数组，如果是 IPv4 地址，格式为点分十进制（如 "192.168.1.1"）；如果是 IPv6 地址，格式为冒号分隔的十六进制表示（如 "2001:0db8:85a3:0000:0000:8a2e:0370:7334"）
@param void *dst：指向一个足够大的缓冲区（对于 IPv4 是一个 struct in_addr 结构体，对于 IPv6 是一个 struct in6_addr 结构体），用于存储转换后的二进制 IP 地址
@return int : 成功转换返回 0; 输入地址错误返回 1;发生错误返回 -1
*/
int inet_pton(int af, const char *src, void *dst);
/**
* @brief *
* @param in 将以网络字节顺序给出的 Internet 主机地址 in 转换为 IPv4 点分十进制表示法的字符串。字符串存储在静态分配的缓冲区中，后续调用将覆盖该缓冲区。
* @return char* 缓冲区指针
*/
char *inet_ntoa(struct in_addr in);
/**
* @brief 是 inet_netof() 和 inet_lnaof() 的反函数。它返回一个以网络字节顺 序表示的 Internet 主机地址，由主机字节顺序中的网络号 net 和本地地址 host 组成。
*/
struct in_addr inet_makeaddr(in_addr_t net, in_addr_t host);
/**
* @brief 返回 Internet 地址 in 的本地网络地址部分。返回的值以主机字节顺序表示。
*/
in_addr_t inet_lnaof(struct in_addr in);
/**
* @brief 返回 Internet 地址 in 的网络号部分。返回的值以主机字节顺序表示。
*/
in_addr_t inet_netof(struct in_addr in);
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
int main(int argc, char const *argv[]) {
unsigned short local_num = 0x1f,net_num;
net_num = htons(local_num);//本地转换网络
printf("本地数据 0x%x 转换为网络数据 0x%x\n",local_num,net_num);
local_num = ntohs(net_num);//网络转换为本地
printf("网络数据 0x%x 转换为本地数据 0x%x\n",net_num,local_num);
return 0;
}
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <pthread.h>
int main(int argc, char const *argv[]) {
printf("192.168.6.101 的十六进制为 0x%X 0x%X 0x%X 0x%X\n",192,168,6,101);
// 网络地址赋值，保存
struct sockaddr_in server_in;
struct in_addr server_addr_in;
in_addr_t server_in_addr_t;
//inet_aton
inet_aton("192.168.6.101",&server_addr_in);
//转化为十六进制是为了方便理解
printf("经过 inet_aton 转化之后的 IP 地址为 0x%x\n",server_addr_in.s_addr);
//inet_addr，不推荐使用，因为输入 -1 返回的地址是一个有效地址（255.255.255.255）
server_in_addr_t = inet_addr("192.168.6.101");
printf("经过 inet_addr 转化之后的 IP 地址为 0x%x\n",server_in_addr_t);
//inet_pton，这个可是指定协议
inet_pton(AF_INET,"192.168.6.101",&(server_in.sin_addr));
printf("经过 inet_pton 转化之后的 IP 地址为 0x%x\n",server_in.sin_addr.s_addr);
//inet_ntoa
printf("经过 inet_pton 转化之后的 IP 地址为%s\n",inet_ntoa(server_addr_in));
//inet_lnaof 本地号
printf("inet_lnaof:0x%X\n",inet_lnaof(server_addr_in));
//inet_netof 网络号
printf("inet_netof:0x%X\n",inet_netof(server_addr_in));
//inet_makeaddr
struct in_addr tmp = inet_makeaddr(inet_netof(server_addr_in),inet_lnaof(server_addr_in));
printf("通过 inet_makeaddr 拼接之后为 0x%X\n",tmp.s_addr);
printf("通过 inet_makeaddr 拼接之后为%s\n",inet_ntoa(tmp));
return 0;
}
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unistd.h>
#define handle_error(cmd, result) \
if (result < 0) { \
perror(cmd); \
return -1; \
}
void * read_from_server(void * arg){
int client_fd = *(int *)arg;
char * read_buf = NULL;
read_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!read_buf){ perror("malloc"); shutdown(client_fd,SHUT_RD); free(read_buf); return NULL; }
while((count = recv(client_fd,read_buf,1024,0)) > 0){
fputs(read_buf,stdout);
memset(read_buf,0,sizeof(read_buf));
}
free(read_buf);
shutdown(client_fd,SHUT_RD);
}
void * write_to_server(void * arg){
int client_fd = *(int *)arg;
char * write_buf = NULL;
write_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!write_buf){ perror("malloc"); free(write_buf); shutdown(client_fd,SHUT_WR); return NULL; }
while(fgets(write_buf,1024,stdin) != NULL){
count = send(client_fd,write_buf,1024,0);
if(count < 0){ perror("send"); break; }
}
free(write_buf);
shutdown(client_fd,SHUT_WR);
}
int main(int argc, char const *argv[]) {
int socketfd,tmp_result;
//定义两个结构体，一个表示服务端，一个是客户端的
struct sockaddr_in server_in,client_in;
//清空
memset(&server_in,0,sizeof(server_in));
memset(&client_in,0,sizeof(client_in));
//设置客户端的 IP
client_in.sin_family = AF_INET;
client_in.sin_port = htons(8888);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"192.168.136.101",&(client_in.sin_addr));
//设置 IP 和端口
server_in.sin_family = AF_INET;
server_in.sin_port = htons(6666);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"0.0.0.0",&(server_in.sin_addr));
//socket
socketfd = socket(AF_INET,SOCK_STREAM,0);
handle_error("socket",socketfd);
//bind 绑定
tmp_result = bind(socketfd,(struct sockaddr *)&client_in,sizeof(client_in));
handle_error("bind",tmp_result);
//connect 客户端主动连接
tmp_result = connect(socketfd,(struct sockaddr *)&server_in,sizeof(server_in));
handle_error("connect",tmp_result);
printf("连接成功，服务端的 IP 为%s，端口号为%d\n",inet_ntoa(server_in.sin_addr),ntohs(server_in.sin_port));
pthread_t read_pid,write_pid;
pthread_create(&read_pid,NULL,read_from_server,(void *)&socketfd);
pthread_create(&write_pid,NULL,write_to_server,(void *)&socketfd);
pthread_join(read_pid,NULL);
pthread_join(write_pid,NULL);
//客户端连接上了
//printf("客户端的地址为%s，端口号为%d\n",inet_ntoa(server_in.sin_addr),ntohs(server_in.sin_port));
close(socketfd);
return 0;
}
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unistd.h>
#define handle_error(cmd, result) \
if (result < 0) { \
perror(cmd); \
return -1; \
}
// 使用 recv 接收客户端发送的数据 打印到控制台
void * read_from_client(void * arg){
int client_fd = *(int *)arg;
char * read_buf = NULL;
read_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!read_buf){ perror("malloc"); shutdown(client_fd,SHUT_RD); free(read_buf); return NULL; }
while((count = recv(client_fd,read_buf,1024,0)) > 0){
fputs(read_buf,stdout);
memset(read_buf,0,sizeof(read_buf));
}
free(read_buf);
shutdown(client_fd,SHUT_RD);
}
// 接收控制台输入的信息 写出去
void * write_to_client(void * arg){
int client_fd = *(int *)arg;
char * write_buf = NULL;
write_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!write_buf){ perror("malloc"); free(write_buf); shutdown(client_fd,SHUT_WR); return NULL; }
while(fgets(write_buf,1024,stdin) != NULL){
count = send(client_fd,write_buf,1024,0);
if(count < 0){ perror("send"); break; }
}
free(write_buf);
shutdown(client_fd,SHUT_WR);
}
int main(int argc, char const *argv[]) {
int socketfd,tmp_result,client_fd;
//定义两个结构体，一个表示服务端，一个是客户端的
struct sockaddr_in server_in,client_in;
//清空
memset(&server_in,0,sizeof(server_in));
memset(&client_in,0,sizeof(client_in));
//设置 IP 和端口
server_in.sin_family = AF_INET;
server_in.sin_port = htons(6666);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"0.0.0.0",&(server_in.sin_addr));
//socket
socketfd = socket(AF_INET,SOCK_STREAM,0);
handle_error("socket",socketfd);
//bind 绑定
tmp_result = bind(socketfd,(struct sockaddr *)&server_in,sizeof(server_in));
handle_error("bind",tmp_result);
//listen 监听
tmp_result = listen(socketfd,128);
handle_error("listen",tmp_result);
//accept
int client_len = sizeof(client_in);
client_fd = accept(socketfd,(struct sockaddr *)&client_in,&client_len);
handle_error("client",client_fd);
//连接成功的时候
printf("客户端的地址为%s，端口号为%d\n",inet_ntoa(client_in.sin_addr),ntohs(client_in.sin_port));
pthread_t read_pid,write_pid;
pthread_create(&read_pid,NULL,read_from_client,(void *)&client_fd);
pthread_create(&write_pid,NULL,write_to_client,(void *)&client_fd);
pthread_join(read_pid,NULL);
pthread_join(write_pid,NULL);
//客户端连接上了
close(client_fd);
close(socketfd);
return 0;
}
#include <stdio.h>
/**
* @brief 设置文件流的缓冲模式
*
* @param stream 要设置的文件流，可以是输入缓冲流也可以是输出缓冲流
* @param buf 指向缓冲区的指针，这个参数为 NULL 则自动分配缓冲区。
* @param mode 缓冲区模式
* _IOFBF：全缓冲，数据会存储在缓冲区中直到缓冲区满。
* _IOLBF：行缓冲，数据会存储在缓冲区中直到碰到换行符或缓冲区满。
* _IONBF：无缓冲，输出操作将直接从调用进程到目标设备，不经过缓冲区。
* @param size 缓冲区大小，以字节为单位。size 为 0 时，
* 如果 buf 为 NULL，则标准 C 库将为该文件流自动分配一个默认大小的缓冲区
* 如果 buf 不为 NULL，将 size 设置为 0 不合逻辑，行为是未定义的
* @return int 成功返回 0，失败返回非零值
*/
int setvbuf(FILE *stream, char *buf, int mode, size_t size);
#include <stdio.h>
/**
* fflush() 强制刷新缓冲区
* @param stream 待刷新的数据流，如果为 NULL，则刷新所有打开的输出流。
* @return int 成功返回 0.失败返回 EOF，并设置 errno
*/
int fflush(FILE *stream);
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
int main(int argc, char const *argv[]) {
FILE * fp = fopen("./testfile.txt","w");
if(fp == NULL){ perror("fopen"); return 1; }
//默认是全缓冲，正常退出会写入到文件
//方法 1，在摧毁前，改变缓冲模式，变为没有缓冲
setvbuf(fp,NULL,_IONBF,0);
fprintf(fp,"hello");
// //方法二，手动刷新
// fflush(fp);
//方法三，在 fprintf 加上\n，并且需要改为行模式
// setvbuf(fp,NULL,_IOLBF,0);
// fprintf(fp,"hello\n");
//但是摧毁前面的代码，就不会写入的
char * args[] = {"/usr/bin/ls","-l",NULL};
char * envs[] = {NULL};
execve(args[0],args,envs);
perror("execve");
return 0;
}
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unistd.h>
#define handle_error(cmd, result) \
if (result < 0) { \
perror(cmd); \
return -1; \
}
// 读取客户端发送过来的数据 回复收到
void * read_from_client_then_write_OK(void * arg){
int client_fd = *(int *)arg;
char * read_buf = NULL;
char * write_buf = NULL;
read_buf = malloc(sizeof(char) * 1024);
write_buf = malloc(sizeof(char) * 1024);
ssize_t read_count,write_count;
if(read_buf == NULL){ perror("read_buf malloc"); close(client_fd); return NULL; }
if(write_buf == NULL){ perror("write_buf malloc"); close(client_fd); return NULL; }
while(read_count = recv(client_fd,read_buf,1024,0)){
if(read_count < 0){ perror("recv:"); return NULL; }
if(read_count == 0){ close(client_fd); free(read_buf); free(write_buf); return NULL; }
printf("从客户端%d读取到的数据为%s\n",client_fd,read_buf);
strcpy(write_buf,"收到");
write_count = send(client_fd,write_buf,1024,0);
if(write_count < 0){ perror("send"); }
}
// 当客户端输入 ctrl + d 时会退出循环
free(read_buf);
free(write_buf);
close(client_fd);
}
int main(int argc, char const *argv[]) {
int socketfd,tmp_result;
//定义两个结构体，一个表示服务端，一个是客户端的
struct sockaddr_in server_in,client_in;
//清空
memset(&server_in,0,sizeof(server_in));
memset(&client_in,0,sizeof(client_in));
//设置 IP 和端口
server_in.sin_family = AF_INET;
server_in.sin_port = htons(6666);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"0.0.0.0",&(server_in.sin_addr));
//socket
socketfd = socket(AF_INET,SOCK_STREAM,0);
handle_error("socket",socketfd);
//bind 绑定
tmp_result = bind(socketfd,(struct sockaddr *)&server_in,sizeof(server_in));
handle_error("bind",tmp_result);
//listen 监听
tmp_result = listen(socketfd,128);
handle_error("listen",tmp_result);
//accept
int client_len = sizeof(client_in);
while (1){
int client_fd = accept(socketfd,(struct sockaddr *)&client_in,&client_len);
handle_error("client",client_fd);
//连接成功的时候
// 和每一个客户端使用一个线程交互 把客户端发送的信息打印到控制台 回复收到
printf("客户端的地址为%s，端口号为%d\n",inet_ntoa(client_in.sin_addr),ntohs(client_in.sin_port));
pthread_t read_write_pid;
if(pthread_create(&read_write_pid,NULL,read_from_client_then_write_OK,(void *)&client_fd)){ perror("pthread_create"); continue; }
// 需要等待线程结束 但是不能挂起等待
pthread_detach(read_write_pid);
}
close(socketfd);
return 0;
}
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unistd.h>
#define handle_error(cmd, result) \
if (result < 0) { \
perror(cmd); \
return -1; \
}
void * read_from_server(void * arg){
int client_fd = *(int *)arg;
char * read_buf = NULL;
read_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!read_buf){ perror("malloc"); shutdown(client_fd,SHUT_RD); free(read_buf); return NULL; }
while((count = recv(client_fd,read_buf,1024,0)) > 0){
fputs(read_buf,stdout);
fputs("\n",stdout);
memset(read_buf,0,sizeof(read_buf));
}
free(read_buf);
shutdown(client_fd,SHUT_RD);
}
void * write_to_server(void * arg){
int client_fd = *(int *)arg;
char * write_buf = NULL;
write_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!write_buf){ perror("malloc"); free(write_buf); shutdown(client_fd,SHUT_WR); return NULL; }
while(fgets(write_buf,1024,stdin) != NULL){
count = send(client_fd,write_buf,1024,0);
if(count < 0){ perror("send"); break; }
}
free(write_buf);
shutdown(client_fd,SHUT_WR);
}
int main(int argc, char const *argv[]) {
int socketfd,tmp_result;
//定义两个结构体，一个表示服务端，一个是客户端的
struct sockaddr_in server_in,client_in;
//清空
memset(&server_in,0,sizeof(server_in));
memset(&client_in,0,sizeof(client_in));
//设置客户端的 IP
client_in.sin_family = AF_INET;
client_in.sin_port = htons(8888);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"192.168.136.101",&(client_in.sin_addr));
//设置 IP 和端口
server_in.sin_family = AF_INET;
server_in.sin_port = htons(6666);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"0.0.0.0",&(server_in.sin_addr));
//socket
socketfd = socket(AF_INET,SOCK_STREAM,0);
handle_error("socket",socketfd);
//bind 绑定，自动分配
// 客户端可以不绑定 系统会自动分配一个空闲的端口号给客户端
// tmp_result = bind(socketfd,(struct sockaddr *)&client_in,sizeof(client_in));
// handle_error("bind",tmp_result);
//connect 客户端主动连接
tmp_result = connect(socketfd,(struct sockaddr *)&server_in,sizeof(server_in));
handle_error("connect",tmp_result);
printf("连接成功，服务端的 IP 为%s，端口号为%d\n",inet_ntoa(server_in.sin_addr),ntohs(server_in.sin_port));
pthread_t read_pid,write_pid;
pthread_create(&read_pid,NULL,read_from_server,(void *)&socketfd);
pthread_create(&write_pid,NULL,write_to_server,(void *)&socketfd);
pthread_join(read_pid,NULL);
pthread_join(write_pid,NULL);
//客户端连接上了
//printf("客户端的地址为%s，端口号为%d\n",inet_ntoa(server_in.sin_addr),ntohs(server_in.sin_port));
close(socketfd);
return 0;
}
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>
#define handle_error(cmd, result) \
if (result < 0) { \
perror(cmd); \
return -1; \
}
// 读取客户端发送过来的数据 回复收到
void * read_from_client_then_write_OK(void * arg){
int client_fd = *(int *)arg;
char * read_buf = NULL;
char * write_buf = NULL;
read_buf = malloc(sizeof(char) * 1024);
write_buf = malloc(sizeof(char) * 1024);
ssize_t read_count,write_count;
if(read_buf == NULL){ perror("read_buf malloc"); close(client_fd); return NULL; }
if(write_buf == NULL){ perror("write_buf malloc"); close(client_fd); return NULL; }
while(read_count = recv(client_fd,read_buf,1024,0)){
if(read_count < 0){ perror("recv:"); return NULL; }
if(read_count == 0){ close(client_fd); free(read_buf); free(write_buf); return NULL; }
printf("从客户端%d读取到的数据为%s\n",client_fd,read_buf);
strcpy(write_buf,"收到");
write_count = send(client_fd,write_buf,1024,0);
if(write_count < 0){ perror("send"); }
}
// 当客户端输入 ctrl + d 时会退出循环
free(read_buf);
free(write_buf);
close(client_fd);
}
void zombie_dealer(int sig) {
pid_t pid;
int status;
// 一个 SIGCHLD 可能对应多个子进程的退出
// 使用 while 循环回收所有退出的子进程，避免僵尸进程的出现
while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
if (WIFEXITED(status)) {
printf("子进程：%d 以 %d 状态正常退出，已被回收\n", pid,WEXITSTATUS(status));
} else if (WIFSIGNALED(status)) {
printf("子进程：%d 被 %d 信号杀死，已被回收\n", pid,WTERMSIG(status));
} else {
printf("子进程：%d 因其它原因退出，已被回收\n", pid);
}
}
}
int main(int argc, char const *argv[]) {
//注册信号
signal(SIGCHLD,zombie_dealer);
int socketfd,tmp_result;
//定义两个结构体，一个表示服务端，一个是客户端的
struct sockaddr_in server_in,client_in;
//清空
memset(&server_in,0,sizeof(server_in));
memset(&client_in,0,sizeof(client_in));
//设置 IP 和端口
server_in.sin_family = AF_INET;
server_in.sin_port = htons(6666);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"0.0.0.0",&(server_in.sin_addr));
//socket
socketfd = socket(AF_INET,SOCK_STREAM,0);
handle_error("socket",socketfd);
//bind 绑定
tmp_result = bind(socketfd,(struct sockaddr *)&server_in,sizeof(server_in));
handle_error("bind",tmp_result);
//listen 监听
tmp_result = listen(socketfd,128);
handle_error("listen",tmp_result);
//accept
int client_len = sizeof(client_in);
while (1){
int client_fd = accept(socketfd,(struct sockaddr *)&client_in,&client_len);
handle_error("client",client_fd);
//连接成功的时候
int pid = fork();
if(pid < 0){ perror("fork"); }
else if(pid == 0){
close(socketfd);
printf("客户端的地址为%s，端口号为%d\n",inet_ntoa(client_in.sin_addr),ntohs(client_in.sin_port));
read_from_client_then_write_OK((void *)&client_fd);
close(client_fd);
exit(EXIT_SUCCESS);
}
else { close(client_fd); }
}
close(socketfd);
return 0;
}
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <unistd.h>
#define handle_error(cmd, result) \
if (result < 0) { \
perror(cmd); \
return -1; \
}
void * read_from_server(void * arg){
int client_fd = *(int *)arg;
char * read_buf = NULL;
read_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!read_buf){ perror("malloc"); shutdown(client_fd,SHUT_RD); free(read_buf); return NULL; }
while((count = recv(client_fd,read_buf,1024,0)) > 0){
fputs(read_buf,stdout);
fputs("\n",stdout);
memset(read_buf,0,sizeof(read_buf));
}
free(read_buf);
shutdown(client_fd,SHUT_RD);
}
void * write_to_server(void * arg){
int client_fd = *(int *)arg;
char * write_buf = NULL;
write_buf = malloc(sizeof(char) * 1024);
ssize_t count;
if(!write_buf){ perror("malloc"); free(write_buf); shutdown(client_fd,SHUT_WR); return NULL; }
while(fgets(write_buf,1024,stdin) != NULL){
count = send(client_fd,write_buf,1024,0);
if(count < 0){ perror("send"); break; }
}
free(write_buf);
shutdown(client_fd,SHUT_WR);
}
int main(int argc, char const *argv[]) {
int socketfd,tmp_result;
//定义两个结构体，一个表示服务端，一个是客户端的
struct sockaddr_in server_in,client_in;
//清空
memset(&server_in,0,sizeof(server_in));
memset(&client_in,0,sizeof(client_in));
//设置客户端的 IP
client_in.sin_family = AF_INET;
client_in.sin_port = htons(8888);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"192.168.136.101",&(client_in.sin_addr));
//设置 IP 和端口
server_in.sin_family = AF_INET;
server_in.sin_port = htons(6666);
//server_in.sin_addr.s_addr = htonl(0);
inet_pton(AF_INET,"0.0.0.0",&(server_in.sin_addr));
//socket
socketfd = socket(AF_INET,SOCK_STREAM,0);
handle_error("socket",socketfd);
//bind 绑定，自动分配
// 客户端可以不绑定 系统会自动分配一个空闲的端口号给客户端
// tmp_result = bind(socketfd,(struct sockaddr *)&client_in,sizeof(client_in));
// handle_error("bind",tmp_result);
//connect 客户端主动连接
tmp_result = connect(socketfd,(struct sockaddr *)&server_in,sizeof(server_in));
handle_error("connect",tmp_result);
printf("连接成功，服务端的 IP 为%s，端口号为%d\n",inet_ntoa(server_in.sin_addr),ntohs(server_in.sin_port));
pthread_t read_pid,write_pid;
pthread_create(&read_pid,NULL,read_from_server,(void *)&socketfd);
pthread_create(&write_pid,NULL,write_to_server,(void *)&socketfd);
pthread_join(read_pid,NULL);
pthread_join(write_pid,NULL);
//客户端连接上了
//printf("客户端的地址为%s，端口号为%d\n",inet_ntoa(server_in.sin_addr),ntohs(server_in.sin_port));
close(socketfd);
return 0;
}
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online