一.前言

一开始时，计算机都相互独立，只能通过软盘，才能把数据交给另一台计算机

后面因为效率原因，就有了服务器，都从服务区上拿数据

美国一开始有贝尔实验室、麻省理工实验室…一开始实验室各搞各的，所以局域网有很多种类的以太网、令牌网…
新技术的产生，一定产生了新设备(芯片技术应用到笔记本，就叫做计算机；用到汽车上，就叫做智能汽车)，所以计算机的发展，肯定伴随着新的设备(比如网络通信，得有网线)
1994年中国进入互联网，不仅让腾讯阿里发展很好，华为和其它通信的公司也发展起来。
当计算机太多时，就有了交换机和路由器

计算机越来越多，就有了广域网

二.协议

协议就是一种约定。
比如：1+1=2是公认，它也可以说成One plus one equals two。语言可以不同，但只能1+1=2。这就是一种协议。
计算机厂商上有很多，但要让计算机之间有需要一种协议
能定制标准的都是世界公认的组织或公司，但定标准，不一定要实现标准。比如：华为定的5G标准，不一定要华为自己实现，但其它公司要做5G，得按照华为定的标准实现。

协议分层

协议本身就是软件，为了更好的模块化，解耦合，最好也要分层。

分层的好处

以两个人说话方式为例：

这是分两层，语言层和通信设备层：

这就是模块化的解耦合，一层出现问题，另一层并不影响，下一层出现了问题，替换了协议，上一层完全不受影响。(软件层划分的越合理，越好，比如封装、STL容器)
出了问题也好排查。张三听不清楚李四打电话，无非就是语言不同或者交流方式出现了问题。

OSI七层模型

OSI（Open System Interconnection，开放系统互连）七层网络模型称为开放式系统互联参考模型，是一个逻辑上的定义和规范。
定标准和实现标准是两批人，实现由顶级的工程师实现，windows和Linux能通信就是因为两者之间遵守着同一个协议。

	分层名称	功能	每层功能概述
7	应用层	针对特定应用的协议
6	表示层	设备固有数据格式和网络标准数据格式的转换
5	会话层	通信管理。负责建立和断开通信连接(数据流动的逻辑通路)。管理传输层以下的分层
4	传输层	管理两个节点之间的数据传输。负责可靠传输(确保数据被可靠地传送到目标地址)
3	网络层	地址管理与路由选择。
2	数据链路层	互连设备之间传送和识别数据帧。
1	物理层	以"0"、"1"代表电压的高地、灯光的闪灭

实际真正落地的不是OSI七层模型，而是5层协议，会话层、表示层、应用层这三个规划为一个大的应用层，因为会话层和表示层是不可能接入到操作系统中的。

TCP/IP五层(或四层)模型

TCP是传输层的协议，IP是网络层的协议。TCP/IP是一组协议的代名词。
5层分别为：

物理层	规定什么是’0’、‘1’，特定的01序列是什么含义。通信媒介不一样，规定传递的方式。
数据链路层	设备和设备之间的传递和识别，有以太网、令牌环网、无线LAN等保证设备之间的通信。
网络层	两个跨网络的设备需要IP地址传输。
传输层	数据传输长距离传输时丢包或乱序怎么处理?
应用层	设备A从北京送到在西安的设备B，其中传数据的目的，如何应用?

其中物理层是光电信号的传递，所以只谈剩下的4层。

为什么要有TCP/IP协议

首先，即便是单个计算机，都是存在协议的，比如与磁盘通信会有磁盘相关的协议：SATA、IDE、SCSI等。设备之间的协议都是在计算机内部，比如内存和磁盘距离个10厘米，通信的成本低，问题就少。
网络因为距离很远，由于物理特性就会出现很多问题。比如男女朋友，在同一个学校，出现问题，解决问题的成本低；异地恋，则会提高成本。

假设主机A发送数据给主机C的过程中，依次会产生的问题：
1.主机A发送给主机C，得把数据交给路由器。(异地恋给女朋友买东西，得交给快递小哥)
2.网络上这么多主机，如何准确的找到主机C。
3.如果我的数据在发送的过程中，在某一个节点丢失了怎么办？(快递小哥转发错地方了)
4.发送数据不是目的，只是手段，让主机C使用数据是目的。(主机A把‘你好’发给主机C，主机C需要处理‘你好’，是以读不回还是以读乱回)
所以有了各种协议，去解决上面的问题。
TCP/IP协议是一种解决方案，本质问题是两台通信的主机距离变远了，所以有了各种问题，需要通过TCP/IP协议这种解决方案去解决。

TCP/IP协议与操作系统的关系(宏观上是如何实现的)

Windows和Linxu底层是不一样的，传输层(典型协议是TCP)和网络层(典型协议是IP)在操作系统内部实现的，虽然操作系统实现本身不一样，但网络部分必须是一样的，这就是为什么Windows和Linux能通讯。
不同主机或厂商所对应不同设备之间可以通信的秘密就在于，大家实现的是相同的网络协议栈。

什么是协议

OS一般都是用C/C++写的代码。
假设有两个主机A、B，两个主机的内核的代码不一样，但传输层和网络层的的代码一样。在传输层有一个结构体protocol，主机A发送struct protocol data给主机B。
问题：在通信的时候是传输二进制数据，主机B能识别data，并精确的识别a=10,b=20,c=30吗？

答：是可以的；因为双方都有同一个结构体struct protocol，所以主机B能立马识别abc的值。
所谓协议：就是通信双方都认识的结构化的数据类型。
因为协议是分层的，所以每层双方都有协议，同层之间，互相可以认识对方的协议。
以网上购物发快递为例子：

买键盘，实际就想要一个键盘。但实际给我的，除了键盘还给了盒子上贴的一张快递单，我看到这个快递单子，就能确认这是我的快递。快递单+键盘两个共同构成了一个完整的报文。
快递单上所有的信息都是发快递的人填的，快递小哥和我也明白快递单上面的内容。这个单子就是三者之间的约定，这个约定是快递公司定的(定标准的人)。发快递的人、快递小哥与收快递的人一起遵守这个约定。
用C语言表示这个快递单，不就是一个结构体。快递单就是协议的报头，键盘就是有效载荷，合在一起叫做报文。
发送方构建快递单叫做构建报头，把键盘装起来叫做封装。
综上所述：协议就是约定。

三.网络传输基本流程

以太网、无线LAN等局域网之间的标准是可以不同的。

局域网(以太网为例)通信原理

问题：两台主机在同一个局域网，是否可以直接通信？
答：是可以的；宿舍的无线路由器，你和舍友连着同一个局域网，和隔壁宿舍连着是不同的局域网，小时候玩<<我的世界>>开个热点把4G网络关上依旧能一起玩，在同一局域网。
故事：在教室里，老师喊张三，问作业为什么没做，站起来！教室里的同学都听到了，张三分析老师刚刚说的信息，提取目的地址叫做张三，就站起来了，然后张三跟老师说：我作业交了。其他人分析刚刚老师说的消息里面的一个目的地址叫做张三，跟自己没关系，直接把听到的这句话丢弃掉，不做响应。
双方在通信的整个过程，老师与张三都互相认为在单独通信。周围其他人也能听到这个消息，但不做响应。
其中教室叫做局域网，老师为主机A，张三为主机B，两者通信时只要知道对方名字就能通信，其他人能收到但不做响应，这就是局域网通信的基本原理。
总结：局域网能直接通信，每台主机(局域网)都要有一个唯一的标识：MAC地址

MAC地址

MAC地址是数据链路层中相连的节点。(就是标识主机的唯一性)
长度为48位，6个字节，一半用16进制＋冒号的形式来表示。
可以用ifconfig指令查看：

ifconfig

Mac地址是集成在网卡中的地址，在出厂时就设置好了，可以说在全球具有唯一性。
问题：操作系统时如何获取Mac地址？
答：开机时，网卡的驱动程序会根据网卡的协议，会把Mac地址读到操作系统。
不仅仅网卡有唯一标识，很多设备都有唯一标识，比如磁盘也是有全球唯一标识，叫做序列号。
虚拟机中的Mac地址不是真实的地址，而是虚拟出来的，可能会产生冲突。
以主机A用以太网给主机E发送数据为例：

以太网通信的原理：
1.在以太网中，任何时刻，只允许一台机器向网络中发送数据。
2.如果有多台同时发送，就会产生数据干扰，称为数据碰撞。(发送的01序列，之间可能干扰)
3.所有发送数据的主机要进行碰撞检测和碰撞避免。(主机A把数据发出去了，检测数据有没有发送成功，主机A自己也是一台主机，所以自己发送的数据自己能到，跟发的数据和收的数据做比较，查看是否碰撞，一旦发生碰撞了，就要进行碰撞避免。比如主机A与主机B发生了碰撞，两主机都要休眠一定的随机时间，再次碰撞的概率减小，同时这个局域网中少了两台主机，可以让其它主机趁着这个间隙发送数据)
根据上面三个原理，很像一种临界资源(公共的数据)，只允许一种主机，访问该临界资源里的资源。
4.没有交换机的情况下，一个以太网就是一个碰撞域。
5.局域网通信的过程中，主机对收到的报文确定是否发给自己的，是通过目标Mac地址判定。
可以通过系统角度来理解局域网通信。

令牌环网

主机A持有数据，就能发消息。主机B持有数据，也能发消息。这不就是一把锁。

封装与解包分用

在同一个局域网内，发送消息的过程：

其中每层都有协议，所以当进行上述传输流程时，要进行封装和解包：

明确概念：
以网络层为例：网络层报头为报头。传输层报头、应用层报头与“你好”为有效载荷。

从上到下添加报头，可以想象成一个入栈的结构，往上交付的过程就是出栈的过程，所以我们也称为网络协议栈：

数据在网络中发送的时候，一定最终要在硬件上跑，主机2的网卡先收到数据，然后再向上解包分用。就比如你在三楼宿舍要去3楼教学楼，只能从宿舍的三楼跑到1楼，然后再从教学楼的1楼跑到3楼:

应用层存在上百种协议，传输层有tcp/udp…，网络层有IP/ICMP…链路层有mac
若发送数据应用层用http，传输层用tcp，网络层用ip，链路层用mac，那问题在于接收层，网络层中有ip/icmp…等协议，如何知道发送方的网络层用到什么协议？

在前面说了，报头(协议)就是一种结构体，那么封装的时候，他会把有效载体封装进结构体中：

总结：网络协议有两个共性：
1.报头和有效载荷分离的问题 – 解包。
2.除了应用层，每一层协议都得解决一个问题：自己的有载荷，应该交给上一层的那一种协议 – 分层。
快递就有分用的功能，快递小哥到当地了，给每一个收快递的人打电话，不就是一种分用。电话是什么时候填的？是在发快递时候填好了(封装)。
报文 = 报头 + 有效载荷
在不同场景下，不同的报文有不同的名字(比如在学校叫某同学，工作某同事)

补充：
1.应用层数据通过协议栈发到网络上时,每层协议都要加上一个数据首部(header),称为封装。
2.首部信息中包含了一些类似于首部有多长, 载荷(payload)有多长, 上层协议是什么等信息。
3.数据封装成帧后发到传输介质上,到达目的主机后每层协议再剥掉相应的首部, 根据首部中的 “上层协议字段” 将数据交给对应的上层协议处理。

四.IP地址

上面讲述的都是在同一局域网中通信，那么不在同一局域网如何通信？
路由器：路由器要能够跨网络转发，至少连接两个网络，就得配上多个网络与驱动程序。
下图主机A的路由器与主机B的路由器分别配两张网卡：1个网卡连接的是以太网；1个连接着令牌环网。
因为用的局域网不同，所以主机A用的以太网的驱动程序，主机B用的令牌环网的驱动程序。

其中，IP地址是标识网络中唯一性的，IP协议有两个版本：IPv4和IPv6。
IPv4是一个4字节，32位的整数，通常用“点分十进制”的字符串标识IP地址，例如：192.168.0.1；用点分隔的每一个数字为一个字节，数字区间为0~255。
IPv6是一个16字节，128位的整数。
Linux下的IP地址：

Windows下看网络地址：ipconfig

紧接着上面用户A与用户B通信，本质就是网络协议栈之间的通信：

路由器和用户A属于一个局域网，路由器和用户B也属于通一个局域网。他们两两配置的网卡是相似的，在同一网段就能通信，以Windows为例：

在网络层不仅要添加报头，还要路由。(路由：信息要去172.168.22，肯定不是自己这个局域网(在相同的局域网中，主机都是同样的开头，比如192开头)，所以肯定不是交给内网，要交给路由器)

路由：发现不是发给自己局域网主机的报文，就推送给服务器。
网络层到数据链路层的报头是：macA帧（其中包含scr：macA，代表是主机A发送的。还有dst：macleft），其余主机会收到该报文，但发现dst的地址不是他们自己，就不做处理，只有路由器会收到。路由器收到该报文，确认报文是自己的，向上交付给网络层：

网络层再次路由，然后路由器发现你要去dst：172.168.2.2和网卡对应的IP地址(172.168.2.1)差不多，于是再把报文再进行向下交付，重新封装（报头：src：macRight，dst：macB）
后有数据电路层收到报文并解包交给上层。

这个过程我们发现：主机A网络层拿到的报文、路由器网络层拿到的报文、主机B网络层拿到的报文，他们原IP、目的IP、数据是一模一样的：

结论：网络层(就是IP层)向上(包括网络层)看到的所有的报文都是一样的，所以IP可以屏蔽底层网络的差异!
这就是为什么用的手机用无线网、令牌环、油量…都能相互通信！

IP VS Mac地址

IP地址和mac地址的区别：
故事：
唐僧去西天取经

其中发现上面有两套地址中，其中车迟国领主、女儿国女王、火焰山领主就相当于一张路由表，方便我们查询。
唐僧问车迟国国王下一站去哪里时，国王想的过程就是查询一次路由表的过程。
唐僧提供地址信息，车迟国国王提供的路由表的信息，两个信息一结合就知道接下来唐僧要去女儿国。
其中IP地址不变，变得都是mac地址。

问题：为什么车迟国国王提供的信息是女儿国，不是其它的国家？
答：你和朋友在北京，要去云南旅游：

其中mac地址受IP地址影响。(阶段性目标受最终目标影响)，比如最终目标是成为一名博士，前一个阶段得先是研究生。

五.Socket编程预备

理解源IP地址和目的IP地址

IP在网络中是标识主机唯一性的，跨网络的。
mac地址是在局域网中标识唯一性的，只在局域网内有效，出了局域网就把“衣服”脱掉了。
问题：数据传输到主机是目的吗？主机A把数据交给主机B就完了吗？

答：不是的。因为数据都是给人用的，比如：聊天是人与人聊天，游览网页是人在游览。人是通过QQ来聊天、通过游览器游览网页。启动QQ和游览器都是进程，进程是人在系统中代表，只要数据交给进程，人就相当于拿到了数据：

传输数据到主机不是目的，而是手段。到达主机内部，在交给主机内的进程，才是目的。
为了在任意主机内标识进程，引入了一个概念：端口号。

端口号

端口号(port)是传输层协议的内容：
1.端口号是一个2字节16位的整数；
2.端口号用来标识一个进程，告诉操作系统，当前的这个数据要交给哪一个进程来处理；
在传输层报头当中，会把端口号(port)写入其中：

需要网络通信的这类进程（比如QQ、B站…）启动的时候，需要自己绑定特定的端口号。
传输层收到报文时，通过报文中的端口号进行转发给指定的进程，我们在未来写代码的时候，就一定要和指定的port进行关联：

通信是两个人在通信，也可以说是两个进程在通信。
IP + PORT = 互联网中唯一的一个进程：

主机收到数据不是目的，而是手段，真正收到数据的是进程。
综上所述：网络通信的本质是进程间通信！！！
进程之间通信需要：
1.保证独立性。
2.看到一份公共资源(网络)。
其中IP地址+PORTA(端口)叫做socket通信。
问题：PID也是标识进程唯一性的，为什么不能用PID标识，而用port标识？
答：1.从技术上是可以做到的，但是PID是系统级别的概念，而port是网络的概念，让传输层用PID把数据交道应用层，就会产生强耦合。如果一个PID发生变换，那么整个网络部分都要调整。所以要做到系统是系统，网络是网络，系统与网络要做到解耦。
2.所有的进程都有PID，但不是所有的进程都想网络通信，所以在系统中，只有少量通信的进程，需要端口号，未来可以用端口号来分别该进程是否需要网络通信。
例子：在学校，每个人都有学号，且每个人都有身份证号，为什么学校不用身份证号来分辨而多出个学号呢?
方便管理，这就很好的做到了社会层面和学校层面的解耦，学号变了不影响身份证号。
注意：一个端口号只能被一个进程占用。

端口号范围划分

腾讯的QQ号不是所有的都能用，其内部保留了一些。
端口号也不是都能用的，一共有0~65535个端口号，说明一个服务器可以启动65536个网络服务，但不会那么多，3、4个服务已经够多了。
0~1023：知名端口号，HTTP,FTP,SSH等这些广为使用的应用层协议，他们的端口号都是固定的，深度捆绑。(这就跟110、120电话的性质类似)
1024~65535：操作系统动态分配的端口号(可以自己手动绑定)、客户端程序的端口号。

认识TCP协议与UDP协议

TCP协议：传输层协议、有连接、可靠传输、面向字节流。
UDP协议：传输层协议、无连接、不可靠传输、面向数据报。
传输数据时，如果数据丢失了，TCP协议可以提供相对应的策略(比如：丢失后重传、乱了进行重组排序)，UDP协议丢了就是不管。
那就说了，直接用TCP协议不就得了，其实可靠传输是其的特征，不是优缺点，因为要保证可靠传输，说明要做更多的工作，得知道哪些丢了、哪些没丢。UDP协议不用做这么多工作，使用上更简单。
TCP协议常用于转账的领域；UDP协议常用于直播领域：

网络字节序（大小端）

我们学习C语言时就明白，存在大小端的问题，就是数据的存储方式。
把低权值位放到高地址就是大端机，把低权值位放到低地址处就是小端机：

不同的机器存储的方式是由差别的。
问题：如果主机A以大端的方式发送数据，主机B以小端的方式接收数据，不就反了？

答：定了个标准，网络通信必须大端！！即低地址高字节。

网络主机相互转换接口

未来为了使我们写的程序具有可移植性，在写通信的过程中大部分的大小端会自动帮我们转了，但端口号和IP地址之类的需要自己转化，系统提供了函数：

socket编程接口

// 创建 socket 文件描述符 (TCP/UDP, 客户端 + 服务器)
 int socket(int domain, int type, int protocol);
 // 绑定端口号 (TCP/UDP, 服务器)      
int bind(int socket, const struct sockaddr *address,socklen_t address_len);
 // 开始监听socket (TCP, 服务器)
 int listen(int socket, int backlog);
 // 接收请求 (TCP, 服务器)
 int accept(int socket, struct sockaddr* address,socklen_t* address_len);
 // 建立连接 (TCP, 客户端)
 int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen)

发现很多函数都用了sockaddr结构体，先说该结构体。

sockaddr结构

socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4、IPv6。
socket的发明者不仅仅想让进程可以完成网络通信，也可以完成本主机通信:

网络在设计的时候，就考虑到让用户使用同一套的接口，能用来表示不同种类的通信方式，这不就是多态嘛！！

六.Socket 编程 UDP

echo server 服务端

首先要创建套接字。
socket函数：

其中AF_UNIX与套接字SOCK_DGRAM都是宏：

返回值：成功时，返回文件描述符；出错时，返回-1

创建套接字可以理解成把网卡打开了，在Linux系统中一切皆文件，网卡也是文件，所以可以通过返回的文件描述符对网卡设备进行读写(IO)。
未来进行收消息或发消息都需要sockfd(套接字)：

1. 创建socket文件：

void InitServer() // 初始化_sockfd
{
	// 1.创建socket文件
	_sockfd = socket(AF_UNIX, SOCK_DGRAM, 0);
	if (_sockfd < 0)
	{
		LOG(FATAL, "create socket error");
		exit(SOCKET_ERROR);
	}
	LOG(DEBUG, "create socket success,sockfd :%d", _sockfd);
}

2. 绑定：

客户端和服务器都要有IP地址与端口号：

bind函数，让套接字信息(IP、端口号…)与套接字(socket)关联起来。

struct sockaddr_in 里面的内容：

• sin_family储存AF_INET(网络的信息)。
• sin_port储存16位的端口号。
• sin_addr存储IP36位的IP地址。
  发短信时，主机A不仅要把信息发送给主机B，主机A还把IP地址与端口交给主机B，因为主机B要给主机A应答。说明IP地址与端口都要走网络，所以IP地址与端口号要转成网络序列（大端）。
  平常我们喜欢用string类型的变量当IP地址，但是使用时需要4字节的网络序列，所以需要把string类型转换为4字节的网络序列。
  就有了接口：inet_addr
  

// 2.bind
        struct sockaddr_in local;
        memset(&local,0,sizeof(local)); //置空
        local.sin_family = AF_INET;
        local.sin_port = htons(_localport); //主机转网络序列
        local.sin_addr.s_addr = inet_addr(_locallip.c_str()); //1.4字节 2.网络序列
        int n = ::bind(_sockfd,(struct sockaddr*)&local,sizeof(local)); 
        if(n < 0)
        {
            LOG(FATAL,"bind error");
            exit(BIND_ERROR);
        }
        LOG(DEBUG,"socket bind success");

服务器运行之后就不会关，就比如某杀毒软件，你关了也关不上。
所以启动是死循环，干什么事情在里面填写：

void Start()
    {
        _isrunning = true;
        while(_isrunning)
        {
            //otherthing
        }
    }

整体代码如下：

#pragma once

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "NoCopy.hpp"
#include "Log.hpp"

using namespace log_ns;

enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
};

int gsockfd = -1;
uint16_t glocalport = 888;

// UdpServer user("192.1.1.1",8899);
class UdpServer : public nocopy //继承单例
{
public:
    UdpServer(std::string &locallip,uint16_t localport = glocalport)
        : _sockfd(gsockfd),
          _localport(localport),
          _locallip(locallip),
          _isrunning(false)
    {
    }
    void InitServer()
    {
        // 1.创建socket文件
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            LOG(FATAL, "create socket error");
            exit(SOCKET_ERROR);
        }
        LOG(DEBUG, "create socket success,sockfd :%d", _sockfd);

        // 2.bind
        struct sockaddr_in local;
        memset(&local,0,sizeof(local)); //置空
        local.sin_family = AF_INET;
        local.sin_port = htons(_localport); // 主机转网络序列
        local.sin_addr.s_addr = inet_addr(_locallip.c_str()); //1.string转成4字节 2.主机转网络网络序列
        int n = ::bind(_sockfd,(struct sockaddr*)&local,sizeof(local));
        if(n < 0)
        {
            LOG(FATAL,"bind error");
            exit(BIND_ERROR);
        }
        LOG(DEBUG,"socket bind success");
    }
    void Start()
    {
        _isrunning = true;
        while(_isrunning)
        {
            //otherthing
        }
    }
    ~UdpServer()
    {}

private:
    int _sockfd;
    uint16_t _localport;
    std::string _locallip;
    bool _isrunning;
};

可以用指令netstat查看：

收数据

虽然sockfd和文件描述符相似，但不能直接使用write和read…因为sockfd是数据报的，不是字节流的。
要用recvfrom来读：


返回值：失败返回-1；返回收到信息的大小。
发送消息：sendto函数

返回值：失败返回-1；返回发送信息的大小：

代码：

void Start()
    {
        _isrunning = true;
        char buffer[1024];
        while(_isrunning)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int n = recvfrom(_sockfd,&buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);
        }
    }

Client 客户端

• 首先客户端一定在未来知道服务器的IP地址和端口号的。
  IP地址：比如在网页登入QQ时，www.qq.com，这是域名，登入时会转化成IP地址。
  
  端口号：跟服务端是强关联的(比如：我们平常说打报警电话，很少说打报警电话110)。
• 其次客服端一定要有自己的IP与端口，来区分客户端的唯一性。
  server的端口号，必须由用户指明，而且是明确的，不能随意改变。(淘宝、百度…)
  client的端口号，一般不让用户自己设定，而是让client OS随机选择。
  原因：服务端是被多个人访问的，所以不能随意改变端口号。客户端，以手机为例，有微信、京东…不同公司的客户端，比如淘宝喜欢888的端口号，京东也喜欢888的端口号，在点击启动的时候，因为一个进程绑定888后，其余进程就用不了888了，就造成淘宝能打开，京东就打不开了。所以不能固定绑定客户端的端口号。
  综上所述：client 需要 bind 它自己的IP和端口号，但是client 不需要 自己手动填充 bind它自己的IP和端口。
  问题：client如何选择端口号，什么时候选择端口号？
  答：客户端在首次向服务器发送数据的时候，OS会自动给client bind 它自己家的IP和端口，在首次调用sendto函数时，绑定IP与端口号。
  client总的代码：

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "NoCopy.hpp"
#include "Log.hpp"

// ./udp_client server-ip server-port
// ./udp_client 127.0.0.1 8888
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << "server-ip server-port" << std::endl;
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);
    // 创建socket
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        std::cerr << "create socket error" << std::endl;
        exit(1);
    }

    struct sockaddr_in server;
    memset(&server, 0, sizeof(server)); //初始化
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr(serverip.c_str());
    server.sin_port = htons(serverport);
    while (1)
    {
        std::string line;
        std::cout << "Please Enter# ";
        getline(std::cin, line);
        int n = sendto(sockfd, line.c_str(), line.size(), 0, (struct sockaddr *)&server, sizeof(server)); // 发数据
        if (n > 0)
        {
            struct sockaddr_in temp;
            socklen_t len = sizeof(temp);
            char in_buffer[1024];
            int m = recvfrom(sockfd, in_buffer, sizeof(in_buffer)-1, 0, (struct sockaddr *)&temp, &len); //收数据
            if (m > 0)
            {
                in_buffer[m] = 0;
                std::cout << in_buffer << std::endl;
            }
            else
            {
                break;
            }
        }
        else
        {
            break;
        }
    }

    return 0;
}

注意事项

1. 若服务器和客户端在同一台机器上，通信的过程不会走到网络里，这样保证双方的软件内部不会出错，测试通过再引入跨网络通信。
   
2. 云服务器绑定IP比较特殊，服务端不能直接（也强烈不建议）bind自己的公网IP：
   
   因为云服务器的共享IP是虚拟出来的，服务器上本身ip就没有101.200.125.68这个IP。
   下面这两个才是真正的服务器IP。
   
   内网IP是可以绑定的：
   
   但绑定了内网IP，是无法从外网上收消息了。
   为了解决上面的两种情况，一般把云服务的IP地址设为0：
   
   0代表的是：可以让服务器bind任意IP。
   举个例子：比如服务器配了俩共享IP，IP1和IP2，端口号：8888，那么这个服务器可以收到IP1:8888的报文，也可以收到IP2:8888的报文：
   
   绑定的IP为0的服务器，就能收到端口号相同的任何IP报文了。

整体的代码与效果

Log.hpp 用来检查用的日志，直接调用LOG(level，内容);即可

#pragma once

#include <iostream>
#include <unistd.h>
#include <time.h>
#include <cstdarg>
#include <pthread.h>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "LockGuard.hpp"

#define SCREEN_TYPE 1
#define FILE_TYPE 2

namespace log_ns
{

    std::string glogfile = "./log.txt";
    pthread_mutex_t glock = PTHREAD_MUTEX_INITIALIZER;

    enum
    {
        DEBUG = 1,
        INFO,
        WARNING,
        ERROR,
        FATAL
    };

    std::string LevelToString(int level) // 日志等级
    {
        switch (level)
        {
        case DEBUG:
            return "DEBUG";
        case INFO:
            return "INFO";
        case WARNING:
            return "WARNING";
        case ERROR:
            return "Error";
        case FATAL:
            return "FATAL";
        default:
            return "UNKONE";
        }
    }

    std::string GetCurrTime() // 目前的时间
    {
        time_t now = time(nullptr);
        struct tm *curr_time = localtime(&now);
        char buffer[128];
        snprintf(buffer, sizeof(buffer), "%d-%02d-%02d %02d:%02d:%02d",
                 curr_time->tm_year + 1900,
                 curr_time->tm_mon + 1,
                 curr_time->tm_mday,
                 curr_time->tm_hour,
                 curr_time->tm_min,
                 curr_time->tm_sec);
        return buffer;
    }

    class Logmessage // 日志的内容
    {
    public:
        std::string _level;
        pid_t _pid;
        std::string _filename;
        int _filenumber;
        std::string _time;
        std::string _messageinfo;
    };

    class Log
    {
    public:
        Log(const std::string &logfile = glogfile) : _logfile(logfile), _type(SCREEN_TYPE)
        {
        }
        void Enable(int type)
        {
            _type = type;
        }
        void FlushLogToScreen(const Logmessage &lg)
        {
            printf("[%s][%d][%s][%d][%s][%s]\n",
                   lg._level.c_str(),
                   lg._pid,
                   lg._filename.c_str(),
                   lg._filenumber,
                   lg._time.c_str(),
                   lg._messageinfo.c_str());
        }
        void FlushLogToFile(const Logmessage &lg)
        {
            char logtxt[2048];
            snprintf(logtxt, sizeof(logtxt), "[%s][%d][%s][%d][%s][%s]\n",
                     lg._level.c_str(),
                     lg._pid,
                     lg._filename.c_str(),
                     lg._filenumber,
                     lg._time.c_str(),
                     lg._messageinfo.c_str());
            int fd = open(_logfile.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666);
            if (fd < 0)
                return perror("open file false");
            write(fd, logtxt, strlen(logtxt));
            close(fd);
        }
        void FlushLog(const Logmessage &lg) // 判断刷新到到屏幕还是文件
        {
            if (lg._level == "DEBUG")
                return;
            LockGuard lockguard(&glock);
            switch (_type)
            {
            case SCREEN_TYPE:
                FlushLogToScreen(lg);
                break;
            case FILE_TYPE:
                FlushLogToFile(lg);
                break;
            default:
                printf("_type error \n");
                break;
            }
        }
        void LogMessage(std::string filename, int filenumber, int level, const char *format, ...) // 刷新的内容
        {
            Logmessage lg;
            lg._level = LevelToString(level);
            lg._pid = getpid();
            lg._filename = filename;
            lg._filenumber = filenumber;
            lg._time = GetCurrTime();
            va_list ap;
            va_start(ap, format);
            char log_info[1024];
            vsnprintf(log_info, sizeof(log_info), format, ap);
            va_end(ap);
            lg._messageinfo = log_info;
            FlushLog(lg);
        }
        ~Log()
        {
        }

    private:
        int _type;            // 打印到屏幕还是文件中
        std::string _logfile; // 哪个文件出了问题
    };

    Log lg;

#define LOG(level, format, ...)                                        \
    do                                                                 \
    {                                                                  \
        lg.LogMessage(__FILE__, __LINE__, level, format, ##__VA_ARGS__); \
    } while (0)
#define EnableScrean()          \
    do                          \
    {                           \
        lg.Enable(SCREEN_TYPE); \
    } while (0)
#define EnableFILE()          \
    do                        \
    {                         \
        lg.Enable(FILE_TYPE); \
    } while (0)
}

NoCopy.hpp 单例模式

#pragma once

class nocopy
{
public:
    nocopy()
    {

    }
    ~nocopy()
    {}
    nocopy(const nocopy&) = delete;
    const nocopy& operator =(const nocopy& ) = delete;
};

UdpServer.hpp:

#pragma once

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "NoCopy.hpp"
#include "Log.hpp"

using namespace log_ns;

enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
};

int gsockfd = -1;
uint16_t glocalport = 8888;

// UdpServer user(8899);
class UdpServer : public nocopy
{
public:
    UdpServer(uint16_t localport = glocalport)
        : _sockfd(gsockfd),
          _localport(localport),
          _isrunning(false)
    {
    }
    void InitServer()
    {
        // 1.创建socket文件
        _sockfd = ::socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            LOG(FATAL, "create socket error");
            exit(SOCKET_ERROR);
        }
        // LOG(DEBUG, "create socket success,sockfd :%d", _sockfd);

        // 2.bind
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local)); // 置空
        local.sin_family = AF_INET;
        local.sin_port = htons(_localport); // 1.网络序列
        local.sin_addr.s_addr = INADDR_ANY;
        int n = ::bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n < 0)
        {
            LOG(FATAL, "bind error");
            exit(BIND_ERROR);
        }
        LOG(INFO, "socket bind success");
    }
    void Start()
    {
        _isrunning = true;
        char buffer[1024];
        while (_isrunning)
        {
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            int n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
            if (n > 0) // 返回收到的信息
            {
                std::string ip = inet_ntoa(peer.sin_addr); // 4字节-》string
                uint16_t port = htons(peer.sin_port);      // 网络转主机
                buffer[n] = 0;
                std::cout << "[" << ip << ":" << port << "]#" << buffer << std::endl;
                // LOG(DEBUG, "recvfrom return is :%d", n);
                std::string echo_server = "[udp_server echo] #";
                echo_server += buffer;
                LOG(DEBUG, "echo_server :%s", echo_server.c_str());
                sendto(_sockfd, echo_server.c_str(), sizeof(echo_server), 0, (struct sockaddr *)&peer, len);
            }
        }
    }
    ~UdpServer()
    {
        if (_sockfd > gsockfd)
            ::close(_sockfd);
    }

private:
    int _sockfd;
    uint16_t _localport;
    bool _isrunning;
};

UdpServerMain.cc

#include "UdpServer.hpp"
#include <memory>

// ./udp_server local-port
// ./udp_server 8888
int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << "server-port" << std::endl;
    }
    EnableScrean();
    uint16_t port = std::stoi(argv[1]);
    std::unique_ptr<UdpServer> usvr = std::make_unique<UdpServer>(port);
    usvr->InitServer();
    usvr->Start();
    return 0;
}

UdpClientMain.cc

#include <iostream>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "NoCopy.hpp"
#include "Log.hpp"

using namespace log_ns;

// ./udp_client server-ip server-port
// ./udp_client 127.0.0.1 8888
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[0] << "server-ip server-port" << std::endl;
        exit(0);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);
    // 创建socket
    int sockfd = ::socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        std::cerr << "create socket error" << std::endl;
        exit(1);
    }

    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_addr.s_addr = inet_addr(serverip.c_str());
    server.sin_port = htons(serverport);
    while (1)
    {
        std::string line;
        std::cout << "Please Enter# ";
        getline(std::cin, line);
        LOG(DEBUG,"%s",line.c_str());
        int n = sendto(sockfd, line.c_str(), line.size(), 0, (struct sockaddr *)&server, sizeof(server)); // 发数据
        // LOG(DEBUG,"sendto return is %d",n);
        if (n > 0)
        {
            struct sockaddr_in temp;
            socklen_t len = sizeof(temp);
            char in_buffer[1024];
            int m = recvfrom(sockfd, in_buffer, sizeof(in_buffer)-1, 0, (struct sockaddr *)&temp, &len);
            if (m > 0)
            {
                in_buffer[m] = 0;
                std::cout << in_buffer << std::endl;
            }
            else
            {
                break;
            }
        }
        else
        {
            break;
        }
    }

    return 0;
}

效果

七.网络命令

Ping 命令

检查网络连通性。
问题：在Windows电脑上有一个云服务器，如何保证电脑与云服务器连通呢？(比如windows没有连网，没法连)
答：Ping命令就算检查两台主机是否能联通。
测试是否能连通网络，连通百度：

未来写了一种网络服务，比如写了一个TCP的服务，请求时怎样都拿不到结果，可以先拿Ping命令测试网络是否连通，若连通，说明网络服务本身就有问题。

• Ping命令一旦启动，就不会停止的，若只想Ping 1次，就有了选项-c（cont的意思）

netstat 命令

netstat时一个用来查看网络状态的重要工具。
netstat通常用来查看网络服务，UDP/TCP启动起来就是一个进程，我们能用ps能查到该进程偏于进程方面的信息，若想查看网络方面的属性的字段，就用netstat：

-u	查看udp服务
-t	查看TCP服务
-a	查看所有的服务
-p	查看与哪个进程关联
-n	把能显示成数字的，显示成数字
-l	把处于LISTEN状态的TCP服务显示出来

watch命令可以每隔x秒让该命令执行一次：

watch -n 1 netstat -nuap #每隔一秒执行一次

pidof 命令

拿到进程的PID。
服务器有时候处于后端，简单的ctrl+c是杀不死的，所以需要kill命令。
经常会这么用：

pidof [进程名] | xargs kill -9

xargs的作用：把管道中的数据，转换成后续的数据。
kill是用标准输入文件描述符0，来把数据读到kill中。