开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 网络协议 -> TCP/IP网络编程：P2-＞套接字类型与协议设置 -> 正文阅读

[网络协议]TCP/IP网络编程：P2-＞套接字类型与协议设置

本系列文章为《TCP/IP网络编程----尹圣雨》学习笔记，前面的系列文章链接如下
TCP/IP网络编程：P1-＞理解网络编程和套接字

文章目录

一、套接字协议及其数据传输特性
二、Windows平台下的实现及验证
- 2.1 Windows操作系统的socket函数
- 2.2 基于Windows的TCP套接字示例

一、套接字协议及其数据传输特性

关于协议

如果相隔很远的两人想展开对话，必须先决定对话方式。如果一方使用电话，那么另一方也只能使用电话，而不是书信。可以说，电话就是两人对话的协议。协议是对话中使用的通信规则，把上述概念拓展到计算机领域可整理为计算机间对话必备通信规则。简言之，协议就是为了完成数据交换而定好的约定。

创建套接字

创建套接字所用的socket函数已经在第1章中简单介绍过。但为了完全理解该函数，此处将再次展开讨论，本章的主要目的也在于此。
第1章并未提及该函数的参数，但它们对创建套接字来说是不可或缺的。下面给出详细说明。

#include <sys/socket.h>
int socket(int domain, int type, int protocol);
/*
成功时返回文件描述符，失败时返回-1
domain: 套接字中使用的协议族（Protocol Family）
type: 套接字数据传输的类型信息
protocol: 计算机间通信中使用的协议信息
*/

1.1 协议族(Protocol Family)

奶油意大利面和番茄酱意大利面均属于意大利面的一种，与此类似，套接字通信中的协议也具有一些分类。通过socket函数的第一个参数传递套接字中使用的协议分类信息，此协议分类信息称为协议族。可分成如下几类。头文件sys/socket.h中声明的协议族：

名称	协议族
PF_INET	IPv4互联网协议族
PF_INET6	IPv6互联网协议族
PF_LOCAL	本地通信的UNIX协议族
PF_PACKET	底层套接字的协议族
PF_IPX	IPX Novell协议族

我们主要学习PF_INET对应的IPv4互联网协议族，因为其他协议族并不常用或尚未普及。另外，套接字中实际采用的最终协议信息是通过socket函数的第三个参数传递的，在指定的协议族范围内通过第一个参数决定第三个参数。

1.2 套接字类型(Type)

定义

套接字类型指的是套接字的数据传输方式，通过socket函数的第二个参数传递。这种说法可能各位会感到疑惑：已通过第一个参数传递了协议族信息，还要决定数据传输方式？问题就在于决定了协议族并不能同时决定数据传输方式。换言之，socket函数第一个参数PF_INET协议族中也存在好多种数据传输方式。

1.2.1 套接字类型1：面向连接的套接字(SOCK_STREAM)

原理

如果socket函数的第二个参数传递SOCK_STREAM，将创建面向连接的套接字。下图中2位工人通过1条传送带传递物品，这与面向连接的数据传输方式类似。

特点

①传输过程中数据不会消失：图中通过独立的传送带传输数据(糖果)，只要传送带本身没有问题，就能保证数据不丢失。
②按序传输数据：较晚传递的数据(糖果)不会先到达，因为传送带保证了数据的按序传递。
③传输的数据不存在数据边界(Boundary)：100个糖果(数据)是分批传递的，但接收者凑齐100个后才装袋。
----这种情形可以适用到之前说过的write和read函数。传输数据的计算机通过3次调用write函数传递了100字节的数据，但接收数据的计算机仅通过1次read函数调用就接收了全部100个字节。
----收发数据的套接字内部有缓冲(buffer)，简言之就是字节数组。通过套接字传输的数据将保存到该数组。因此，收到数据并不意味着马上调用read函数。只要不超过数组容量，则有可能在数据填充满缓冲后通过1次read函数调用读取全部，也有可能分成多次read函数调用进行读取。也就是说，在面向连接的套接字中，read函数和write函数的调用次数并无太大意义。所以说面向连接的套接字不存在数据边界。
④套接字连接必须一一对应：上图中传输和接收端各有1名工人。

思考：套接字缓冲已满是否意味着数据丢失

问题： 为了接收数据，套接字内部有一个由字节数组构成的缓冲。如果这个缓冲被接收的数据填满会发生什么事情？之后传递的数据是否会丢失？
回答： 首先调用read函数从缓冲读取部分数据，因此缓冲并不总是满的。但如果read函数读取速度比接受的数据的速度慢，则缓冲有可能被填满。此时套接字无法在接受数据，但即使这样也不会发生数据丢失，因为传输套接字将停止传输。也就是说，面向连接的套接字会根据接收端的状态传输数据，如果传输出错还会提供重传服务。因此，面向面接的套接字除特殊情况外不会发生数据丢失。 |

总结

面向连接的套接字：可靠的、按序传递的、基于字节的面向连接的数据传输方式的套接字。

1.2.2 套接字类型2：面向消息的套接字(SOCK_DGRAM)

原理

如果向socket函数的第二个参数传递SOCK_DGRAM，则将创建面向消息的套接字。面向消息的套接字可以比喻成高速移动的摩托车快递。

特点

①强调快速传输而非传输顺序：众所周知，快递行业的速度就是生命。用摩托车发往同一目的地的2件包裹无需保证顺序，只要以最快速度交给客户即可。
②传输的数据可能丢失也可能损毁：这种方式存在损坏或丢失的风险。
③传输的数据有数据边界：如果用2辆摩托车分别发送2件包裹，则接收者也需要分2次接收。
④限制每次传输的数据大小：包裹的大小有一定限制，因此，若要传递大量包裹，则需分批发送。

总结

面向消息的套接字特性：不存在连接的概念，是一种不可靠的、不按序传递的、以数据的高速传输目的的套接字。

1.3 协议的最终选择

思考

问题： 前面已经通过socket函数的前两个参数传递了协议族信息和套接字数据传输方式，这些信息还不足以决定采用的协议吗？为什么还需要传递第3个参数呢？
回答： 一般来说，传递前两个参数即可创建所需套接字，所以大部分情况下可以向第三个参数传递0。但是如果遇到同一协议族中存在多个数据传输方式相同的协议(数据传输方式相同，但协议不同)，此时需要通过第三个参数具体指定协议信息。

创建IPv4协议族中面向连接的套接字

参数PF_INET指IPv4网络协议族，SOCK_STREAM是面向连接的数据传输。满足这2个条件的协议只有IPPROTO_TCP，因此可以如下调用socket函数创建套接字，这种套接字称为TCP套接字。
int tcp_socket = socket(PF_INET，socK_STREAM，IPPROTO_TCP);

创建IPv4协议族中面向消息的套接字

SOCK_DGRAM指的是面向消息的数据传输方式，满足上述条件的协议只有IPPROTO_UDP。因此，可以如下调用socket函数创建套接字，这种套接字称为UDP套接字。
int udp_socket = socket(PF_INET，soCK_DGRAM，IPPROTO_UDP);

1.4 面向连接的套接字：TCP套接字示例

背景

第一章中的hello_server.c和hello_client.c是基于TCP套接字的示例，现调整其中一部分代码，以验证TCP套接字的《传输的数据不存在数据边界》这一特性。为验证这一点，需要让write函数的调用次数不同于read函数的调用次数。因此，在客户端中分多次调用read函数，每次只读取一个字节，最终读取完服务器端发送的全部数据。

服务器端代码

#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; // server socket
    int clnt_sock; // client socket

    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); // 创建了一个 TCP 套接字
    if (serv_sock == -1)
        error_handling("socket() error");

    memset(&serv_addr, 0, sizeof(serv_addr));      // 将 serv_addr 全部填充为 0，主要是为了将 serv_addr 的 sin_zero 成员设为 0
    serv_addr.sin_family = AF_INET;                // 选定 IPv4 地址族
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); // htonl：将 long 类型数据从主机字节序转换为网络字节序; INADDR_ANY：32 位整型值表示的 IP 地址
    serv_addr.sin_port = htons(atoi(argv[1]));     // 此程序运行时应该在文件名后跟一个端口号作为参数，如 hello_server 3030

    if (bind(serv_sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) // 将套接字与服务器的 IP 地址和端口号相绑定
        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); // 接受一个连接请求，并将 clnt_sock 套接字与其相连接
    if (clnt_sock == -1)
        error_handling("accept() error");

    write(clnt_sock, message, sizeof(message)); // 向客户端发送信息。注意：clnt_sock 不是客户端的套接字，而是服务器上真正与客户端相连接的套接字
    close(clnt_sock);                           // 关闭与客户连接的套接字：断开了该连接
    close(serv_sock);                           // 关闭监听端口的套接字：不再接受任何请求
    return 0;
}

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

首先执行gcc tcp_server.c -o hserver编译源文件，然后执行./hserver 9190等待客户端消息的来临。
在这里插入图片描述

客户端代码

#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 = 0;
    int idx = 0, read_len = 0;

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

    //创建套接字，此时套接字并不马上分为服务端和客户端。如果紧接着调用 bind,listen 函数，将成为服务器套接字
    //如果调用 connect 函数，将成为客户端套接字
    //若前两个参数使用PF_INET 和 SOCK_STREAM，则可以省略第三个参数 IPPROTO_TCP
    sock = socket(PF_INET, SOCK_STREAM, 0);
    if(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 = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));

   //调用 connect 函数向服务器发送连接请求
    if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("connect() error!");

   //当read函数返回0的时候(read函数读到了EOF,即服务器端调用了close函数才会中止循环)条件为假，跳出循环。
    while(read_len = read(sock, &message[idx++], 1))
    {
        if(read_len == -1)
            error_handling("read() error!");

        str_len += read_len;
    }

    printf("Message from server: %s \n", message);
    printf("Function read call count: %d \n", str_len);
    close(sock);
    return 0;
}

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

首先执行gcc tcp_client.c -o hclient编译源文件，然后执行./hclient 127.0.0.1 9190等待客户端消息的来临。从运行结果可以看出服务端发送了13字节的数据，客户端调用13次read函数进行读取。
在这里插入图片描述

二、Windows平台下的实现及验证

前面讲过的套接字类型及传输特性与操作系统无关。Windows平台下的实现方式也类似，不需要过多说明，只需稍加了解socket函数返回类型即可。

2.1 Windows操作系统的socket函数

Windows的函数名和参数名都与Linux平台相同，只是返回值类型稍有不同。再次给出socket函数的声明。

#include <WinSock2.h>
SOCKET socket(int af, int type, int protocol);  //参数种类与含义同 Linux 的 socket 函数完全相同
//成功时返回 socket 句柄，失败时返回 INVALID_SOCKET。

返回值

可以看出返回值类型为SOCKET，此结构体用来保存整数型套接字句柄值。实际上，socket函数返回整数型数据，因此可以通过int型变量接收，就像在Linux中做的一样。但考虑到以后的扩展性，定义为SOCKET数据类型，希望各位也使用SOCKET结构体变量保存套接字句柄，这也是微软希望看到的。以后即可将SOCKET视作保存套接字句柄的一个数据类型。
同样，发生错误时返回INVALID_SOCKET，只需将其理解为提示错误的常数即可。其实际值为-1，但值是否为-1并不重要，除非编写如下代码。

SOCKET soc = socket(PF_INET,SOCK_STREAM, IPPROTO_TCP);
if (soc == -1)
	ErrorHandling(". . .");

如果这样编写代码，那么微软定义的INVALID_SOCKET常数将失去意义！应该如下编写，这样，即使日后微软更改INVALID_SOCKET常数值，也不会发生问题。

SOCKET soc = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (soc == INVALID_SOCKET)
	ErrorHandling(". . .");

2.2 基于Windows的TCP套接字示例

服务器端代码： 服务器端代码与第一章完全相同，直接使用即可。

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

void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
    WSADATA wsaData;
    SOCKET hServSock, hClntSock;
    SOCKADDR_IN servAddr, clntAddr;

    int szClntAddr;
    char message[] = "Hello World!";

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

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)  // 初始化 Winsock 相关库
        ErrorHandling("WSAStartup() error!");

    hServSock = socket(PF_INET, SOCK_STREAM, 0);    // 创建套接字
    if (hServSock == INVALID_SOCKET)
        ErrorHandling("socket() error");

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;                  // 设置协议族
    servAddr.sin_addr.s_addr = htonl(INADDR_ANY);   // 设置 IP 地址
    servAddr.sin_port = htons(atoi(argv[1]));       // 设置端口号

    if (bind(hServSock, (SOCKADDR*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR)    // 为套接字分配地址和端口
        ErrorHandling("bind() error");

    if (listen(hServSock, 5) == SOCKET_ERROR)       // 使套接字转换为可接收连接的状态
        ErrorHandling("listen() error");

    szClntAddr = sizeof(clntAddr);
    hClntSock = accept(hServSock, (SOCKADDR*)&clntAddr, &szClntAddr);   // 接受连接请求，函数返回客户端的套接字
    if (hClntSock == INVALID_SOCKET)
        ErrorHandling("accept() error");

    send(hClntSock, message, sizeof(message), 0);   // 向客户端发送信息
    closesocket(hClntSock);     // 关闭服务器端套接字
    closesocket(hServSock);     // 关闭客户端套接字
    WSACleanup();       // 注销 Winsock 相关库
    return 0;
}

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

打开cmd，执行hTCPServerWin 9190等待客户端的消息。
在这里插入图片描述

客户端代码： 将第一章的客户端代码进行修改。

#pragma execution_character_set("utf-8")

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

void ErrorHandling(char* message);

//在命令行执行可执行程序时有两个输入：IP地址、端口号
int main(int argc, char* argv[])
{
    WSADATA wsaData;        // 用于初始化 winsock 库的结构体
    SOCKET hSocket;
    SOCKADDR_IN servAddr;   // 存储地址信息的结构体

    char message[30];
    int strLen;

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

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)  // 使用 MAKEWORD 合成版本信息，然后用 WSAStartup 初始化 winsock 相关库
        ErrorHandling("WSAStartup() error!");

    hSocket = socket(PF_INET, SOCK_STREAM, 0);      // 生成套接字
    if (hSocket == INVALID_SOCKET)
        ErrorHandling("socket() error");

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family = AF_INET;                          // 地址族，AF_INET 表示 IPv4 地址族
    servAddr.sin_addr.S_un.S_addr = inet_addr(argv[1]);     // 从第二个参数处读取 IPv4 地址。
    servAddr.sin_port = htons(atoi(argv[2]));               // 从第三个参数处读取端口号

    if (connect(hSocket, (SOCKADDR*)&servAddr, sizeof(servAddr)) == SOCKET_ERROR)   // 连接服务器
        ErrorHandling("connect() error!");

    strLen = 0;
    int idx = 0, readLen = 0;
    while (readLen = recv(hSocket, &message[idx++], 1, 0))  // 分多次从接收缓存读取数据，每次读取一字节
        strLen += readLen;

    printf("Message from server: %s \n", message);
    printf("Function recv call count: %d \n", strLen);

    closesocket(hSocket);   // 关闭套接字
    WSACleanup();           // 注销 winsock 库
    return 0;
}

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