《TCP/IP网络编程》第13章 多种I/O函数
send&recv
#include <sys/socket.h>
//成功字节，失败-1
ssize_t send(int sockfd, const void *buf, size_t nbytes, int flags);
//成功字节(收到EOF返回0)，失败-1
ssize_t recv(int sockfd, void *buf, size_t nbytes, int flags);
收发数据可选项
| flags | 含义 | send | recv |
|---|---|---|---|
| MSG_OOB | 用于传输带外数据（Out-of-band data） | * | * |
| MSG_PEEK | 验证输入缓冲中是否存在接收的数据 | * | |
| MSG_DONTROUTE | 数据传输过程中不参照路由（Routing）表，在本地（Local）网络中寻找目的地 | * | |
| MSG_DONTWAIT | 非阻塞(Non-blocking)I/O | * | * |
| MSG_WAITALL | 防止函数返回，直到接收全部请求的字节数 | * |
MSG_OOB
MSG_OOB用于创建特殊发送方法和通道以发送紧急消息。
OOB：Out-of-band，带外数据，通过完全不同的通信路径传输的数据。
TCP不另外提供，只利用TCP的紧急模式（Urgent mode）进行传输。
13.oob_send_linux.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define IP "127.0.0.1"
#define PORT 9999
#define BUF_SIZE 30
void error_handling(const char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char *argv[])
{
int sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
error_handling("socket() error");
socklen_t addr_size = sizeof(struct sockaddr_in);
struct sockaddr_in addr;
memset(&addr, 0, addr_size);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(IP);
addr.sin_port = htons(PORT);
if (connect(sock, (struct sockaddr *)&addr, addr_size) == -1)
error_handling("connect() error");
write(sock, "123", strlen("123"));
send(sock, "4", strlen("4"), MSG_OOB);
write(sock, "567", strlen("567"));
send(sock, "890", strlen("890"), MSG_OOB);
close(sock);
return 0;
}
// gcc 13.oob_send_linux.c -o 13.oob_send_linux && ./13.oob_send_linux
13.oob_recv_linux.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#define PORT 9999
#define BUF_SIZE 30
int recv_sock;
void error_handling(const char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
void urg_handler(int signo)
{
char buf[BUF_SIZE];
//int str_len = recv(recv_sock, buf, sizeof(buf) - 1, MSG_OOB); //一次urg_handler调用只能读取1个字节
int str_len = recv(recv_sock, buf, 1, MSG_OOB);
buf[str_len] = 0;
printf("Urgent message: %s\n", buf);
}
int main(int argc, char *argv[])
{
int acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
if (acpt_sock == -1)
error_handling("socket() error");
int opt = 1;
if (setsockopt(acpt_sock, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt)) == -1)
error_handling("setsockopt() error");
socklen_t addr_size = sizeof(struct sockaddr_in);
struct sockaddr_in recv_adr;
memset(&recv_adr, 0, addr_size);
recv_adr.sin_family = AF_INET;
recv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
recv_adr.sin_port = htons(PORT);
if (bind(acpt_sock, (struct sockaddr *)&recv_adr, addr_size) == -1)
error_handling("bind() error");
if (listen(acpt_sock, 5) == -1)
error_handling("listen() error");
struct sockaddr_in serv_adr;
recv_sock = accept(acpt_sock, (struct sockaddr *)&serv_adr, &addr_size);
// fcntl函数控制文件描述符
//指定recv_sock套接字的拥有者（F_SETOWN）为getpid()表示的进程
//套接字的拥有者实际为操作系统
//这里指负责套接字所有事务的主体
//处理SIGURG信号的主体为当前进程，并非所有进程都会处理SIGURG信号
//文件描述符recv_sock指向的套接字引发的SIGURG信号处理进程变为将getpid函数返回值用作ID的进程
fcntl(recv_sock, F_SETOWN, getpid());
struct sigaction act;
act.sa_handler = urg_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
int state = sigaction(SIGURG, &act, 0); //收到MSG_OOB紧急信息将产生SIGURG信号
char buf[BUF_SIZE];
int str_len;
while ((str_len = recv(recv_sock, buf, sizeof(buf) - 1, 0)) != 0)
{
if (str_len == -1)
continue;
buf[str_len] = 0;
puts(buf);
}
close(recv_sock);
close(acpt_sock);
return 0;
}
// gcc 13.oob_recv_linux.c -o 13.oob_recv_linux && ./13.oob_recv_linux
紧急模式
MSG_OOB（Out-of-band）并非真正意义上的"带外数据"（通过单独的通信路径高速传输数据）。
TCP不提供，可利用紧急模式（Urgen mode）传输。
TCP保持传输顺序的特性不会改变，MSG_OOB的真正意义在于督促数据接收对象尽快处理数据。
检查输入缓冲
MSG_DONTWAIT，非阻塞。
MSG_PEEK，recv读取缓冲数据后不删除。
recv+MSG_DONTWAIT|MSG_PEEK，非阻塞方式验证待读取数据是否存在。
13.peek_send_linux.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define IP "127.0.0.1"
#define PORT 9999
#define BUF_SIZE 30
void error_handling(const char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char *argv[])
{
int sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
error_handling("socket() error");
socklen_t addr_size = sizeof(struct sockaddr_in);
struct sockaddr_in addr;
memset(&addr, 0, addr_size);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(IP);
addr.sin_port = htons(PORT);
if (connect(sock, (struct sockaddr *)&addr, addr_size) == -1)
error_handling("connect() error");
write(sock, "123", strlen("123"));
send(sock, "4", strlen("4"), MSG_OOB);
write(sock, "567", strlen("567"));
send(sock, "890", strlen("890"), MSG_OOB);
close(sock);
return 0;
}
// gcc 13.oob_send_linux.c -o 13.oob_send_linux && ./13.oob_send_linux
13.peek_recv_linux.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#define PORT 9999
#define BUF_SIZE 30
void error_handling(const char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char *argv[])
{
int acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
if (acpt_sock == -1)
error_handling("socket() error");
int opt = 1;
if (setsockopt(acpt_sock, SOL_SOCKET, SO_REUSEADDR, (const void *)&opt, sizeof(opt)) == -1)
error_handling("setsockopt() error");
socklen_t addr_size = sizeof(struct sockaddr_in);
struct sockaddr_in acpt_adr;
memset(&acpt_adr, 0, addr_size);
acpt_adr.sin_family = AF_INET;
acpt_adr.sin_addr.s_addr = htonl(INADDR_ANY);
acpt_adr.sin_port = htons(PORT);
if (bind(acpt_sock, (struct sockaddr *)&acpt_adr, addr_size) == -1)
error_handling("bind() error");
if (listen(acpt_sock, 5) == -1)
error_handling("listen() error");
struct sockaddr_in recv_adr;
int connect_sock = accept(acpt_sock, (struct sockaddr *)&recv_adr, &addr_size);
int str_len;
char buf[BUF_SIZE];
while (1)
{
str_len = recv(connect_sock, buf, sizeof(buf) - 1, MSG_PEEK | MSG_DONTWAIT);
if (str_len > 0)
break;
}
buf[str_len] = 0;
printf("Buffering %d bytes: %s\n", str_len, buf);
str_len = recv(connect_sock, buf, sizeof(buf) - 1, 0);
buf[str_len] = 0;
printf("Read again: %s\n", buf);
close(connect_sock);
close(acpt_sock);
return 0;
}
// gcc 13.peek_recv_linux.c -o 13.peek_recv_linux && ./13.peek_recv_linux
readv&writev
对数据进行整合传输及发送的函数。
writev将分散保存在多个缓存中的数据一并发送，readv由多个缓冲分别接收，可以减少I/O函数的调用次数（read/write多次，readv/writev一次），提高效率。
关闭Nagle算法的情况下，多次调用write，可能发送多个数据包，writev一次性写入缓冲区，很可能仅通过发送一个数据包传输数据。
#include <sys/uio.h>
//成功字节数，失败-1
ssize_t writev(int fileds, const struct iovec *iov, int iovcnt);
struct iovec {
void *iov_base;//缓冲地址
size_t iov_len;//缓冲大小
};
13.writev_linux.c
#include <stdio.h>
#include <sys/uio.h>
int main(int argc, char *argv[])
{
struct iovec vec[2];
char buf1[] = "ABCDEFG";
vec[0].iov_base = buf1;
vec[0].iov_len = 3;
char buf2[] = "1234567";
vec[1].iov_base = buf2;
vec[1].iov_len = 4;
int str_len = writev(1, vec, 2);
puts("");
printf("Write bytes: %d\n", str_len);
return 0;
}
// gcc 13.writev_linux.c -o 13.writev_linux && ./13.writev_linux
//ABC1234
//Write bytes: 7
#include <sys/uio.h>
//成功字节数，失败-1
ssize_t readv(int fileds, const struct iovec *iov, int iovcnt);
13.readv_linux.c
#include <stdio.h>
#include <sys/uio.h>
#define BUF_SIZE 100
int main(int argc, char *argv[])
{
struct iovec vec[2];
char buf1[BUF_SIZE] = {0};
vec[0].iov_base = buf1;
vec[0].iov_len = 5;
char buf2[BUF_SIZE] = {0};
vec[1].iov_base = buf2;
vec[1].iov_len = BUF_SIZE;
int str_len = readv(0, vec, 2);
printf("Read bytes: %d\n", str_len);
printf("First message: %s\n", buf1);
printf("Second message: %s\n", buf2);
return 0;
}
// gcc 13.readv_linux.c -o 13.readv_linux && ./13.readv_linux
//I like TCP/IP socket programming
//Read bytes: 33
//First message: I lik
//Second message: e TCP/IP socket programming
Windows实现
Out-of-band数据属于异常（不同寻常的程序执行流）。
Windows无针对MSG_OOB可选项的事件处理设置，通过利用select的这一特性（异常监听）接收Out-of-band数据。
13.oob_send_win.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>
#define IP "127.0.0.1"
#define PORT 9999
#define BUF_SIZE 30
void ErrorHanding(const char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char *argv[])
{
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
ErrorHanding("WSAStartup() error!");
SOCKET sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == INVALID_SOCKET)
ErrorHanding("socket() error!");
int addr_size = sizeof(SOCKADDR_IN);
SOCKADDR_IN addr;
memset(&addr, 0, addr_size);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = inet_addr(IP);
addr.sin_port = htons(PORT);
if (connect(sock, (SOCKADDR *)&addr, addr_size) == SOCKET_ERROR)
ErrorHanding("connect() error!");
send(sock, "123", strlen("123"), 0);
send(sock, "4", strlen("4"), MSG_OOB);
send(sock, "567", strlen("567"), 0);
send(sock, "890abc", strlen("890abc"), MSG_OOB); // MSG_OOB只发送最后一个字符c
send(sock, "def", strlen("def"), 0);
send(sock, "gh", strlen("gh"), MSG_OOB); // MSG_OOB只发送最后一个字符h
closesocket(sock);
WSACleanup();
return 0;
}
// gcc 13.oob_send_win.c -o 13.oob_send_win -lws2_32 && 13.oob_send_win
13.oob_recv_win.c
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#define PORT 9999
#define BUF_SIZE 30
void ErrorHanding(const char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
int main(int argc, char *argv[])
{
WSADATA wsaData;
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
ErrorHanding("WSAStartup() error!");
SOCKET listen_sock = socket(PF_INET, SOCK_STREAM, 0);
if (listen_sock == INVALID_SOCKET)
ErrorHanding("socket() error");
int opt = 1;
if (setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt)) < 0)
ErrorHanding("setsockopt() error");
int addr_size = sizeof(SOCKADDR_IN);
SOCKADDR_IN listen_addr;
memset(&listen_addr, 0, addr_size);
listen_addr.sin_family = AF_INET;
listen_addr.sin_addr.s_addr = htonl(INADDR_ANY);
listen_addr.sin_port = htons(PORT);
if (bind(listen_sock, (struct sockaddr *)&listen_addr, addr_size) == SOCKET_ERROR)
ErrorHanding("bind() error");
if (listen(listen_sock, 5) == SOCKET_ERROR)
ErrorHanding("listen() error");
fd_set reads;
FD_ZERO(&reads);
FD_SET(listen_sock, &reads);
fd_set excepts;
FD_ZERO(&excepts);
FD_SET(listen_sock, &excepts);
while (1)
{
fd_set reads_copy = reads;
fd_set excepts_copy = excepts;
struct timeval timeout = {55, 5000};
int result = select(0, &reads_copy, 0, &excepts_copy, &timeout);
if (result == SOCKET_ERROR)
break;
else if (result == 0)
continue;
for (int i = 0; i < reads.fd_count; i++)
{
if (FD_ISSET(reads.fd_array[i], &excepts_copy))
{
if (reads.fd_array[i] == listen_sock)
{
ErrorHanding("listen_sock error");
}
else
{
char buf[BUF_SIZE];
// MSG_OOB，一次只发送一个字符
// MSG_OOB，一次可以读取多个字符(多次发送的MSG_OOB，可能一次性全部读取)
//int str_len = recv(reads.fd_array[i], buf, BUF_SIZE - 1, MSG_OOB);
int str_len = recv(reads.fd_array[i], buf, 1, MSG_OOB);
buf[str_len] = 0;
printf("Urgent message: %s\n", buf);
}
}
if (FD_ISSET(reads.fd_array[i], &reads_copy))
{
if (reads.fd_array[i] == listen_sock)
{
SOCKADDR_IN connect_addr;
SOCKET connect_sock = accept(listen_sock, (SOCKADDR *)&connect_addr, &addr_size);
FD_SET(connect_sock, &reads);
FD_SET(connect_sock, &excepts);
printf("connected client: %d\n", connect_sock);
}
else
{
char buf[BUF_SIZE];
int str_len = recv(reads.fd_array[i], buf, BUF_SIZE - 1, 0);
if (str_len == 0)
{
FD_CLR(reads.fd_array[i], &reads);
FD_CLR(reads.fd_array[i], &excepts);
closesocket(reads.fd_array[i]);
printf("closed client: %d\n", reads.fd_array[i]);
}
else
{
buf[str_len] = 0;
puts(buf);
}
}
}
}
}
closesocket(listen_sock);
WSACleanup();
return 0;
}
// gcc 13.oob_recv_win.c -o 13.oob_recv_win -lws2_32 && 13.oob_recv_win
300
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
