网络编程：理解TCP中的“流”
TCP是一种流式协议
TCP数据是流式的特性，可分别从发送端和接收端来阐述
发送端：当调用send函数完成数据“发送”后，数据并没有真正从网络上发送出去，只是从应用程序拷贝到了操作系统内核协议栈中，至于什么时候发送，取决于发送窗口、拥塞窗口以及当前发送缓冲区的大小等条件，也就是说，不能假设每次send调用发送的数据，都会作为一个整体完整地发送出去。
接收端：先调用send函数发送的字节，总在后调用send函数发送字节的前面，这个是由TCP严格保证的；如果发送过程中有TCP分组丢失，但其后续分组陆续到达，那么TCP协议栈会缓存后续分组，直到前面丢失的分组到达，最终，形成可以被应用程序读取的数据流。
网络字节排序
大端字节序：将0x02高字节存放在起始地址（高存低）
小端字节序：将0x01低字节存放在起始地址（低存低）
网络协议使用的是大端字节序
为了保证网络字节序一致，POSIX标准提供了如下的转换函数：
uint16_t htons (uint16_t hostshort)
uint16_t ntohs (uint16_t netshort)
uint32_t htonl (uint32_t hostlong)
uint32_t ntohl (uint32_t netlong)
n代表network，h代表host，s代表short，l代表long，分别表示16位和32位的整数
报文读取和解析
TCP报文是以字节流的形式呈现给应用程序，那应用程序如何解读字节流呢？
报文格式和解析
- 报文格式就是定义了字节的组织形式，发送端和接收端按照统一的报文格式进行数据传输和解析，保证批次能够完成交流
- 知道了报文格式，接收端才能针对性地进行报文读取和解析工作
报文格式最重要的是如何确定报文的边界。常见的报文格式有两种：
- 一种是发送端把要发送的报文长度预先通过报文告知给接收端
- 另一种是通过一些特殊的字符来进行边界的划分
显示编码报文长度
报文格式
首先4个字节大小的消息长度，目的是将真正发送的字节流的大小显示通过报文告知接收端，接下来的4个字节大小的消息类型；真正需要发送的数据则紧随其后。
发送报文
发送端的程序：
int main(int argc, char **argv) {
if (argc != 2) {
error(1, 0, "usage: tcpclient <IPaddress>");
}
int socket_fd;
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in server_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERV_PORT);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
socklen_t server_len = sizeof(server_addr);
int connect_rt = connect(socket_fd, (struct sockaddr *) &server_addr, server_len);
if (connect_rt < 0) {
error(1, errno, "connect failed ");
}
struct {
u_int32_t message_length;
u_int32_t message_type;
char buf[128];
} message;
int n;
while (fgets(message.buf, sizeof(message.buf), stdin) != NULL) {
n = strlen(message.buf);
message.message_length = htonl(n);
message.message_type = 1;
if (send(socket_fd, (char *) &message, sizeof(message.message_length) + sizeof(message.message_type) + n, 0) <
0)
error(1, errno, "send failure");
}
exit(0);
}
htonl函数将字节大小转化为网络字节顺序。
解析报文：
服务端的程序，服务端需要对报文进行解析
static int count;
static void sig_int(int signo) {
printf("\nreceived %d datagrams\n", count);
exit(0);
}
int main(int argc, char **argv) {
int listenfd;
listenfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in server_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERV_PORT);
int on = 1;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
int rt1 = bind(listenfd, (struct sockaddr *) &server_addr, sizeof(server_addr));
if (rt1 < 0) {
error(1, errno, "bind failed ");
}
int rt2 = listen(listenfd, LISTENQ);
if (rt2 < 0) {
error(1, errno, "listen failed ");
}
signal(SIGPIPE, SIG_IGN);
int connfd;
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
if ((connfd = accept(listenfd, (struct sockaddr *) &client_addr, &client_len)) < 0) {
error(1, errno, "bind failed ");
}
char buf[128];
count = 0;
while (1) {
int n = read_message(connfd, buf, sizeof(buf));
if (n < 0) {
error(1, errno, "error read message");
} else if (n == 0) {
error(1, 0, "client closed \n");
}
buf[n] = 0;
printf("received %d bytes: %s\n", n, buf);
count++;
}
exit(0);
}
调用read_message函数进行报文解析工作，并把报文的主体通过标准输出打印出来。
readn函数
read函数的语意：读取报文预设大小的字节，readn调用会一直循环，尝试读取预设大小的字节，如果接收缓冲区数据空，readn函数会阻塞在那里，直到有数据到达。
size_t readn(int fd, void *buffer, size_t size) {
char *buffer_pointer = buffer;
int length = size;
while (length > 0) {
int result = read(fd, buffer_pointer, length);
if (result < 0) {
if (errno == EINTR)
continue; /* 考虑非阻塞的情况，这里需要再次调用read */
else
return (-1);
} else if (result == 0)
break; /* EOF(End of File)表示套接字关闭 */
length -= result;
buffer_pointer += result;
}
return (size - length); /* 返回的是实际读取的字节数*/
}
解析报文：read_message函数
以readn函数为基础，read_message对报文的解析处理：
size_t read_message(int fd, char *buffer, size_t length) {
u_int32_t msg_length;
u_int32_t msg_type;
int rc;
rc = readn(fd, (char *) &msg_length, sizeof(u_int32_t)); //获取4个字节的消息长度数据
if (rc != sizeof(u_int32_t))
return rc < 0 ? -1 : 0;
msg_length = ntohl(msg_length);
rc = readn(fd, (char *) &msg_type, sizeof(msg_type)); //获取4个字节的消息类型数据
if (rc != sizeof(u_int32_t))
return rc < 0 ? -1 : 0;
if (msg_length > length) {
return -1;
}
rc = readn(fd, buffer, msg_length); //一次性读取已知长度的消息体
if (rc != msg_length)
return rc < 0 ? -1 : 0;
return rc;
}
特殊字符作为边界
通过特殊字符作为报文边界。
HTTP是一个很好的例子：
HTTP通过设置回车符、换行符作为HTTP报文协议的边界
read_line函数在尝试读取一行数据，即读到回车符\r，或者读到回车换行符\r\n为止。
int read_line(int fd, char *buf, int size) {
int i = 0;
char c = '\0';
int n;
while ((i < size - 1) && (c != '\n')) {
n = recv(fd, &c, 1, 0);
if (n > 0) {
if (c == '\r') {
n = recv(fd, &c, 1, MSG_PEEK);
if ((n > 0) && (c == '\n'))
recv(fd, &c, 1, 0);
else
c = '\n';
}
buf[i] = c;
i++;
} else
c = '\n';
}
buf[i] = '\0';
return (i);
}
实践
客户端：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#define SERV_PORT 43211
int main(int argc, char *argv[])
{
if(argc != 2)
{
perror("usage: streamclient <IPaddress>");
return -1;
}
int socket_fd;
socket_fd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in server_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(SERV_PORT);
inet_pton(AF_INET, argv[1], &server_addr.sin_addr);
socklen_t server_len = sizeof(server_addr);
int connect_rt = connect(socket_fd, (struct sockaddr *)&server_addr, server_len);
if(connect_rt < 0)
{
perror("connect failed");
return -1;
}
struct
{
/* data */
u_int32_t message_length;
u_int32_t message_type;
char data[128];
} message;
int n ;
while(fgets(message.data, sizeof(message.data), stdin) != NULL)
{
n = strlen(message.data);
message.message_length = htonl(n);
message.message_type = 1;
if(send(socket_fd, (char *)&message, sizeof(message.message_length)
+ sizeof(message.message_type) + n, 0) < 0)
{
perror("send failure");
return -1;
}
}
exit(0);
}
服务端：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <netinet/in.h>
#define SERV_PORT 43211
#define LISTENQ 1024
static int count;
size_t readn(int fd, void *buffer, size_t size)
{
char *buffer_pointer = buffer;
int length = size;
while(length > 0)
{
int result = read(fd, buffer_pointer, length);
if(result < 0)
{
if(errno == EINTR)
{
continue; // 考虑非阻塞的情况，需要再次调用read
}
else
{
return -1;
}
}
else if(result == 0)
{
break; //EOF (End of File)表示套接字关闭
}
length -= result;
buffer_pointer += result;
}
return(size - length); //返回的是实际读取的字节数
}
size_t read_message(int fd, char*buffer, size_t length)
{
u_int32_t msg_length;
u_int32_t msg_type;
int rc;
rc = readn(fd, (char *)&msg_length, sizeof(u_int32_t));
if(rc != sizeof(u_int32_t))
{
return rc < 0 ? -1: 0;
}
msg_length = ntohl(msg_length);
rc = readn(fd, (char *)&msg_type, sizeof(u_int32_t));
if(rc != sizeof(u_int32_t))
{
return rc < 0 ? -1 : 0;
}
// 判断buffer是否可以容纳下数据
if(msg_length > length)
{
perror("msg_length > length");
return -1;
}
rc = readn(fd, buffer, msg_length);
if(rc != msg_length)
{
return rc < 0 ? -1 : 0;
}
return rc;
}
int main(int argc, char *argv[])
{
int listen_fd;
listen_fd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in server_addr;
bzero(&server_addr, sizeof(server_addr));
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
server_addr.sin_port = htons(SERV_PORT);
int on = 1;
setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &on ,sizeof(on));
int rt1 = bind(listen_fd, (struct sockaddr *)&server_addr, sizeof(server_addr));
if(rt1 < 0)
{
perror("bind failed");
return -1;
}
int rt2 = listen(listen_fd, LISTENQ);
if(rt2 < 0)
{
perror("listen failed");
return -1;
}
signal(SIGPIPE, SIG_IGN);
int connfd;
struct sockaddr_in client_addr;
socklen_t client_len = sizeof(client_addr);
if((connfd = accept(listen_fd, (struct sockaddr *)&client_addr, &client_addr)) < 0)
{
perror("accept failed");
return -1;
}
char buf[128];
count = 0;
while(1)
{
int n = read_message(connfd, buf, sizeof(buf));
if(n < 0)
{
perror("error read message");
return -1;
}
else if(n == 0)
{
printf("client will closing");
return 0;
}
buf[n] = 0;
printf("received %d bytes: %s\n",n, buf);
count++;
}
exit(0);
}
运行结果：
小结
TCP 数据流特性决定了字节流本身是没有边界的，一般我们通过显式编码报文长度的方式，以及选取特殊字符区分报文边界的方式来进行报文格式的设计。而对报文解析的工作就是要在知道报文格式的情况下，有效地对报文信息进行还原。
