打算专门开一期学习札记系列，主要是重新提炼在学习中遇到的一些重点来反复理解。

第一章：理解网络编程和套接字#

1.1 网络编程和套接字#

网络编程就是编写程序让两台连网的计算机相互交换数据，和我们平时理解的编程差不多，只不过网络编程目的主要是进行网络数据传输。
套接字（ $"socket"$ ）， $socket$ 就是插座的意思。顾名思义，套接字的作用也类似于我们充电时的插座（连接电网来供电），它是用于网络数据传输的一个软件设备。
我们在用 $C$ 语言进行网络编程时会用 $socket$ 函数创建一个套接字。大体如下。

1
#include <sys/socket.h>
2
int socket(int domain, int type, int protocol);
3
//这个函数成功时会返回文件描述符，失败时返回-1。

然后我们需要绑定地址信息（ $IP$ 地址和端口号）。

1
#include <sys/socket.h>
2
int bind(int sockfd, struct sockaddr *myaddr, socklen_t addrlen);
3
//成功时返回0，失败时返回-1。

接着我们需要一个接听的函数，将套接字转化为可接听(连接)状态。

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

最后我们需要能够接受连接请求。

1
#include <sys/socket.h>
2
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
3
//成功时返回文件描述符，失败时返回-1。

上述主要是针对服务器端的一些操作，针对客户端，我们只需要一个套接字和连接 $connect$ 的函数。

1
#include <sys/socket.h>
2
int connect(int sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
3
//成功时返回文件描述符，失败时返回-1。

原书中的这里有一个编写 $"Hello World!"$ 的服务器端和客户端源码，可以在本地进行相互的传输数据，我这里就不具体演示了，感兴趣可以去看原书自己动手试一下。我这里主要记述一下一些重要的知识点。

1.2 基于Linux的文件操作#

这部分主要是有关于 $Linux$ 的基本知识，由于对我来说不算新的知识点，所以我会相对简单地说明。
在 $Linux$ 中， $socket$ 也被认为是文件的一种，所以也可以使用文件操作符来进行操作。系统分配标准输入，输出，错误的文件描述符分别为 $0, 1, 2$ 。创建新文件（或套接字）就会分配新的文件描述符。
文件描述符简单来说就是给要操作的文件标个序号，然后操作时指定这个序号就是对其进行操作了。关于文件操作主要和下面几个函数有关：

1
#include <sys/types.h>
2
#include <sys/stat.h>
3
#include <fcntl.h>
4
#include <unistd.h>
5

6
//path：文件名的字符串地址，flag文件打开模式信息
7
int open(const char *path, int flag);
8
//成功时返回文件描述符，失败时返回-1。
9

10
//关闭对应的套接字或文件的文件描述符
11
int close(int fd);
12
//成功时返回0，失败时返回-1。
13

14
//fd：对应文件的文件描述符，buf：保存传输数据的缓冲地址值，nbytes：传输的字节数
15
ssize_t write(int fd, const void * buf, size_t nbytes);
16
//成功时返回写入的字节数，失败时返回-1。
17

18
//fd和buf同上，nbytes：能接收数据的最大字节数
19
ssize_t read(int fd, void * buf, size_t nbytes);
20
//成功时返回接收的字节数（遇到文件结尾就返回0），失败时返回-1。

此外文件描述符是从小到大的顺序编号，一般从 $3$ 开始，因为 $0, 1, 2$ 是分配个标准 $I/O$ 的描述符。

1.3 基于Windows平台的实现#

这里关于 $Windows$ 的实现也有编写 $"Hello World!"$ 的服务器端和客户端源码，这里同样不再展示。主要讲讲 $Windows$ 和 $linux$ 使用套接字的不同之处。
在 $Winsock$ 进行套接字编程时我们需要使用 $WSAStartup$ 函数，设置程序用到的 $Winsock$ 版本，并初始化相应版本的库。

1
#include <winsock2.h>
2

3
//wVersionRequested：程序员要用的Winsock版本信息，lpWSAData：WSADATA结构体变量的地址
4
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
5
//成功时返回0，失败时返回非零的错误代码。

这里的版本信息我们使用 $MAKEWORD$ 宏函数构建 $WORD$ 型版本信息：

1
MAKEWORD(1, 2); //主版本为1， 副版本为2，返回0x0201。
2
MAKEWORD(2, 2); //主版本为2， 副版本为2，返回0x0202。

第二个参数我们就要传入 $WSADATA$ 类型的结构体变量的地址。（我们需要先初始化一个 $WSADATA$ 类型的变量），参考下面的演示：

1
int main(int argc, char* argv[]){
2
    WSADATA wsaData;
3
    ....
4
    if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
5
        ErrorHandling("WSAStartup() error!");
6
    ....
7
    return 0;
8
}

创建完之后我们就可以通过套接字传输数据了，而在套接字传输完之后我们还需要注销该库。

1
#include <winsock2.h>
2

3
int WSACleanup(void);
4
//成功时返回0，失败时返回SOCKET_ERROR。

调用完该函数之后， $Winsock$ 库会返还给操作系统，无法再调用 $Winsock$ 相关函数。

1.4 基于Windows 的套接字相关函数及示例#

基于 $Windows$ 的套接字相关函数如下：

1
#include <winsock2.h>
2

3
SOCKET socket(int af, int type, int protocol);
4
//成功时返回套接字句柄，失败时返回INVALID_SOCKET。
5

6
int bind(SOCKET s, const struct sockaddr * name, int namelen);
7
//成功时返回0，失败时返回SOCKET_ERROR。
8

9
int listen(SOCKET s, int backlog);
10
//成功时返回0，失败时返回SOCKET_ERROR。
11

12
SOCKET accpet(SOCKET s, struct sockaddr * addr, int * addrlen);
13
//成功时返回套接字句柄，失败时返回INVALID_SOCKET。
14

15
int connect(SOCKET s, const struct sockaddr * name, int namelen);
16
//成功时返回0，失败时返回SOCKET_ERROR。
17

18
int closesocket(SOCKET s);
19
//成功时返回0，失败时返回SOCKET_ERROR。

$Windows$ 中会区分文件句柄和套接字句柄，这一点不同于 $Linux$ 文件描述符，所以我们在 $Windows$ 创建 $socket$ 函数需要用 $SOCKET$ 来存储套接字句柄。
在 $Linux$ 中由于套接字也算是文件，所以可以使用文件 $I/O$ 函数的 $read$ 和 $write$ 来进行数据传输。但 $Windows$ 严格区分 $I/O$ 函数和套接字 $I/O$ 函数，下面介绍 $Winsock$ 数据传输函数：

1
#include <winsock2.h>
2

3
//s：套接字句柄，buf和之前一样，len：要传输的字节数，flags；传输数据时用到的多种选项信息
4
int send(SOCKET s, const char * buf, int len, int flags);
5
//成功时返回传输字节数，失败时返回SOCKET_ERROR。
6

7
//len：能接收的最大字节数，其他的变量同上。
8
int recv(SOCKET s, const char * buf, int len, int flags);
9
//成功时返回接收的字节数（收到EOF时为0），失败时返回SOCKET_ERROR。

这里还要注意 $Linux$ 中也是有 $send$ 和 $recv$ 函数的， $Windows$ 的 $send$ 和 $recv$ 函数并不等价于 $Linux$ 的 $read, write$ 函数。

第二章：套接字类型与协议设置#

2.1 套接字协议及其数据传输特性#

协议简单来说就是为了完成数据交换而定好的约定（通信规则）。
这里需要深入理解一下第一章提到的 $scoket$ 函数。

1
#include <sys/socket.h>
2

3
int socket(int domain, int type, int protocol);
4
//domain：     套接字使用的协议族（Protocol Family）信息。
5
//type：       套接字数据传输类型信息。
6
//protocol：   计算机通信中使用的协议信息。

协议族（ $Protocol Family$ ），也就是套接字通信中使用的一个协议分类。比较常用的是 $IPv4$ 协议族。

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

一个协议族会有多种数据传输方式，而套接字类型（ $Type$ ），会决定套接字的数据传输方式。
这里有两种代表性的数据传输方式：

套接字类型1：面向连接的套接字（SOCK_STREAM）#

主要有三个特征：
1.传输过程中数据不会消失。
2.按序传输数据。
3.传输的数据不存在数据边界（ $Boundary$ ）。
总结成一句话就是可靠的，按序传递的，基于字节的面向连接的数据传输方式的套接字。
在套接字内部有缓冲（ $Buffer$ ）也就是字节数组。通过套接字传输的数据将保存在该数组。所以我们在接收到数据后不一定要立马 $read$ 读取，可以在缓冲区填满了之后再读取。因此在面向连接的套接字中 $read$ 和 $write$ 函数的调用次数并不重要，这也说明了这种套接字不存在数据边界。

套接字类型2：面向消息的套接字（SOCK_DGRAM）#

有四个主要特征：
1.强调快速传输而非传输顺序。
2.传输的数据可能丢失也可能损毁。
3.传输的数据有数据边界。
4.限制每次传输数据的大小。
同样总结成一句话：不可靠的，不按序传递的，以数据高速运输为目的的套接字。
数据边界：每次传输次数和接收次数需要相同，这种特性就是“传输的数据具有边界”。
面向消息的套接字比面向连接的套接字具有更快的传输速度，但是无法保证数据损毁或丢失，且不存在连接这个概念。

协议的最终选择#

第三个参数一般情况下无需考虑直接填 $0$ 即可。除非存在“同一个协议族中存在多个数据传输方式相同的协议”，数据传输方式相同，但是协议不同。此时就算需要通过第三个参数具体指定协议信息。
IPv4协议族中面向连接的套接字：

1
int tcp_socket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);

满足前两个参数的指定的协议只有 $IPPROTO\_TCP$ 协议，所以这种套接字也叫做TCP套接字。
IPv4协议族中面向消息的套接字：

1
int udp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);

同样满足前两参数的指定的协议只有 $IPPROTO\_UDP$ 协议，所以这种套接字也叫UDP套接字。
这里原书中同样给出了 $TCP$ 套接字使用的示例，跟第一章的代码差不多，只不过多演示了一下 $write$ 和 $read$ 调用次数不同仍然能完整传递数据的特性。

2.2 Windows平台下的实现及验证#

Windows操作系统下的 $socket$ 函数：

1
#include <winsock2.h>
2

3
SOCKET socket(int af, int type, int protocol);
4
//成功时返回socket句柄，失败时返回INVALID_SOCKET。

这里原作者提到了一些扩展性问题，尽管 $Windows$ 操作系统下 $SOCKET$ 数据类型返回的也是 $int$ 整型，我们还是尽量使用 $SOCKET$ 而非 $int$ 接收返回值。同理于 $INVALID\_SOCKET$ 。
$Windows$ 下的 $TCP$ 套接字使用示例这里同样也不再赘述。

Mkrari的个人博客