TCP/IP网络编程之基于TCP的服务端/客户端（一）

时间  2019-11-20
标签 tcp 网络 编程 基于 服务 客户端 栏目 系统网络 繁體版
原文   原文链接

理解TCP和UDPhtml

根据数据传输方式的不一样，基于网络协议的套接字通常分为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协议栈socket

反之，经过UDP套接字收发数据时，利用图1-2的四层协议栈来完成：函数

图1-3   UDP协议栈post

各层可能经过操做系统等软件实现，也可能经过相似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函数，依次向五个客户端提供服务
  • 第4四、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特性的问题，咱们将在下一章给出解决的办法

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程