当前位置：首页 > article >正文

《TCP/IP网络编程》学习笔记 | Chapter 4：基于TCP的服务器端/客户端（1）

article 2024/11/14 0:01:51

《TCP/IP网络编程》学习笔记 | Chapter 4：基于TCP的服务器端/客户端（1）

《TCP/IP网络编程》学习笔记 | Chapter 4：基于TCP的服务器端/客户端（1）
- 理解TCP和UDP
- - TCP/IP协议栈
  - TCP/IP协议的诞生背景
  - 链路层
  - 网络层
  - TCP/UDP层
  - 应用层
- 实现基于TCP的服务端/客户端
- - 进入等待连接请求状态
  - 受理客户端连接请求
  - 回顾 Hello World 服务器端
  - TCP客户端的默认函数调用顺序
  - 客户端套接字地址信息
  - 回顾 Hello World 客户端
  - 基于TCP的服务器端/客户端函数调用关系
- 实现迭代服务器端/客户端
- - 实现迭代服务器端
  - 迭代回声服务器端/客户端
  - - echo_server.c
    - echo_client.c
  - 回声客户端存在的问题
- 基于 Windows 的实现
- - 与 Linux 的区别
  - 基于 Windows 的回声服务器端
  - 基于 Windows 的回声客户端
  - 测试
- 习题
- - （1）请说明TCP/IP的4层协议栈，并说明TCP和UDP套接字经过的层级结构差异。
  - （2）请说出TCP/IP协议栈中链路层和IP层的作用，并给出两者关系。
  - （3）为何需要把TCP/IP协议栈分成4层（或7层）？结合开放式系统回答
  - （4）客户端调用connect函数向服务器端发送连接请求。服务器端调用哪个函数后，客户端可以调用connect函数？
  - （5）什么时候创建连接请求等待队列？它有何作用？与accept有什么关系？
  - （6）客户端中为何不需要调用bind函数分配地址？如果不调用bind函数，那何时、如何向套接字分配IP地址和端口号？
  - 把第1章的hello_server.c和hello_server_win.c改成迭代服务器端，并利用客户端测试更改是否准确。

《TCP/IP网络编程》学习笔记 | Chapter 4：基于TCP的服务器端/客户端（1）

理解TCP和UDP

根据数据传输方式的不同，基于网络协议的套接字一般分为TCP套接字和UDP套接字。因为TCP套接字是面向连接的，因此又称为基于流（stream）的套接字。

TCP是Transmission Control Protocol（传输控制协议）的简写，意为“对数据传输过程的控制”。因此，学习控制方法及范围有助于正确理解TCP套接字。

TCP/IP协议栈

讲解TCP前先介绍TCP所属的TCP/IP协议栈（Stack，层），如图所示：

在这里插入图片描述

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

在这里插入图片描述

反之，通过UDP套接字收发数据时，利用下图的四层协议栈来完成：

在这里插入图片描述

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

TCP/IP协议的诞生背景

把“通过因特网完成有效数据传输”问题按照不同领域划分成小问题后，出现了多种协议，它们通过层级结构建立紧密联系。

把协议分成多个层次具有的优点：

协议设计更容易
为了通过标准化操作设计开放式系统

以多个标准为依据所设计的系统称为开放式系统，我们现在学习的TCP/IP协议栈也属于其中之一。那么开放式系统具有哪些优点呢？比方：路由器用来完成IP层交互任务，某公司原先使用A路由器，可将其替换成B路由器，即便A、B这两种路由器并非同一产商也可以顺利替换，因为所有的路由器生产产商都会按照IP层标准制造。再举个例子，大家的计算机一般都装有网卡（网络接口卡），即便没安装也没关系，网卡很容易买到，因为所有的网卡制造商都会遵守链路层的协议标准，这就是开放式系统的优点。

链路层

链路层是物理链接领域标准化的结果，也是最基本的领域，专门定义LAN、WAN、MAN等网络标准。若两台主机通过网络进行数据进行交换，则需要下图所示的物理连接，链路层就负责这些标准。

在这里插入图片描述

网络层

准备好物理连接后就要传输数据，为了在复杂的网络中传输数据，首先需要考虑路径的选择。向目标传输数据需要经过哪条路径？解决此问题就是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协议则会按照如下图的方式进行数据传输：

在这里插入图片描述

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

应用层

数据传输路径、数据确认过程都被隐藏到套接字内部，只需利用套接字编出程序即可。编写软件过程中，需要根据程序特点决定服务器端和客户端之间的数据传输规定，这便是应用层协议。

网络编程的大部分内容就是设计并实现应用层协议。

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

下图给出了TCP服务器端默认的函数调用顺序，大部分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函数的第二个参数决定了等候室的大小。等候室称为连接请求等待队列，准备好服务器端套接字和连接请求等待队列后，这种可接收连接请求的状态称为等待连接请求状态。

受理客户端连接请求

调用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的套接字，并返回其文件描述符。需要强调的是，套接字是自动创建的，并自动与发起连接请求的客户端建立连接。

在这里插入图片描述

回顾 Hello World 服务器端

这里，我们重新回顾第一章的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客户端的默认函数调用顺序

创建套接字和请求连接就是客户端的全部内容。

在这里插入图片描述

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

#include <sys/socket.h>

int connect(int sock_fd, struct sockaddr *serv_addr, socklen_t addrlen);

成功时返回0，失败时返回-1。

参数：

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

客户端调用connect函数后，发生以下情况之一才会返回（完成函数调用）：

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

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

客户端套接字地址信息

实现服务端必须给套接字分配IP地址和端口号，但客户端实现过程未出现，而是创建套接字后立即调用connect函数。网络数据交换必须分配IP和端口号，这是怎么回事呢？

客户端分配地址：

何时：调用connect函数时
何地：操作系统的内核中
如何：IP用计算机（主机）的IP，端口随机

客户端的IP地址和端口在调用connect函数时自动分配，无需调用标记的bind函数进行分配。

回顾 Hello World 客户端

这里，我们再回顾之前的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服务器端/客户端的实现顺序，实际上二者并非相互独立，让我们画一下它们之间的交互过程。

在这里插入图片描述

服务器端创建套接字后连续调用bind、listen函数进入等待状态，客户端通过调用connect函数发起连接请求，需要注意的是，客户端只能等到服务器端调用listen函数后才能调用connect函数。同时要清楚，客户端调用connect前，服务器端可能先调用了accept函数。当然，此时服务器端在调用accept函数时进入了阻塞状态，直到客户端调用connect函数为止。

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

回声服务器端/客户端：服务器端将客户端传输的字符串数据原封不动地传回客户端。

实现迭代服务器端

何为迭代服务器端？

设置好等待队列后，应向所有客户端提供服务，在受理完一个客户端请求连接后，还需要再受理其他的请求连接。

迭代服务器端的函数调用顺序：

在这里插入图片描述

从上图看出，调用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 message[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, message, BUF_SIZE)) != 0)
            write(clnt_sock, message, str_len);
        close(clnt_sock);
    }
    close(serv_sock);

    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

第37~47行：为处理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>

#define BUF_SIZE　1024
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, BUF_SIZE, stdin);
        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;
        write(sock, message, strlen(message));
        str_len = read(sock, message, BUF_SIZE - 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);
}

第29行：调用connect函数。若调用该函数引起的连接请求被注册到服务器端等待队列，则connect函数将完成正常调用。因此，即使通过第30行代码输出了连接提示字符串，如果服务器尚未调用accept函数，也不会真正建立服务关系

第44行：调用close函数向相应套接字发送EOF（EOF即意味着中断连接）

回声客户端存在的问题

下面是echo_client.c的代码：

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

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

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

朴素的解决方法：可以提前确定接收数据的大小。若之前传输了20字节长的字符串，则在接收时循环调用read函数读取20个字节。

基于 Windows 的实现

与 Linux 的区别

通过 WSAStartup、WSACleanup 函数初始化并清除套接字相关库。
数据类型和变量名切换为 Windows 风格。
数据传输用 recv、send 函数而非 read、write 函数。
关闭套接字时用 closesocket 函数而非 close 函数。

基于 Windows 的回声服务器端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 1024

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hServerSock, hClientSock;
    SOCKADDR_IN serverAddr, clientAddr;
    int clientAddrSize;
    char message[BUF_SIZE];
    int strLen;

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    hServerSock = socket(PF_INET, SOCK_STREAM, 0);
    if (hServerSock == INVALID_SOCKET)
        ErrorHanding("socket() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(atoi(argv[1]));

    if (bind(hServerSock, (SOCKADDR *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
        ErrorHanding("bind() error!");

    if (listen(hServerSock, 5) == SOCKET_ERROR)
        ErrorHanding("listen() error!");

    clientAddrSize = sizeof(clientAddr);
    for (int i = 0; i < 5; i++)
    {
        hClientSock = accept(hServerSock, (SOCKADDR *)&clientAddr, &clientAddrSize);
        if (hClientSock == INVALID_SOCKET)
            ErrorHanding("accept() error!");
        else
            printf("Connected client %d\n", i + 1);

        // echo
        while ((strLen = recv(hClientSock, message, BUF_SIZE, 0)) != 0)
            send(hClientSock, message, strLen, 0);

        closesocket(hClientSock);
    }

    closesocket(hServerSock);
    WSACleanup();

    return 0;
}

基于 Windows 的回声客户端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <winsock2.h>

#define BUF_SIZE 1024

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hSocket;
    SOCKADDR_IN serverAddr;

    char message[BUF_SIZE];
    int strLen;

    if (argc != 3)
    {
        printf("Usage: %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() error!");

    hSocket = socket(PF_INET, SOCK_STREAM, 0);
    if (hSocket == INVALID_SOCKET)
        ErrorHanding("hSocket() error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = inet_addr(argv[1]);
    serverAddr.sin_port = htons(atoi(argv[2]));

    if (connect(hSocket, (SOCKADDR *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
        ErrorHanding("connect() error!");
    else
        puts("Connected......");

    while (1)
    {
        fputs("Input message(Q to quit): ", stdout);
        fgets(message, BUF_SIZE, stdin);

        if (!strcmp(message, "q\n") || !strcmp(message, "Q\n"))
            break;

        send(hSocket, message, strlen(message), 0);
        strLen = recv(hSocket, message, BUF_SIZE - 1, 0);
        message[strLen] = '\0';
        printf("Message from server: %s\n", message);
    }

    closesocket(hSocket);
    WSACleanup();

    return 0;
}

测试

编译：

gcc echo_server_win.c -lwsock32 -o echo_server
gcc echo_client_win.c -lwsock32 -o echo_client

运行结果：

// 服务器端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>echo_server 9190
Connected client 1
Connected client 2
Connected client 3
Connected client 4
Connected client 5

// 客户端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>echo_client 127.0.0.1 9190
Input message(Q to quit): www
Message from server: www

Input message(Q to quit): never gonna
Message from server: never gonna

Input message(Q to quit): www
Message from server: www

习题

（1）请说明TCP/IP的4层协议栈，并说明TCP和UDP套接字经过的层级结构差异。

从高到低：应用层、传输层、网络层、数据链路层

TCP：链路层->IP层->TCP层->应用层
UDP：链路层->IP层->UDP层->应用层

（2）请说出TCP/IP协议栈中链路层和IP层的作用，并给出两者关系。

数据链路层通过各种控制协议，将有差错的物理信道变为无差错的、能可靠传输数据帧的数据链路。

网络层通过路由选择算法，为分组选择最适当的路径，实现两个端系统之间的数据透明传送。

数据链路层作为 IP 层的直接下层，向上提供数据传送服务。

（3）为何需要把TCP/IP协议栈分成4层（或7层）？结合开放式系统回答

开放式系统的研制经验表明，对于复杂的计算机网络协议，其结构应该是层次式的。

分层的好处：隔层之间是独立的，灵活性好，结构上可以分隔开，易于实现和维护，能促进标准化工作。

（4）客户端调用connect函数向服务器端发送连接请求。服务器端调用哪个函数后，客户端可以调用connect函数？

调用listen函数，设置好服务端监听套接字后。

（5）什么时候创建连接请求等待队列？它有何作用？与accept有什么关系？

调用listen函数时创建了连接请求等待队列。它是存储客户端连接请求信息的空间。accept函数调用后，将从连接请求队列中取出连接请求信息，并与相应客户端建立连接。

（6）客户端中为何不需要调用bind函数分配地址？如果不调用bind函数，那何时、如何向套接字分配IP地址和端口号？

客户端是请求连接的程序，不是一个接收连接的程序。所以，服务器的地址信息是更重要的因素，没有必要通过bind函数明确地分配地址信息。但是，要想和服务器通信，必须将自己的地址信息分配到套接字上，因此，在connect函数调用时，自动把IP地址和端口号输入到套接字上（IP用计算机（主机）的IP，端口随机）。

把第1章的hello_server.c和hello_server_win.c改成迭代服务器端，并利用客户端测试更改是否准确。

hello_echo_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(PF_INET, SOCK_STREAM, 0);
    if (serv_sock == -1)
        error_handling("socket() 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);

    while (1)
    {
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_addr, &clnt_addr_size);
        if (clnt_sock == -1)
            break;

        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);
}

hello_echo_server_win.c：

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>

void ErrorHanding(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

int main(int argc, char *argv[])
{
    WSADATA wsaData;
    SOCKET hServerSock, hClientSock;
    SOCKADDR_IN serverAddr, clientAddr;
    int szClientAddr;
    char message[] = "Hello World!";

    if (argc != 2)
    {
        printf("Usage: %s <port>\n", argv[0]);
        exit(1);
    }

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHanding("WSAStartup() 	error!");

    hServerSock = socket(PF_INET, SOCK_STREAM, 0);
    if (hServerSock == INVALID_SOCKET)
        ErrorHanding("socket() 	error!");

    memset(&serverAddr, 0, sizeof(serverAddr));
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    serverAddr.sin_port = htons(atoi(argv[1]));

    if (bind(hServerSock, (SOCKADDR *)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR)
        ErrorHanding("bind() error!");

    if (listen(hServerSock, 5) == SOCKET_ERROR)
        ErrorHanding("listen() error!");

    szClientAddr = sizeof(clientAddr);
    while (1)
    {
        hClientSock = accept(hServerSock, (SOCKADDR *)&clientAddr, &szClientAddr);
        if (hClientSock == INVALID_SOCKET)
        {
            ErrorHanding("accept() error!");
            break;
        }

        send(hClientSock, message, sizeof(message), 0);

        closesocket(hClientSock);
    }
    
    closesocket(hServerSock);

    WSACleanup();

    return 0;
}

编译：

gcc hello_client_win.c -lwsock32 -o hClntWin
gcc hello_echo_server_win.c -lwsock32 -o hEchoServWin

测试：

// 服务器端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>hEchoServWin 9190

// 客户端
C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>hClntWin 127.0.0.1 9190
Message from server: Hello World!

C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>hClntWin 127.0.0.1 9190
Message from server: Hello World!

C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>hClntWin 127.0.0.1 9190
Message from server: Hello World!

C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>hClntWin 127.0.0.1 9190
Message from server: Hello World!

C:\Users\81228\Documents\Program\TCP IP Project\Chapter 4>

结果正确，符合预期。

查看全文

http://www.kler.cn/a/389316.html