标签：缓存 socket ip 编程网络域名服务器接字

CS架构与BS架构

CS架构

是Client/Service这两个单词的首字母，指的是客户端服务器架构的意思，很多常见的软件都是这种架构。

解释：

对于CS架构，最为常见的例子就是网络游戏，比如LOL、WOW如果不联网无法使用，你在软件内的所有操作通过互联网能够传递到其他的玩家身上。

优点：

第一，性能较高：可以将一部分的计算机工作放在客户端上，这样服务器只需要处理数据即可。

第二，界面炫酷：客户端可以使用更多系统提供的效果，做出更为炫目的效果。

缺点：

第一，更新软件：如果推出了新版本，不更新客户端无法登录使用（一部分）。

第二，不同设备访问：如果使用其他的电脑，没有安装客户端的话就无法登录软件。

BS架构

是Browser/Server这两个单词的首字母，指的是浏览器服务器，是WEB兴起后的一种架构。

解释：

现在所有的网站都是BS架构，较为常见的例子有知乎、百度、网易云音乐Web等等，所有只需要通过浏览器即可使用。

优点：

第一，更新简洁：如果需要更新内容了，对开发人员而言需要更改服务器的内容，但是对用户而言只需要刷新浏览器即可。
第二，多设备同步：所有数据都在网上，只要能够使用浏览器即可登录使用。

缺点：

第一，性能较低：相比于客户端应用性能较低，但是随着硬件性能的提升，这个差距在缩小。
第二，浏览器兼容：处理低版本的浏览器显示问题一直是开发人员头疼的问题之一，移动设备兼容性较好，``ie6``已经越来越少人用了。

OSI七层协议

OSI

每层都运行特定的协议，越往上越靠近用户，越往下越靠近硬件

互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层

每层运行常见物理设备

OSI七层协议数据传输的封包与解包过程

协议：

规定数据的组织形式

格式：头部+数据部分

物理层：

物理层功能：主要是基于电器特性发送高低电压(电信号)，高电压对应数字1，低电压对应数字0

一组物理层数据分为：位

数据链路层

数据链路层由来：单纯的电信号0和1没有任何意义，必须规定电信号多少位一组，每组什么意思

数据链路层的功能：定义了电信号的分组方式

以太网协议：

早期的时候各个公司都有自己的分组方式，后来形成了统一的标准，即以太网协议ethernet

ethernet规定

一组电信号构成一个数据包，叫做‘帧’
每一数据帧分成：报头head和数据data两部分

head	data

head包含：(固定18个字节) --> 源地址和目标地址：mac地址

发送者／源地址，6个字节
接收者／目标地址，6个字节
数据类型，6个字节

data包含：(最短46字节，最长1500字节) -->包含网络层整体的内容

数据包的具体内容

head长度＋data长度＝最短64字节，最长1518字节，超过最大限制就分片发送

mac地址：

head中包含的源和目标地址由来：

ethernet规定接入internet的设备都必须具备网卡，发送端和接收端的地址便是指网卡的地址，即mac地址

mac地址：

每块网卡出厂时都被烧制上一个世界唯一的mac地址，长度为48位2进制，通常由12位16进制数表示（前六位是厂商编号，后六位是流水线号）

广播

有了mac地址，同一网络内的两台主机就可以通信了（一台主机通过arp协议获取另外一台主机的mac地址）

ethernet采用最原始的方式，广播的方式进行通信，即计算机通信基本靠吼

网络层

网络层由来：

有了ethernet、mac地址、广播的发送方式，世界上的计算机就可以彼此通信了，问题是世界范围的互联网是由

一个个彼此隔离的小的局域网组成的，那么如果所有的通信都采用以太网的广播方式，那么一台机器发送的包全世界都会收到，

这就不仅仅是效率低的问题了，这会是一种灾难

采用路由的方式（向不同广播域／子网分发数据包），``mac``地址是无法区分的，它只跟厂商有关

网络层功能：

引入一套新的地址用来区分不同的广播域／子网，这套地址即网络地址

IP协议：

规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示
范围0.0.0.0-255.255.255.255
一个ip地址通常写成四段十进制数，例：172.16.10.1

ip地址分成两部分

网络部分：标识子网
主机部分：标识主机

注意：单纯的``ip``地址段只是标识了``ip``地址的种类，从网络部分或主机部分都无法辨识一个``ip``所处的子网

例：172.16.10.1与172.16.10.2并不能确定二者处于同一子网

子网掩码

所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字，它的网络部分全部为1，主机部分全部为0。比如，IP地址172.16.10.1，如果已知网络部分是前24位，主机部分是后8位，那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。

知道”子网掩码”，我们就能判断，任意两个IP地址是否处在同一个子网络。方法是将两个IP地址与子网掩码分别进行AND运算（两个数位都为1，运算结果为1，否则为0），然后比较结果是否相同，如果是的话，就表明它们在同一个子网络中，否则就不是。

IP协议的作用主要有两

一个是为每一台计算机分配IP地址，

另一个是确定哪些地址在同一个子网络。

ip数据包

ip数据包也分为head和data部分，无须为ip包定义单独的栏位，直接放入以太网包的data部分

head：长度为20到60字节 --> 源地址和目标地址：此时是ip地址

data：最长为65,515字节。 --> 传输层整体的数据

而以太网数据包的”数据”部分，最长只有1500字节。因此，如果IP数据包超过了1500字节，它就需要分割成几个以太网数据包，分开发送了。

以太网头	ip 头	ip数据

总结：

ip地址+mac地址可以表示全世界范围内独一无二的一台计算机

ARP协议

arp协议由来：

计算机通信基本靠吼，即广播的方式，所有上层的包到最后都要封装上以太网头，然后通过以太网协议发送，在谈及以太网协议时候，我门了解到

通信是基于mac的广播方式实现，计算机在发包时，获取自身的mac是容易的，如何获取目标主机的mac，就需要通过arp协议

arp协议功能：

广播的方式发送数据包，获取目标主机的mac地址

协议工作方式：

每台主机ip都是已知的

例如：主机172.16.10.10/24访问172.16.10.11/24

一：首先通过ip地址和子网掩码区分出自己所处的子网

场景	数据包地址
同一子网	目标主机mac，目标主机ip
不同子网	网关mac，目标主机ip

二：分析172.16.10.10/24与172.16.10.11/24处于同一网络(如果不是同一网络，那么下表中目标ip为172.16.10.1,通过arp获取的是网关的mac)

	源mac	目标mac	源ip	目标ip	数据部分
发送端主机	发送端mac	FF:FF:FF:FF:FF:FF	172.16.10.10/24	172.16.10.11/24	数据

三：这个包会以广播的方式在发送端所处的自网内传输，所有主机接收后拆开包，发现目标ip为自己的，就响应，返回自己的mac

传输层

传输层的由来：

网络层的``ip``帮我们区分子网，以太网层的``mac``帮我们找到主机，然后大家使用的都是应用程序，你的电脑上可能同时开启``qq``，暴风影音，等多个应用程序，
那么我们通过``ip``和``mac``找到了一台特定的主机，如何标识这台主机上的应用程序，答案就是端口，端口即应用程序与网卡关联的编号。

传输层功能：

建立端口到端口的通信

补充：

Ip+prot -->标识的是全世界独一无二的一个基于网络通讯的应用程序

端口范围``0-65535``，``0-1023``为系统占用端口
基于tcp协议通讯之前：``必须建立一个双向通路的链接，通过三次握手

tcp协议：

可靠传输，``TCP``数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常``TCP``数据包的长度不会超过``IP``数据包的长度，以确保单个``TCP``数据包不必再分割。

`以太网头`	ip ``头 ``	tcp``头 ``	数据 ``

udp协议：

不可靠传输，``”``报头``”``部分一共只有``8``个字节，总长度不超过``65,535``字节，正好放进一个``IP``数据包。

`以太网头`	ip``头 ``	`` udp``头 ``	数据 ``

tcp报文

tcp三次握手和四次挥手

三次握手建立链接：建立连接是为了传数据准备的，三次握手就可以
四次握手断链接：断开链接是，由于链接内部有数据传输，所以分为四次断开
tcp``是可靠传输的：发送数据必须等到对方确认后才算完成，才会将做自己内存的数据清理掉，否则重试

ps：

当服务器大量处于TIME_WAIT状态是意味着服务器可能处于高并发状态

应用层

应用层由来：

用户使用的都是应用程序，均工作于应用层，互联网是开发的，大家都可以开发自己的应用程序，数据多种多样，必须规定好数据的组织形式``

应用层功能：

规定应用程序的数据格式。
例：``TCP``协议可以为各种各样的程序传递数据，比如``Email``、``WWW``、``FTP``等等。那么，必须有不同协议规定电子邮件、网页、``FTP``数据的格式，这些应用程序协议就构成了``”``应用层``”``。

自定义协议：==>头+数据

自定义协议要注意的问题：

1.两大组成部分=头部+数据部分

头部：放对数据的描述信息

比如：数据要发给谁，数据类型，数据的长度

数据部分：要发的数据

总结：

DNS

nds查询

#一：递归主机向本地域名服务器的查询一般都是采用递归查询。所谓递归查询就是：如果主机所询问的本地域名服务器不知道被查询的域名的IP地址，

那么本地域名服务器就以DNS客户的身份，向其它根域名服务器继续发出查询请求报文(即替主机继续查询)，而不是让主机自己进行下一步查询。

因此，递归查询返回的查询结果或者是所要查询的IP地址，或者是报错，表示无法查询到所需的IP地址。

# 二：迭代本地域名服务器向根域名服务器的查询的迭代查询。迭代查询的特点：当根域名服务器收到本地域名服务器发出的迭代查询请求报文时，要么给出所要查询的IP地址，

要么告诉本地服务器：“你下一步应当向哪一个域名服务器进行查询”。然后让本地服务器进行后续的查询。根域名服务器通常是把自己知道的顶级域名服务器的IP地址告诉本地域名服务器，

让本地域名服务器再向顶级域名服务器查询。顶级域名服务器在收到本地域名服务器的查询请求后，要么给出所要查询的IP地址，要么告诉本地服务器下一步应当向哪一个权限域名服务器进行查询。

最后，知道了所要解析的IP地址或报错，然后把这个结果返回给发起查询的主机。

#下面举一个例子演示整个查询过程：

假定域名为m.xyz.com的主机想知道另一个主机y.abc.com的IP地址。例如，主机m.xyz.com打算发送邮件给y.abc.com。这时就必须知道主机y.abc.com的IP地址。下面是图2的几个查询步骤：

1、主机m.abc.com先向本地服务器dns.xyz.com进行递归查询。

2、本地服务器采用迭代查询。它先向一个根域名服务器查询。

3、根域名服务器告诉本地服务器，下一次应查询的顶级域名服务器dns.com的IP地址。

4、本地域名服务器向顶级域名服务器dns.com进行查询。

5、顶级域名服务器dns.com告诉本地域名服务器，下一步应查询的权限服务器dns.abc.com的IP地址。

6、本地域名服务器向权限域名服务器dns.abc.com进行查询。

7、权限域名服务器dns.abc.com告诉本地域名服务器，所查询的主机的IP地址。

8、本地域名服务器最后把查询结果告诉m.xyz.com。

# 整个查询过程共用到了8个UDP报文。

为了提高DNS查询效率，并减轻服务器的负荷和减少因特网上的DNS查询报文数量，在域名服务器中广泛使用了高速缓存，用来存放最近查询过的域名以及从何处获得域名映射信息的记录。

例如，在上面的查询过程中，如果在m.xyz.com的主机上不久前已经有用户查询过y.abc.com的IP地址，那么本地域名服务器就不必向根域名服务器重新查询y.abc.com的IP地址，而是直接把告诉缓存中存放的上次查询结果(即y.abc.com的IP地址)告诉用户。

由于名字到地址的绑定并不经常改变，为保持告诉缓存中的内容正确，域名服务器应为每项内容设置计时器并处理超过合理时间的项(例如每个项目两天)。当域名服务器已从缓存中删去某项信息后又被请求查询该项信息，就必须重新到授权管理该项的域名服务器绑定信息。当权限服务器回答一个查询请求时，在响应中都指明绑定有效存在的时间值。增加此时间值可减少网络开销，而减少此时间值可提高域名解析的正确性。

不仅在本地域名服务器中需要高速缓存，在主机中也需要。许多主机在启动时从本地服务器下载名字和地址的全部数据库，维护存放自己最近使用的域名的高速缓存，并且只在从缓存中找不到名字时才使用域名服务器。维护本地域名服务器数据库的主机应当定期地检查域名服务器以获取新的映射信息，而且主机必须从缓存中删除无效的项。由于域名改动并不频繁，大多数网点不需花精力就能维护数据库的一致性。

如上图所示，我们将详细阐述DNS解析流程。

1、首先客户端位置是一台电脑或手机，在打开浏览器以后，比如输入http://www.zdns.cn的域名，它首先是由浏览器发起一个DNS解析请求，

如果本地缓存服务器中找不到结果，则首先会向根服务器查询，根服务器里面记录的都是各个顶级域所在的服务器的位置，当向根请求http://www.zdns.cn的时候，

根服务器就会返回.cn服务器的位置信息。

2、递归服务器拿到.cn的权威服务器地址以后，就会寻问cn的权威服务器，知不知道http://www.zdns.cn的位置。这个时候cn权威服务器查找并返回http://zdns.cn服务器的地址。

3、继续向http://zdns.cn的权威服务器去查询这个地址，由http://zdns.cn的服务器给出了地址：202.173.11.10

4、最终才能进行http的链接，顺利访问网站。

5、这里补充说明，一旦递归服务器拿到解析记录以后，就会在本地进行缓存，如果下次客户端再请求本地的递归域名服务器相同域名的时候，就不会再这样一层一层查了，

因为本地服务器里面已经有缓存了，这个时候就直接把http://www.zdns.cn的A记录返回给客户端就可以了。

DNS缓存

DNS缓存指DNS返回了正确的IP之后，系统就会将这个结果临时储存起来。并且它会为缓存设定一个失效时间 (例如N小时)，在这N小时之内，当你再次访问这个网站时，系统就会直接从你电脑本地的DNS缓存中把结果交还给你，而不必再去询问DNS服务器，变相“加速”了网址的解析。

当然，在超过N小时之后，系统会自动再次去询问DNS服务器获得新的结果。所以，当你修改了 DNS 服务器，并且不希望电脑继续使用之前的DNS缓存时，就需要手动去清除本地的缓存了

DNS缓存分类

1）浏览器DNS缓存（内存中): 浏览器会按照一定频率缓存DNS记录

2）本地操作系统DNS缓存(内存中): 如果浏览器缓存中找不到需要的DNS记录，那就去操作系统找。

3）本地HOSTS文件（硬盘中）: Windows系统中位于C:\Windows\System32\drivers\etc

4）路由器指定的DNS(远程): 路由器自动获取DNS地址，也可以手动修改-登录后台设置DNS服务器地址

ps：路由器DNS被篡改会造成域名劫持，你访问的网址都会被定位到同一个位置，但是IP直接可以访问

5）ISP的DNS服务器（远程）: ISP(Internet Service Provider互联网服务提供商、联通电信移动)，ISP有专门的DNS服务器应对DNS查询请求

6）根服务器（远程，跨国）: ISP的DNS服务器还找不到的话，它就会向根服务器发出查询请求

调用系统缓存需要跨进程，消耗大，因此为了解析速度的方便，就有了一系列缓存来加快IP查找速度。

浏览器DNS查找顺序

浏览器DNS缓存->本地系统DNS缓存->本地计算机HOSTS文件->ISP DNS缓存->递归or迭代搜索

期间如果查询到了，也就直接访问ip地址了，这个就像三级缓存原理一样，例如，能够在hosts文件中找到就不会再去查其他的

清除DNS缓存

打开cmd执行命令：ipconfig /all

全国通用DNS地址（国内用户推荐使用，速度较快！）

首先DNS服务器地址添：114.114.114.114 (位于北京人民英雄纪念碑）

备用DNS服务器地址添：114.114.115.115

全球通用DNS地址（此DNS地址为谷歌服务器的）

首选DNS服务器地址添：8.8.8.8

备用DNS服务器地址添：8.8.4.4

查看本地dns缓存命令：ipconfig /displaydns

清除本地dns缓存命令：ipconfig /flushdns

清除浏览器缓存：

我们在开发的时候，有时候会给某个域名绑hosts，用于本地开发测试，但是绑了之后，用谷歌浏览器访问会发现并没有生效，按F12会发现访问的还是线上的ip，

说明浏览器是有该域名的dns缓存的，那么如何清除浏览器的dns缓存呢？

# 1、针对谷歌浏览器

谷歌浏览器清除方法如下：打开浏览器，访问如下地址

chrome://net-internals/#dns

点击 clear host cache，就清楚了浏览器的dns缓存，再访问绑hosts的域名，就会发现ip变啦

# 2、针对火狐浏览器

如果是firefox火狐浏览器的话，可以按照以下方式：

在地址栏中 about:config 并回车，可能会出现一个警告信息，直接点击按钮进入，会出现firefox的所有配置信息，通过搜索dns 进行过滤，

可以看到一项名为 network.dnsCacheExpirationGracePeriod 项，它对应的值就是DNS缓存的时间，双击此项，会出现修改的提示框，填入 0 （不缓存DNS）即可。

其他了解

13台根dns：

A.root-servers.net198.41.0.4美国

B.root-servers.net192.228.79.201美国（另支持IPv6）

C.root-servers.net192.33.4.12法国

D.root-servers.net128.8.10.90美国

E.root-servers.net192.203.230.10美国

F.root-servers.net192.5.5.241美国（另支持IPv6）

G.root-servers.net192.112.36.4美国

H.root-servers.net128.63.2.53美国（另支持IPv6）

I.root-servers.net192.36.148.17瑞典

J.root-servers.net192.58.128.30美国

K.root-servers.net193.0.14.129英国（另支持IPv6）

L.root-servers.net198.32.64.12美国

M.root-servers.net202.12.27.33日本（另支持IPv6）

域名定义：http://jingyan.baidu.com/article/1974b289a649daf4b1f774cb.html

顶级域名：以.com,.net,.org,.cn等等属于国际顶级域名，根据目前的国际互联网域名体系，国际顶级域名分为两类：类别顶级域名(gTLD)和地理顶级域名(ccTLD)两种。类别顶级域名是以"COM"、"NET"、"ORG"、"BIZ"、"INFO"等结尾的域名，均由国外公司负责管理。地理顶级域名是以国家或地区代码为结尾的域名，如"CN"代表中国，"UK"代表英国。地理顶级域名一般由各个国家或地区负责管理。

二级域名：二级域名是以顶级域名为基础的地理域名，比喻中国的二级域有，.com.cn,.net.cn,.org.cn,.gd.cn等.子域名是其父域名的子域名，比喻父域名是abc.com,子域名就是www.abc.com或者*.abc.com.

一般来说，二级域名是域名的一条记录，比如alidiedie.com是一个域名，www.alidiedie.com是其中比较常用的记录，一般默认是用这个，但是类似*.alidiedie.com的域名全部称作是alidiedie.com的二级

socket套接字

socket是什么

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

也有人将socket说成ip+port，ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序，ip地址是配置到网卡上的，而port是应用程序开启的，ip与port的绑定就标识了互联网中独一无二的一个应用程序

而程序的pid是同一台机器上不同进程或者线程的标识

套接字分类

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

套接字工作原理

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

socket()模块函数用法

import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family ``可以是`` AF_UNIX ``或`` AF_INET``。``socket_type ``可以是`` SOCK_STREAM ``或`` SOCK_DGRAM``。``protocol ``一般不填``,``默认值为`` 0``。
获取``tcp/ip``套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
获取``udp/ip``套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
由于`` socket ``模块中有太多的属性。我们在这里破例使用了``'from module import *'``语句。使用`` 'from socket import *',``我们就把`` socket ``模块里的所有属性都带到我们的命名空间里了``,``这样能 大幅减短我们的代码。
例如``tcpSock = socket(AF_INET, SOCK_STREAM)

服务端套接字函数

s.bind() # 绑定(主机,端口号)到套接字

s.listen() # 开始TCP监听

s.accept() # 被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数

  s.connect()   # ``主动初始化``TCP``服务器连接
  s.connect_ex() # connect()``函数的扩展版本``,``出错时返回出错码``,``而不是抛出异常

公共用途的套接字函数

  s.recv()       # ``接收``TCP``数据
  s.send()       # ``发送``TCP``数据``(send``在待发送数据量大于己端缓存区剩余空间时``,``数据丢失``,``不会发完``)
  s.sendall()     # ``发送完整的``TCP``数据``(``本质就是循环调用``send,
sendall``在待发送数据量大于己端缓存区剩余空间时``,
数据不丢失``,``循环调用``send``直到发完``)
  s.recvfrom()     # ``接收``UDP``数据
  s.sendto()      # ``发送``UDP``数据
  s.getpeername()   # ``连接到当前套接字的远端的地址
  s.getsockname()   # ``当前套接字的地址
  s.getsockopt()    # ``返回指定套接字的参数
  s.setsockopt()    # ``设置指定套接字的参数
  s.close()      # ``关闭套接字

面向锁的套接字方法

  s.setblocking()   # ``设置套接字的阻塞与非阻塞模式
  s.settimeout()    # ``设置阻塞套接字操作的超时时间
  s.gettimeout()    # ``得到阻塞套接字操作的超时时间

面向文件的套接字的函数

  s.fileno()      # ``套接字的文件描述符
  s.makefile()     # ``创建一个与该套接字相关的文件

基于TCP的套接字

tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

tcp服务端

 
ss = socket() ``创建服务器套接字
ss.bind()    ``把地址绑定到套接字
ss.listen()    ``监听链接
inf_loop:    ``服务器无限循环
  cs = ss.accept() ``接受客户端链接
  comm_loop:     ``通讯循环
    cs.recv()/cs.send() ``对话``(``接收与发送``)
  cs.close()   ``关闭客户端套接字
ss.close()     ``关闭服务器套接字``(``可选``)

tcp客户端

 
cs = socket()   ``创建客户套接字
cs.connect()   ``尝试连接服务器
comm_loop:     ``通讯循环
  cs.send()/cs.recv()   ``对话``(``发送``/``接收``)

案例

  ``加上链接循环与通信循环
服务端
 
_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',8081)``电话卡
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) ``买手机
s.bind(ip_port) ``手机插卡
s.listen(5)   ``手机待机
 
while True:             ``新增接收链接循环``,``可以不停的接电话
  conn,addr=s.accept()       ``手机接电话
   print(conn)
   print(addr)
  print('``接到来自``%s``的电话``' %addr[0])
  while True:             ``新增通信循环``,``可以不断的通信``,``收发消息
    msg=conn.recv(BUFSIZE)       ``听消息``,``听话
     if len(msg) == 0:break     ``如果不加``,``那么正在链接的客户端突然断开``,recv``便不再阻塞``,``死循环发生
    print(msg,type(msg))
    conn.send(msg.upper())      ``发消息``,``说话
  conn.close()           ``挂电话
s.close()            ``手机关机
 
客户端
 
_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
import socket
ip_port=('127.0.0.1',8081)
BUFSIZE=1024
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect_ex(ip_port)      ``拨电话
while True:               ``新增通信循环``,``客户端可以不断发收消息
  msg=input('>>: ').strip()
  if len(msg) == 0:continue
  s.send(msg.encode('utf-8'))     ``发消息``,``说话``(``只能发送字节类型``)
  feedback=s.recv(BUFSIZE)              ``收消息``,``听话
  print(feedback.decode('utf-8'))
s.close()                    ``挂电话

问题：

有的同学在重启服务端时可能会遇到

 
这个是由于你的服务端仍然存在四次挥手的``time_wait``状态在占用地址（如果不懂，请深入研究``1.tcp``三次握手，四次挥手``2.syn``洪水攻击``3.``服务器高并发情况下会有大量的``time_wait``状态的优化方法）

解决方法：

一#加入一条socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)#``就是它，在``bind``前加
phone.bind(('127.0.0.1',8080))

二.发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，

vi/etc/sysctl.conf
 
编辑文件，加入以下内容：
net.ipv4.tcp_syncookies=1
net.ipv4.tcp_tw_reuse=1
net.ipv4.tcp_tw_recycle=1
net.ipv4.tcp_fin_timeout=30
 
然后执行``/sbin/sysctl-p``让参数生效。
 
net.ipv4.tcp_syncookies=1``表示开启``SYNCookies``。当出现``SYN``等待队列溢出时，启用``cookies``来处理，可防范少量``SYN``攻击，默认为``0``，表示关闭；
 
net.ipv4.tcp_tw_reuse=1``表示开启重用。允许将``TIME-WAITsockets``重新用于新的``TCP``连接，默认为``0``，表示关闭；
 
net.ipv4.tcp_tw_recycle=1``表示开启``TCP``连接中``TIME-WAITsockets``的快速回收，默认为``0``，表示关闭。
 
net.ipv4.tcp_fin_timeout``修改系統默认的``TIMEOUT``时间

基于UDP的套接字

udp是无链接的，先启动哪一端都不会报错

udp``服务端
1 ss = socket()  #``创建一个服务器的套接字
2 ss.bind()    #``绑定服务器套接字
3 inf_loop:    #``服务器无限循环
4   cs = ss.recvfrom()/ss.sendto() # ``对话``(``接收与发送``)
5 ss.close()             # ``关闭服务器套接字
udp``客户端
cs = socket()  # ``创建客户套接字
comm_loop:    # ``通讯循环
  cs.sendto()/cs.recvfrom()  # ``对话``(``发送``/``接收``)
cs.close()            # ``关闭客户套接字

粘包

只有TCP有粘包现象，UDP永远不会粘包

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

所谓粘包问题

主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）

是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。

tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，实验略

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

UDP（user datagram protocol，用户数据报协议）

是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。即面向消息的通信是有消息保护边界的。

两种情况下会发生粘包。

发送端需要等缓冲区满才发送出去，造成粘包（发送数据时间间隔很短，数据了很小，会合到一起，产生粘包）
接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

补充问题一：为何tcp是可靠传输，udp是不可靠传输

tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的

而udp发送数据，对端是不会返回确认信息的，因此不可靠

补充问题二：send(字节流)和recv(1024)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数据

send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失，用sendall就会循环调用send，数据不会丢失

解决粘包问题

理论：

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据

自定义协议：

 
import json,struct
#``假设通过客户端上传``1T:1073741824000``的文件``a.txt
#``为避免粘包``,``必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T``数据``,``文件路径和``md5``值
#``为了该报头能传送``,``需要序列化并且转为``bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #``序列化并转成``bytes,``用于传输
#``为了让客户端知道报头的长度``,``用``struck``将报头长度这个数字转成固定长度``:4``个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #``这``4``个字节里只包含了一个数字``,``该数字是报头的长度
#``客户端开始发送
conn.send(head_len_bytes) #``先发报头的长度``,4``个``bytes
conn.send(head_bytes) #``再发报头的字节格式
conn.sendall(``文件内容``) #``然后发真实内容的字节格式
#``服务端开始接收
head_len_bytes=s.recv(4) #``先收报头``4``个``bytes,``得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #``提取报头的长度
head_bytes=s.recv(x) #``按照报头长度``x,``收取报头的``bytes``格式
header=json.loads(json.dumps(header)) #``提取报头
#``最后根据报头的内容提取真实的数据``,``比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)

Socketserver模块

基于tcp的套接字，关键就是两个循环，

一个链接循环，一个通信循环

socketserver模块中分两大类：

server类（解决链接问题）

request类（解决通信问题）

server类：

request类：

继承关系:

以下述代码为例，分析socketserver源码：

ftpserver=socketserver.ThreadingTCPServer(('17.0.0.1',8080),FtpServer)
ftpserver.serve_forever()

查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer

实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)

上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....

源码分析总结：

基于tcp的socketserver我们自己定义的类中的

self.server即套接字对象
self.request即一个链接
self.client_address即客户端地址

基于udp的socketserver我们自己定义的类中的

self.request是一个元组

（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），

如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)

self.client_address即客户端地址

http协议

超文本传输协议：用来规定浏览器和服务端的数据格式

四大特性

1.基于请求响应

2.基于tcp/IP作用于应用层之上的协议

3.无状态，不保存用户的信息

由于http协议是无状态的，所以后来就出现了一些用来保存用户状态的技术：cookie，session，token。。。

4.无/短链接

请求一次我响应一次，之后我们就没有联系了

长链接：双方建立链接之后默认不断开， websocket

数据格式

请求数据格式

请求首行：标识http协议版本，请求方式如：get请求（要数据），post请求（提交数据）。。

请求头：一大堆key：value键值对

/r/n：不能省略

请求头: 部分存在，存放的是提交到服务器的数据

响应数据格式

响应首行：标识http协议版本和对应的响应状态码

响应头：一大堆key：value键值对

/r/n：不能省略

响应头: 返回的数据

响应状态码：

一串数字可以用来标识复杂的状态和错误

1xx：服务端已经成功接收到了数据正在处理，你可以继续处理

2xx：服务端成功响应了你想要的数据

3xx：重定向

4xx：请求错误

404：请求资源不存在

403：当前请求不符合资源的访问条件

5xx：服务器问题

标签：缓存,socket,ip,编程,网络,域名,服务器,接字
From： https://www.cnblogs.com/xiaofubase/p/16899112.html

网络编程

CS架构与BS架构

CS架构

优点：

缺点：

BS架构

解释：

优点：

缺点：

OSI****七层协议

OSI

互联网协议按照功能不同分为osi七层或tcp/ip五层或tcp/ip四层

每层运行常见物理设备

OSI七层协议数据传输的封包与解包过程

协议：

物理层：

数据链路层

以太网协议：

mac地址：

head中包含的源和目标地址由来：

mac地址：

广播

网络层

网络层由来：

网络层功能：

IP协议：

ip地址分成两部分

子网掩码

IP协议的作用主要有两

ip数据包

总结：

ARP协议

arp协议由来：

arp协议功能：

协议工作方式：

传输层

传输层的由来：

传输层功能：

补充：

tcp协议：

udp协议：

tcp报文

tcp三次握手和四次挥手

ps：

应用层

应用层由来：

应用层功能：

自定义协议：==>头+数据

自定义协议要注意的问题：

总结：

DNS

#下面举一个例子演示整个查询过程：

如上图所示，我们将详细阐述DNS解析流程。

DNS缓存

DNS缓存分类

浏览器DNS查找顺序

清除DNS缓存

清除浏览器缓存：

# 1、针对谷歌浏览器

# 2、针对火狐浏览器

其他了解

socket套接字

socket是什么

套接字分类

基于文件类型的套接字家族

基于网络类型的套接字家族

套接字工作原理

socket()模块函数用法

服务端套接字函数

客户端套接字函数

公共用途的套接字函数

面向锁的套接字方法

面向文件的套接字的函数

基于TCP的套接字

tcp服务端

tcp客户端

案例

问题：

解决方法：

一#加入一条socket配置，重用ip和端口

OSI七层协议