6 网络编程

基本概念扫盲

为什么需要计算机网络

如下图所示，A、B、C三个不同地域的主机要想进行通信不是凭空就可以通信的，而是需要基于互联网进行互相连接、通信。

为什么需要协议

如下图所示，红和蓝是联合攻打绿，它们以烽火为信号出动攻打绿，那么这时候就需要一个约定，比如红先点烽火，然后蓝看见了狼烟再点烽火，红看见了蓝的狼烟之后熄灭烽火，以此表示自己看见了，而蓝看见了红熄灭烽火之后也熄灭自己的烽火以此表示自己知道红看见了此信号，而后两人就需要再约定信号一起整顿出军以确保没有失误。

所以我们知道蓝和红之间的通信不能保证100%成功，但是要尽量保证没有失误的话就需要一遍又一遍的去确认，而这些一次又一次的确定就是双方定下的协议；由此我们可以清楚的认识到我们在网络通信中是必须要有协议的存在的。

为什么需要这么多协议

上文中我们举了两军协同作战，他们之间有个作战协议，而一旦作战成功，夺下对方城池那就需要另外一个瓜分战果的协议，所以每个不同的场景都会有对应的协议，这是有这么多协议的原因。

如下图所示，我们的计算机网络也有很多协议，下面是分为五层，如果你了解过计算机网络协议应该会知道七层模型、五层模型，但本章节不讲七层模型而是选择五层模型，因为七层模型是一种理想化的模型，实际应用我们用到的是五层模型。

如何定位互联网上的终端

首先我们熟知的系统是通过线程ID、进程ID知道对应的线程和进程的，在每个国家公民都是有身份证号码的，这也用来定位你这个人；在互联网上同样也有这样一个标识去确认终端，这就是IP地址。

IP地址以"."符号分割，一共有四组，例如：120.120.120.120，每一组都是的区间都是0到255，IP地址的组成是网络号加上主机号，而具体的界定我们可以查看下文。

IP地址分为5类，其分别如下所示：

类型	起始地址	结束地址
A类	0.0.0.0	127.255.255.255
B类	128.0.0.0	191.255.255.255
C类	192.0.0.0	223.255.255.255
D类	224.0.0.0	239.255.255.255
E类	240.0.0.0	247.255.255.255

我们不需要死记硬背，需要的时候自己查下就可以，具体含义网上很多，这里不过多赘述。

如何区分出网络号、主机号

如上图中我们可以知道IP地址分成了网络号和主机号两部分，通过子网掩码可以从IP地址中区分出网络号，其运算规则是：网络号 = IP地址 &(按位与) 子网掩码。

我们查看自己本机的IP地址和子网掩码来计算：

IP地址：192.168.8.117，子网掩码：255.255.255.0，将这两个转为二进制则为：

11000000.10101000.00001000.01110101

11111111.11111111.11111111.00000000

我们进行按位与运算，结果就是：

11000000.10101000.00001000.00000000

C0.A8.08.00

192.168.8.0

那么在这里192.168.8.0就是其网络号，同样我们可以根据子网掩码来获取主机号，其运算规则是：主机号 = IP地址 &(按位与) ~(取反)子网掩码。

~ 11111111.11111111.11111111.00000000 // 取反子网掩码

00000000.00000000.00000000.11111111

& 11000000.10101000.00001000.01110101 // 按位与

00000000.00000000.00000000.01110101

Dec -> 0.0.0.117 // 十进制结果

最终结果我们知道了其主机号为0.0.0.117。

子网掩码本质上是32位的二进制，只不过是为了看着直观一些就转为了十进制，子网掩码1所对应的位为网络号位而0所对应的位为主机号位，其用来区分有几个子网，例如这里我们的255.255.255.0，转为二进制实际上前24位是网络位，后8位是主机位，那也就表示我们只有一个子网，在这里我们的子网地址范围就是：192.168.8.0-192.168.8.255，可用的主机号计算公式就是2的8（主机位）次方-2，这里结果也就是254，为什么我们还需要减去2，这是因为根据计算方法，192.168.8.0就是网络号（代表当前网络），同时根据定义，主机号位全为1的地址为此网段的广播地址，此时的广播地址为192.168.8.255，去掉网络地址和广播地址，也就是254个主机号可用。

而如果我们的子网掩码为255.255.255.192，转为二进制就是11111111.11111111.11111111.11000000，可以看见其在我们的原先的后8位主机位中占用了2位作为网络位，现在有26个1，那么根据二进制非0即1，其表现方式就有11000000、10000000、00000000、01000000，也就是说我们将原有的192.168.8.0这个网络分成了四份，即4个子网，也可以理解为这里就是2的2（后8位主机位中占用了2位）次方，现在我们将它们转换成10进制就分别是0、64、128、192，那么这4段网络的范围如下所示：

192.168.8.0 - 192.168.8.63

192.168.8.64 - 192.168.8.127

192.168.8.128 - 192.168.8.191

192.168.8.192 - 192.168.8.255

端口号是什么

问题：系统中有很多个进程连着网，比如QQ、微信、迅雷...那么系统是如何区分出数据包应该分给哪个进程呢？

答案：系统是根据端口号来区分出数据包应该分给哪个进程，每个联网的进程都会分配一个系统唯一的ID，发送数据包的时候这个ID也会放进去，接受数据包的时候就可以根据这个ID来分别出对应进程，这个ID也就是端口号。

注意：端口号的范围就是0-65535

网关是什么

如下图所示，路由器就是一个网关，网关就相当于是网络的一扇门，关内是一个网络，A、B、C、D都可以在这个网内进行通信，就不需要网关了，而如果A想跟E进行通信就需要通过网关将你的请求转发去通信，这是因为E不在关内。

DNS是什么

假设你访问的是www.baidu.com，这是一个域名，但是这个域名你想要去访问到真正的那些展示给你的资源其背后对应的正是某个服务器的IP，根据这个IP和对应的端口你才可以访问到资源，而将域名和IP进行关联的正是DNS。

DNS服务器通过记录域名和IP的关联，当你想要去访问某个域名的时候，就需要给DNS服务器发送请求，而后DNS服务器接收到你的请求，将请求中想要查询的域名在DNS服务器本身的记录中去搜索找到对应的IP，最后返回给你。

TCP客户端和服务器端编程架构

什么是TCP

TCP，英文全称是Transmission Control Protocol，中文为传输控制协议，在我们之前所说的五层还是七层模型中，TCP都属于传输层。

如下图所示，A和B基于TCP协议进行传输控制，该协议可以控制协议传输或者说保证传输过程中的数据是正确的：

面向连接

之前我们说到TCP协议可以保证传输过程中的数据是正确的，这是因为其是面向连接的网络协议。

如下图所示，客户端和服务器端基于TCP进行传输通信，首先客户端要跟服务器端说（发送请求）我要跟你进行连接，其次服务器端要回应（发送请求）允许客户端进行连接，而后客户端才会在发送一个请求正式连接，这就是三次握手的特点。

当客户端和服务器端连起来之后，才是会进入传输。

服务器端编程框架

了解了理论之后就要付诸于行动，在编程的时候我们的服务器端要有七个步骤去完成：

1. 创建套接字

2. 绑定套接字

3. 监听套接字

4. 等待连接

5. 收发数据

6. 断开连接(被动)

7. 关闭套接字

这时候就有一个新的东西，就是套接字，这是系统给你打包好的，你可以理解这是网络通信过程中端点的抽象表示，而想要客户端去连接服务器端，就需要一对套接字，一个运行在服务器端，一个运行在客户端；如果概念无法很清晰的去了解，没关系，在实际编程中你就会有所体会。

按顺序编写代码

首先我们创建一个Win32控制台应用的项目，其次在头部包含文件和调用lib：

#include <WINSOCK2.H>

#pragma comment(lib, "ws2_32.lib")

接着我们就需要按照顺序去编写代码，首先第一步是创建套接字，这个需要用到一个函数socket，其语法如下：

SOCKET socket(

int af, // 地址族规范：常见有IPv6（AF_INET6）或IPv4（AF_INET）

int type, // 套接字类型：原始套接字SOCKET_RAW（对较低层次的协议直接访问，例如IP、ICMP协议）、SOCK_STREAM面向连接（TCP/IP协议）、SOCK_DGRAM面向无连接（UDP协议）

int protocol // 使用的协议：这里我们可以直接写0，这样操作系统就会根据前面两个选项推断出你想用的协议

);

// 实现代码

SOCKET sSocket = socket(AF_INET, SOCK_STREAM, 0);

接下来我们的就需要绑定套接字，使用函数bind，其语法如下：

int bind(

SOCKET s, // 套接字：将创建的套接字变量名字写上去

const struct sockaddr FAR *name, // 网络地址信息：包含通信所需要的相关信息，传递的应该是一个sockaddr结构体，在具体传参的时候，会用该结构体的变体sockaddr_in形式去初始化相关字段

int namelen // sockaddr_in结构体的长度

);

sockaddr_in结构体的定义如下：

/*

* Socket address, internet style.

*/

struct sockaddr_in {

short sin_family; // 地址族规范：与创建套接字时候所使用的一致即可

u_short sin_port; // 端口

struct in_addr sin_addr; // IP地址

char sin_zero[8]; // 无特殊的含义，只是为了与sockaddr结构体一致，因为在给套接字分配网络地址的时候会调用bind函数，其中的参数会把sockaddr_in结构体转化为sockaddr结构体

};

我们只需要关注前三个成员即可，最后一个不用管，可以看见IP地址又是一个结构体，我们接着看看in_addr结构体：

/*

* Internet address (old style... should be updated)

*/

struct in_addr {

union {

struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;

struct { u_short s_w1,s_w2; } S_un_w;

u_long S_addr;

} S_un;

#define s_addr S_un.S_addr

/* can be used for most tcp & ip code */

#define s_host S_un.S_un_b.s_b2

/* host on imp */

#define s_net S_un.S_un_b.s_b1

/* network */

#define s_imp S_un.S_un_w.s_w2

/* imp */

#define s_impno S_un.S_un_b.s_b4

/* imp # */

#define s_lh S_un.S_un_b.s_b3

/* logical host */

};

这个结构体里面又是一个联合体，联合体和结构体是差不多的，区别在于联合体用于覆盖使用而结构体是不覆盖使用；

并且我们通过代码可以看见这就是一个u_long类型的地址，我们可以使用函数inet_addr来按照网络字节序转换：

inet_addr("192.168.1.1");

最终，我们在赋值的时候还是要选择某个成员去赋值，代码实现如下（需要注意的是，这里的IP地址是不可以乱写的需要通过命令行或其他方式获取本机的IP地址）：

sockaddr_in sockAddrInfo = {0}; // 初始化

sockAddrInfo.sin_addr.S_un.S_addr = inet_addr("192.168.1.1"); // 地址

sockAddrInfo.sin_port = htons(2118); // 端口需要按照网络字节序，所以需要使用htons函数

sockAddrInfo.sin_family = AF_INET; // 地址族规范

bind(sSocket, (sockaddr*)&sockAddrInfo, sizeof(sockAddrInfo));

第三步就是监听套接字，使用函数listen，其语法如下：

int listen(

SOCKET s, // 套接字：将创建的套接字变量名字写上去

int backlog // 待处理连接队列的最大长度：表示队列中最多同时有多少个连接请求

);

// 实现代码

listen(sSocket, 1);

第四步等待连接，使用函数accept，其语法如下：

SOCKET accept(

SOCKET s, // 套接字：将创建的套接字变量名字写上去

struct sockaddr FAR *addr, // 输出参数，需要传入一个sockaddr结构体的地址

int FAR *addrlen // 输出参数，需要传入一个sockaddr结构体长度的地址

);

// 实现代码，accept返回的也是一个SOCKET，我们需要赋值一下

sockaddr_in acceptSockAddrInfo = {0}; // 初始化

int acceptSockAddrLen = 0;

SOCKET aSocket = accept(sSocket, (sockaddr*)&acceptSockAddrInfo, &acceptSockAddrLen);

第五步收发数据，首先我们看下收数据，使用到函数recv，其语法如下：

int recv(

SOCKET s, // 套接字：将accept返回的套接字变量名字写上去

char FAR *buf, // 输出参数，数据缓冲区，接收到的数据

int len, // 缓冲区大小

int flags // 指定调用方式的标志，这个我们就直接写0即可

);

// 实现代码

char buf[100] = {0};

recv(aSocket, buf, 100, 0);

printf("Recv data: %s\n", buf);

接着我们看下发数据，使用函数send，其语法如下：

int send(

SOCKET s, // 套接字：将accept返回的套接字变量名字写上去

const char FAR *buf, // 传输数据的缓冲区

int len, // 缓冲区大小

int flags // 指定调用方式的标志，这个我们就直接写0即可

);

// 实现代码

send(aSocket, buf, strlen(buf)+1, 0);

第六步断开连接，我们使用shutdown函数，其语法如下：

int shutdown(

SOCKET s, // 套接字：将accept返回的套接字变量名字写上去

int how // 断开连接的形式：SD_SEND不再发送数据、SD_RECEIVE不再接受数据、SD_BOTH不再收发数据

);

// 实现代码

shutdown(aSocket, SD_SEND);

第七步也是最后一步，关闭套接字（这里有2个都要关闭），使用函数closesocket，其语法如下：

int closesocket(

SOCKET s // 套接字：将accept返回的套接字变量名字写上去

);

// 实现代码

closesocket(aSocket);

closesocket(sSocket);

这时候还没有结束，需要使用函数WSAStartup进行Winsock的初始化，其语法格式如下：

int WSAStartup(

WORD wVersionRequested, // 版本号，指定所需的Windows Sockets版本，我们可以使用MAKEWORD去创建一个版本号

LPWSADATA lpWSAData // 指向WSADATA数据结构的指针，用于接收Windows Sockets实现的细节

);

实现代码如下：

WORD wsVersion = MAKEWORD(2, 2);

WSADATA wsaData = {0};

WSAStartup(wsVersion, &wsaData);

最终我们实现了服务器端的功能，完整代码如下：

int main(int argc, char* argv[])

{

// 0. 初始化

WORD wsVersion = MAKEWORD(2, 2);

WSADATA wsaData = {0};

WSAStartup(wsVersion, &wsaData);

// 1. 创建套接字

SOCKET sSocket = socket(AF_INET, SOCK_STREAM, 0);

if (SOCKET_ERROR == sSocket) {

printf("套接字闯创建失败!\n" );

}

else {

printf("套接字闯创建成功!\n" );

}

// 2. 绑定套接字

sockaddr_in sockAddrInfo = {0}; // 初始化

sockAddrInfo.sin_addr.S_un.S_addr = inet_addr("172.16.176.5");

sockAddrInfo.sin_port = htons(2118); // 端口

sockAddrInfo.sin_family = AF_INET; // 地址族规范

int bRes = bind(sSocket, (sockaddr*)&sockAddrInfo, sizeof(sockAddrInfo));

if (SOCKET_ERROR == bRes) {

printf("绑定失败!\n");

}

else {

printf("绑定成功!\n");

}

// 3. 监听套接字

int lRes = listen(sSocket, 1);

if (SOCKET_ERROR == lRes) {

printf("监听失败!\n");

}

else {

printf("监听成功!\n");

}

// 4. 等待连接

sockaddr_in acceptSockAddrInfo = {0}; // 初始化

int acceptSockAddrLen = sizeof(acceptSockAddrInfo);

SOCKET aSocket = accept(sSocket, (sockaddr*)&acceptSockAddrInfo, &acceptSockAddrLen);

if (INVALID_SOCKET == aSocket) {

printf("服务端等待连接失败!\n");

}

else {

printf("服务端等待连接成功!\n");

}

// 5. 收发数据

char buf[100] = {0};

// 循环

while (true) {

int ret = recv(aSocket, buf, 100, 0);

if (ret == 0) {

// 如果recv返回为0则表示客户端要断开连接，就跳出循环断开连接

break;

}

printf("Recv data: %s\n", buf);

send(aSocket, buf, strlen(buf)+1, 0);

memset(buf, 0, 100);

}

// 6. 断开连接(被动)

shutdown(aSocket, SD_SEND);

// 7. 关闭套接字

closesocket(aSocket);

closesocket(sSocket);

WSACleanup();

return 0;

}

最后，如果你不使用了这个扩展就需要使用WSACleanup函数去终止使用；建议在实际编程过程中，应该将函数的返回值存储下来并做判断。

客户端编程框架

客户端编程框架的步骤就简单了一些，只有六个步骤：

1. 创建套接字

2. 绑定套接字

3. 连接服务器

4. 收发数据

5. 断开连接(主动)

6. 关闭套接字

了解了服务器端如何编写，客户端也就了如指掌的，实现代码如下：

int