理解TCP和UDP

根据数据传输方式的不同,基于网络协议的套接字一般分为TCP套接字和UDP套接字。因为TCP套接字是面向连接的,因此又称为基于流(stream)的套接字。TCP是Transmission Control Protocol(传输控制协议)的简写,意为“对数据传输过程的控制”。因此,学习控制方法及范围有助于正确理解TCP套接字

TCP/IP协议栈

讲解TCP前先介绍TCP所属的TCP/IP协议栈(Stack,层),如图1-1所示:

图1-1   TCP/IP协议栈

从图1-1可以看出,TCP/IP协议栈共分为四层,可以理解为数据收发分成了四个层次化过程。也就是说,面对“基于互联网的有效数据传输”的命题,并非通过一个庞大的协议解决问题,而是通过层次化方案——TCP/IP协议栈解决,通过TCP套接字收发数据需要借助四层,如图1-2所示:

图1-2   TCP协议栈

反之,通过UDP套接字收发数据时,利用图1-2的四层协议栈来完成:

图1-3   UDP协议栈

各层可能通过操作系统等软件实现,也可能通过类似NIC的硬件设备实现

TCP/IP协议的诞生背景

“通过因特网完成有效数据传输”这个课题让许多专家聚集到一起,不同人负责不同模块,如:硬件、系统、路由。为什么要这样做呢?因为编写软件前需要构建硬件系统,在此基础上需要通过软件实现各种算法,所以才需要众多领域的专家进行讨论,以形成各种规定。把“通过因特网完成有效数据传输”问题按照不同领域划分成小问题后,出现了多种协议,它们通过层级结构建立紧密联系

把协议分成多个层次具有哪些优点?协议设计更容易?这是优点之一,但更重要的原因是:为了通过标准化操作设计开放式系统。标准本身就在于对外公开,引导更多人遵循。以多个标准为依据所设计的系统称为开放式系统,我们现在学习的TCP/IP协议栈也属于其中之一。那么开放式系统具有哪些优点呢?比方:路由器用来完成IP层交互任务,某公司原先使用A路由器,可将其替换成B路由器,即便A、B这两种路由器并非同一产商也可以顺利替换,因为所有的路由器生产产商都会按照IP层标准制造

再举个例子,大家的计算机一般都装有网卡(网络接口卡),即便没安装也没关系,网卡很容易买到,因为所有的网卡制造商都会遵守链路层的协议标准,这就是开放式系统的优点

链路层

接下来逐层了解TCP/IP协议栈,先讲链路层。链路层是物理链接领域标准化的结果,也是最基本的领域,专门定义LAN、WAN、MAN等网络标准。若两台主机通过网络进行数据进行交换,则需要图1-4所示的物理连接,链路层就负责这些标准:

图1-4   网络连接结构

IP层

准备好物理连接后就要传输数据,为了在复杂的网络中传输数据,首先需要考虑路径的选择。向目标传输数据需要经过哪条路径?解决此问题就是IP层,该层使用的协议就是IP。IP本身是面向消息的、不可靠的协议。每次传输数据时会帮我们选择路径,但每次传输时的路径并不一致。如果传输中发生路径错误,则选择其他路径;但如果发生数据丢失或损坏,则无法解决。换言之,IP协议无法应对数据错误

TCP/UDP层

IP层解决数据传输中的路径选择问题,只需照此路径传输数据即可。TCP和UDP层以IP层提供的路径信息为基础完成实际的数据传输,故该层又称传输层。UDP比TCP简单,我们后面还会在讨论,现在只解释TCP。TCP可以保证可靠的数据传输,但它发送数据时以IP层为基础,IP层是面向消息的,是不可靠的,那TCP又是如何保证消息的可靠传输呢?

IP层只关注一个数据包(数据传输的基本单位)的传输过程。因此,即使传输多个数据包,每个数据包也是由IP层实际传输的,也就是说传输顺序及传输本身都是不可靠的。若只利用IP层传输数据,则有可能后发送的数据包比早发生的数据包先到达目标主机。另外,传输的数据包A、B、C中可能只收到A和C,B可能丢失或接收到时已损坏。但若添加TCP协议则会按照如图1-5的方式进行数据传输:

图1-5   传输控制协议

我们可以看到,当主机A发送1号数据包给主机B时,必须等到主机B确认1号数据包接收成功,才会接着发送2号数据包,如果主机A发送1号数据包却迟迟收不到主机B回复的接收成功,则会认为是超时,并重新发送一个1号数据包

实现基于TCP的服务端/客户端

图1-6给出了TCP服务器端默认的函数调用顺序,大部分TCP服务器端都按照该顺序调用

图1-6   TCP服务端函数调用顺序

调用socket函数创建套接字,声明并初始化地址信息结构体变量,调用bind函数向套接字分配地址。这两个阶段之前都讨论过了,下面讲解之后的几个过程

进入等待连接请求状态

我们已调用bind函数给套接字分配了地址,接下来就要通过调用listen函数进入等待连接请求状态。只有调用了listen函数,服务端套接字才能进入可接收连接的状态,换言之,这时,客户端才能调用connect函数(若提前调用则会发生错误)

#include <sys/socket.h>
int listen(int sockfd, int backlog);//成功时返回0,失败时返回-1

  

  • sock:希望进入等待连接请求状态的套接字文件描述符,传递的描述符套接字参数成为服务端套接字(监听套接字)
  • backlog:连接请求等待队列(Queue)的长度,若为5,则队列长度为5,表示最多使5个连接请求进入队列

先解释一下等待连接请求状态的含义和连接请求等待队列。“服务器端处于等待连接请求状态”是指,客户端请求连接时,服务器端受理连接前一直处于等待状态,当有多个客户端一起发送连接请求时,服务器端套接字只能处理一个连接请求,而其他的连接请求,只能暂时放在请求队列,即listen函数的第二个参数

受理客户端连接请求

调用listen函数后,若有新的连接请求,则应按序受理。受理请求意味着进入可接收数据的状态,这里进入这种状态的所需部件当然还是套接字,可能有人会想使用服务器端套接字,但服务器端套接字已经用于监听,如果将其用于与客户端交换数据,那么谁来监听客户端的连接请求呢?因此需要另外一个套接字,但没必要亲自创建,accept函数将自动创建套接字,并连接到发起请求的客户端

#include <sys/socket.h>
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);//成功时返回创建的套接字文件描述符,失败时返回-1

  

  • sock:服务器套接字的文件描述符
  • addr:保存发起连接请求的客户端地址信息的变量地址值,调用函数后向传递来的地址变量参数填充客户端地址信息
  • addrlen:第二个参数addr结构体的长度,但是存有长度的变量地址。函数调用完成后,该变量即被填入客户端地址长度

accept函数受理连接请求等待队列中待处理的客户端连接请求,函数调用成功时,accept函数内部将产生用于数据I/O的套接字,并返回其文件描述符。需要强调的是,套接字是自动创建的,并自动与发起连接请求的客户端建立连接

这里,我们重新回顾TCP/IP网络编程之网络编程和套接字这一章中的hello_server.c

hello_server.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h> void error_handling(char *message); int main(int argc, char *argv[])
{
int serv_sock;
int clnt_sock; struct sockaddr_in serv_addr;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size; char message[] = "Hello world!"; if (argc != 2)
{
printf("Usage: %s <port>\n", argv[0]);
exit(1);
} serv_sock = socket(AF_INET, SOCK_STREAM, 0);
if (serv_sock == -1)
error_handling("sock() error"); memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_addr.sin_port = htons(atoi(argv[1])); if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
error_handling("bind() error"); if (listen(serv_sock, 5) == -1)
error_handling("listen() error"); clnt_addr_size = sizeof(clnt_addr);
clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
if (clnt_sock == -1)
error_handling("accept() error"); write(clnt_sock, message, sizeof(message));
close(clnt_sock);
close(serv_sock); return 0;
} void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

  

  • 第27行:服务器端实现过程中先要创建套接字,但此时的套接字尚未是真正的服务器端套接字
  • 第31~37行:为了完成套接字地址分配,初始化结构体变量并调用bind函数
  • 第39行:调用accept函数从队列的顶部取出一个连接请求与客户端建立连接,并返回创建的套接字文件描述符。另外,调用accept函数时若等待队列为空,则accept函数不会返回,直到队列中出现新的客户端连接
  • 第47~49行:调用write函数向客户端传输数据,调用close函数关闭连接

TCP客户端的默认函数调用顺序

接下来讲解客户端的实现顺序,我们前面说过,客户端的套接字实现比服务器端要简单的多,因为创建套接字和请求连接就是客户端的全部内容,如图1-7:

图1-7   TCP客户端函数调用顺序

与服务器端相比,区别就在于“请求连接”,它是创建客户端套接字后向服务器端发起的连接请求。服务器端调用listen函数后创建连接请求等待队列,之后客户端即可请求连接。那如何发起连接请求呢?通过connect函数完成:

#include <sys/socket.h>
int connect(int sock_fd, struct sockaddr *serv_addr, socklen_t addrlen);//成功时返回0,失败时返回-1

  

  • sock:客户端套接字文件描述符
  • serv_addr:保存目标服务器端地址信息的变量地址值
  • addrlen:以字节为单位传递已传递给第二个结构体参数serv_addr的地址变量长度

客户端调用connect函数后,发生以下情况之一才会返回:

  • 服务器端接收连接请求
  • 发生断网等异常情况而中断连接请求

需要注意,所谓的“接收连接”并不意味着服务器端调用accept函数,其实是服务器端把连接请求信息记录到等待队列,因此connect函数返回后并不立即进行数据交换

这里,我们再回顾之前的hello_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h> void error_handling(char *message); int main(int argc, char *argv[])
{
int sock;
struct sockaddr_in serv_addr;
char message[30];
int str_len; if (argc != 3)
{
printf("Usage: %s <IP> <port>\n", argv[0]);
exit(1);
} sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == -1)
error_handling("sock() error"); memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
serv_addr.sin_port = htons(atoi(argv[2])); if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
error_handling("connect() error!"); str_len = read(sock, message, sizeof(message) - 1);
if (str_len == -1)
error_handling("read() error!"); printf("Message from server: %s\n", message);
close(sock); return 0;
} void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

  

  • 第23行:创建准备连接服务器端的套接字,此时创建的是TCP套接字
  • 第27~30行:结构体变量serv_addr中初始化IP和端口信息。初始化值为目标服务器端套接字的IP和端口信息
  • 第32行:调用connect函数向服务器端发送连接请求
  • 第35行:完成连接后,接收服务器端传输的数据
  • 第40行:接收数据后调用close函数关闭套接字,结束与服务器端的连接

基于TCP的服务器端/客户端函数调用关系

前面讲解了TCP服务器端/客户端的实现顺序,实际上二者并非相互独立,让我们画一下它们之间的交互过程,如图1-8所示

图1-8   函数调用关系

图1-8的总体流程如下:服务器端创建套接字后联系调用bind、listen函数进入等待状态,客户端通过调用connect函数发起连接请求,需要注意的是,客户端只能等到服务器端调用listen函数后才能调用connect函数。同时要清楚,客户端调用connect前,服务器端可能先调用了accept函数。当然,此时服务器端在调用accept函数时进入了阻塞状态,直到客户端调用connect函数为止

实现迭代服务器端/客户端

现在,让我们来编写一个回声服务器端/客户端,所谓回声,就是服务器端将客户端传输的字符串数据原封不动地回传给客户端,不过在此之前,需要解释一下何为迭代服务器端。之前我们所看到的Hello world服务器端处理完一个客户端连接请求则退出程序,连接请求等待队列是实际上没太大意义,这并非我们所需的服务器端,设置好等待队列后,应向所有客户端提供服务,如果在受理完一个客户端请求连接后,还需要再受理其他的请求连接,改怎么扩展代码?最简单的办法就是通过循环语句返回调动accept函数,如图1-9

图1-9   迭代服务器端的函数调用顺序

图1-9可以看出,调用accept函数后,紧接着调用I/O相关的read、write函数,然后调用close函数。这并非针对服务器端套接字,而是针对accept函数调用时所创建的套接字。调用close函数就意味着结束了针对某一客户端的服务,此时如果还想服务于其他客户端,就要重新调用accept函数。目前,我们的服务器端套接字同一时刻只能服务于一个客户端连接,将来学完进程和线程后,就可以编写同时服务多个客户端的服务器端了

迭代回声服务器端/客户端

即时服务器端以迭代方式运转,客户端代码亦无太大区别,接下来创建迭代回声服务器端及与之配套的回声客户端,首先整理一下程序的基本运行方式:

  • 服务器端在同一时刻只与一个客户端相连,并提供回声服务
  • 服务器端依次向五个客户端提供服务并退出
  • 客户端接收用户输入的字符串并发送到服务器端
  • 服务器端将接收到的字符串回传给客户端,即“回声”
  • 服务器端与客户端之间的字符串回声一直执行到客户端输入Q为止

echo_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
void error_handling(char *message); int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
char messag[1024];
int str_len, i; struct sockaddr_in serv_adr, clnt_adr;
socklen_t clnt_adr_sz; if (argc != 2)
{
printf("Usage:%s<port>\n", argv[0]);
exit(1);
}
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
if (serv_sock == -1)
error_handling("socket()error");
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1]));
if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
error_handling("bind()error");
if (listen(serv_sock, 5) == -1)
error_handling("listen()error");
clnt_adr_sz = sizeof(clnt_adr);
for (i = 0; i < 5; i++)
{
clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
if (clnt_sock == -1)
error_handling("accept()error");
else
printf("Connected client %d \n", i + 1);
while ((str_len = read(clnt_sock, messag, 1024)) != 0)
write(clnt_sock, messag, str_len);
close(clnt_sock);
}
close(serv_sock);
return 0;
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

  

  • 第37~40行:为处理5个客户端连接而添加的循环语句。共调用五次accept函数,依次向五个客户端提供服务
  • 第44、45行:实际完后回声服务的代码,原封不动地传输读取的字符串
  • 第46行:针对连接客户端的套接字调用close函数,向连接的相应套接字发送EOF。换言之,客户端套接字若调用close函数,则第44行的循环条件变为false,因此执行第46行代码
  • 第48行:向5个客户端提供服务后关闭服务器端套接字并终止程序

echo_client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h> void error_handling(char *message);
int main(int argc, char *argv[])
{
int sock;
char message[1024];
int str_len;
struct sockaddr_in serv_adr;
if (argc != 3)
{
printf("Usage:%s<IP><port>\n", argv[0]);
exit(1);
}
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock == -1)
error_handling("socket()error");
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
serv_adr.sin_port = htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
error_handling("connect()error");
else
puts("Connected..........");
while (1)
{
fputs("Input message(Q to quit):", stdout);
fgets(message, 1024, stdin);
if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
break;
write(sock, message, strlen(message));
str_len = read(sock, message, 1024 - 1);
message[str_len] = 0;
printf("Message from server:%s", message);
}
close(sock);
return 0;
} void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}

  

  • 第27行:调用connect函数。若调用该函数引起的连接请求被注册到服务器端等待队列,则connect函数将完成正常调用。因此,即使通过第30行代码输出了连接提示字符串,如果服务器尚未调用accept函数,也不会真正建立服务关系
  • 第42行:调用close函数向相应套接字发送EOF(EOF即意味着中断连接)

编译echo_server.c并运行,服务器端套接字将等待客户端连接请求

# gcc echo_server.c -o echo_server
# ./echo_server 8500

  

编译echo_client.c并分三次运行

# gcc echo_client.c -o echo_client
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Hello
Message from server:Hello
Input message(Q to quit):world
Message from server:world
Input message(Q to quit):Q
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Java
Message from server:Java
Input message(Q to quit):Python
Message from server:Python
Input message(Q to quit):Golang
Message from server:Golang
Input message(Q to quit):Q
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Spring
Message from server:Spring
Input message(Q to quit):Flask
Message from server:Flask
Input message(Q to quit):Gin
Message from server:Gin
Input message(Q to quit):Q

  

最后可看到服务器端套接字程序打印如下:

# ./echo_server 8500
Connected client 1
Connected client 2
Connected client 3

  

可以看到,服务器端套接字共处理了3次客户端连接请求

回声客户端存在的问题

下面是echo_client.c的代码

write(sock, message, strlen(message));
str_len = read(sock, message, 1024 - 1);
message[str_len] = 0;
printf("Message from server:%s", message);

  

以上的代码有个错误假设:每次调用read、write函数时都会以字符串为单位执行实际的I/O操作。但是别忘了,TCP不存在数据边界。因此,多次调用write函数传递字符串有可能一次性传递到服务端,此时,客户端有可能从服务端收到多个字符串,这不是我们希望看到的结果

还要考虑另外一种情况:字符串太长,需要分两次数据包发送,客户端有可能在尚未收到全部数据包时就调用read函数。这些都是TCP特性的问题,我们将在下一章给出解决的办法