文章目录
版权声明
作者: martin
网络编程
TCP/IP 四层协议
OSI七层协议模型 (open system interconnection)
应用层————为应用数据提供服务
表示层————数据格式转化，数据加密
会话层————建立、维护和管理会话
传输层————建立、维护和管理端到端的链接，控制数据传输的方式
网络层————数据传输线路选择，IP地址及路由选择
数据链路层———物理通路的发送和数据包的划分，附加Mac地址到数据包
物理层———01比特流的转换
数据传输由顶向下，下层为上层提供服务
TCP/IP四层协议模型
应用层———负责处理特定的应用程序细节, 如ftp,http ,smtp,ssh 等
运输层———主要为两台主机上的应用提供端到端的通信, 如TCP，UDP。
网络层（互联网层）———处理分组在网络中的活动，比如分组的选路。
链路层（数据链路层/网络接口层）———包括操作系统中的设备驱动程序、
计算机中对应的网络接口卡,01比特流的转换
协议封装
下层协议通过封装为上层协议提供服务。
应用程序数据在发送到物理网络上之前，将沿着协议栈从上往下依次传递。
每层协议都将在上层数据的基础上加上自己的头部信息（有时也包括尾部信息），
以实现该层的功能。
TCP 协议头部
`源端口号和目的端口号: `再加上Ip首部的源IP地址和目的IP地址可以
唯一确定一个TCP连接
`数据序号：`表示在这个报文段中的第一个数据字节序号
`确认序号：`仅当ACK标志为1时有效。确认号表示期望收到的下一个字节的
序号（这个下面再详细分析）
`偏移：`就是头部长度，有4位，跟IP头部一样，以4字节为单位。
最大是60个字节
`保留位：`6位，必须为0
`6个标志位：`
URG-紧急指针有效
ACK-确认序号有效
PSH-接收方应尽快将这个报文交给应用层
RST-连接重置
SYN-同步序号用来发起一个连接
FIN-终止一个连接
`窗口字段：`16位，代表的是窗口的字节容量，
也就是TCP的标准窗口最大为2^16 - 1 = 65535个字节
`校验和：`源机器基于数据内容计算一个数值，
收信息机要与源机器数值 结果完全一样，从而证明数据的有效性。
检验和覆盖了整个的TCP报文段：这是一个强制性的字段，
一定是由发送端计算和存储，并由接收端进行验证的。
`紧急指针：`是一个正偏移量，与序号字段中的值相加表示紧急数据最后一个字节
的序号。TCP的紧急方式是发送端向另一端发送紧急数据的一种方式
选项与填充（必须为4字节整数倍，不够补0）：
最常见的可选字段的最长报文大小MSS（Maximum Segment Size），每个连接方
通常都在一个报文段中指明这个选项。它指明本端所能接收的最大长度的报文段。
该选项如果不设置，默认为536（20+20+536=576字节的IP数据报）
三次握手
（1）男孩喜欢女孩，于是写了一封信告诉女孩：我喜欢你，请和我交往吧！
写完信之后，男孩焦急地等待，因为不知道信能否顺利传达给女孩。
（2）女孩收到男孩的情书后，心花怒放，原来我们是两情相悦呀！
于是给男孩写了一封回信：我收到你的情书了，也明白了你的心意，
其实，我也喜欢你！我愿意和你交往！;
写完信之后，女孩也焦急地等待，因为不知道回信能否能顺利传达给男孩。
（3）男孩收到回信之后很开心，因为发出的情书女孩收到了，
并且从回信中知道了女孩喜欢自己，并且愿意和自己交往。
然后男孩又写了一封信告诉女孩：你的心意和信我都收到了，
谢谢你，还有我爱你！女孩收到男孩的回信之后，也很开心，
因为发出的情书男孩收到了。由此男孩女孩双方都知道了彼此的心意，
之后就快乐地交流起来了~~
所谓的`三次握手`即TCP连接的建立。这个连接必须是一方主动打开，
另一方被动打开的。
（1）首先客户端向服务器端发送一段TCP报文，其中：
标记位为SYN，表示“请求建立新连接”;序号为Seq=X（X一般为1）；
随后客户端进入SYN-SENT阶段。
（2）服务器端接收到来自客户端的TCP报文之后，结束LISTEN阶段。
并返回一段TCP报文，其中：
标志位为SYN和ACK，表示“确认客户端的报文Seq序号有效，
服务器能正常接收客户端发送的数据，并同意创建新连接”
（即告诉客户端，服务器收到了你的数据）；序号为Seq=y；
确认号为Ack=x+1，表示收到客户端的序号Seq并将其值加1
作为自己确认号Ack的值；随后服务器端进入SYN-RCVD阶段。
（3）客户端接收到来自服务器端的确认收到数据的TCP报文之后，
明确了从客户端到服务器的数据传输是正常的，结束SYN-SENT阶段。
并返回最后一段TCP报文。其中：
标志位为ACK，表示“确认收到服务器端同意连接的信号”
（即告诉服务器，我知道你收到我发的数据了）；序号为Seq=x+1，
表示收到服务器端的确认号Ack，并将其值作为自己的序号值；
确认号为Ack=y+1，表示收到服务器端序号Seq，
并将其值加1作为自己的确认号Ack的值；随后客户端进入ESTABLISHED阶段。
服务器收到来自客户端的“确认收到服务器数据”的TCP报文之后，
明确了从服务器到客户端的数据传输是正常的。
结束SYN-SENT阶段，进入ESTABLISHED阶段。
在客户端与服务器端传输的TCP报文中，双方的确认号Ack和序号Seq的值，
都是在彼此Ack和Seq值的基础上进行计算的，
这样做保证了TCP报文传输的连贯性。一旦出现某一方发出的TCP报文丢失，
便无法继续"握手"，以此确保了"三次握手"的顺利完成。
滑动窗口
维持发送方/接收方缓冲区,缓冲区是用来解决网络之间数据不可靠的问题，
例如丢包，重复包，出错，乱序。在TCP协议中，
发送方和接受方通过各自维护自己的缓冲区。
通过商定包的重传机制等一系列操作，来解决不可靠的问题。
`问题一：`如果你是TCP设计者，如何保证数据包依次序传输？
解决方案： 发送 <=> 确认机制
问题二： 采用问题一的解决方案会带来效率上的弊端，
数据包在网络上的传输需要时间
解决方案: 一次发送多个包，同时确认多个
问题三: 我们每次需要发多少个包过去呢？发送多少包是最优解呢？
正常情况
我们能不能把第一个和第二个包发过去后，收到第一个确认包就把第三个包发
过去呢？而不是去等到第二个包的确认包才去发第三个包。
这样就很自然的产生了我们"滑动窗口"的实现。
在图中，我们可看出灰色1号2号3号包已经发送完毕，并且已经收到Ack。
这些包就已经是过去式。4、5、6、7号包是黄色的，表示已经发送了。
但是并没有收到对方的Ack，所以也不知道接收方有没有收到。
8、9、10号包是绿色的。是我们还没有发送的。这些绿色也
就是我们接下来马上要发送的包。 可以看出我们的窗口正好是7格。
后面的11-16还没有被读进内存。要等4号-10号包有接下来的动作后，
我们的包才会继续往下发送。
可以看到4号包对方已经被接收到，所以被涂成了灰色。“窗口”就往右移一格，
这里只要保证“窗口”是7格的。 我们就把11号包读进了我们的缓存。
进入了“待发送”的状态。8、9号包已经变成了黄色，表示已经发送出去了。
接下来的操作就是一样的了，确认包后，窗口往后移继续将未发送的包读进缓存，
把“待发送“状态的包变为”已发送“。
丢包情况
有可能我们包发过去，对方的Ack丢了。也有可能我们的包并没有发送过去。
从发送方角度看就是我们没有收到Ack。
一般情况：一直在等Ack。如果一直等不到的话，
我们也会把读进缓存的待发送的包也一起发过去。
但是，这个时候我们的窗口已经发满了。所以并不能把12号包读进来，
而是始终在等待5号包的Ack。
如果我们这个Ack始终不来怎么办呢？ 采用超时重传机制解决:
发送端每发送一个报文段，就启动一个定时器并等待确认信息；
接收端成功接收新数据后返回确认信息。
若在定时器超时前数据未能被确认，TCP就认为报文段中的数据已丢失或损坏，
需要对报文段中的数据重新组织和重传。(重传超时时间: RTO)
四次挥手
1.客户端发送断开TCP连接请求的报文，其中报文中包含seq序列号，
是由发送端随机生成的，并且还将报文中的FIN字段置为1，
表示需要断开TCP连接。（FIN=1，seq=x，x由客户端随机生成）
2.服务端会回复客户端发送的TCP断开请求报文，其包含seq序列号，
是由回复端随机生成的，而且会产生ACK字段，
ACK字段数值是在客户端发过来的seq序列号基础上加1进行回复，
以便客户端收到信息时，知晓自己的TCP断开请求已经得到验证。
（FIN=1，ACK=x+1，seq=y，y由服务端随机生成）
3.服务端在回复完客户端的TCP断开请求后，不会马上进行TCP连接的断开，
服务端会先确保断开前，所有传输到A的数据是否已经传输完毕，
一旦确认传输数据完毕，就会将回复报文的FIN字段置1，
并且产生随机seq序列号。（FIN=1，ACK=x+1，seq=z，z由服务端随机生成）
4.客户端收到服务端的TCP断开请求后，会回复服务端的断开请求，
包含随机生成的seq字段和ACK字段，
ACK字段会在服务端的TCP断开请求的seq基础上加1，
从而完成服务端请求的验证回复。
（FIN=1，ACK=z+1，seq=h，h为客户端随机生成）
至此TCP断开的4次挥手过程完毕。
UDP通信
1. TCP与UDP
当使用网络套接字通信时，
套接字的“域”都取AF_INET;
套接字的type：
SOCK_STREAM 此时，默认使用TCP协议进行通信。
SOCK_DGRAM 此时，默认使用UDP协议进行通信。
TCP通信，是一个有序的、可靠的、面向连接的
UDP通信，是不保证有序到达的数据报服务。（在局域网内，使用UDP已很可靠）
2. 使用UDP通信
与TCP通信使用上的区别：
1）创建套接字时的type(参数2）不同。
TCP通信，使用SOCK_STREAM
UDP通信，使用SOCK_DGRAM
2）发送数据和接收数据时，使用的接口不同
TCP通信，发送数据，使用write（或send）
接收数据，使用read（或recv）
UDP特性，发送数据，使用sendto
接收数据，服务器端使用recvfrom
客户端使用recv
3）不需要使用listen
4）不需要先建立连接
(TCP客户端和服务器端分别使用connect和receive建立连接)
步骤总结：
基于UDP的网络套接字通信
服务器端
(1) 创建一个网络套接字
(2) 设置服务器地址
(3) 绑定该套接字，使得该套接字和对应的端口关联起来
(4) 循环处理客户端请求
使用recvfrom等待接收客户端发送的数据
使用sendto发送数据至客户端
客户端
(1) 创建一个套接字
(2) 设置服务器地址
(3) 使用sendto向服务器端（接收端）发送数据
(4) 使用recv接受数据
3. sendto与recvfrom、recv
1) sendto
功能：UDP服务器或客户端用于发送数据
原型：int sendto (int sockfd, // 套接字
void *buff, // 发送缓存区
size_t len, // 发送缓冲区的长度
init flags, // 标志，一般取0
struct sockaddr *to, // 目的主机地址
socklen_t tolen // 目的主机地址长度
);
返回值：成功，返回实际发送数据的字节数
失败，返回-1
2) recvfrom
功能：UDP服务器用于接收数据
原型： 与sendto类似。
int recvfrom (int sockfd, // 套接字
void *buff, // 接收缓存区
size_t len, // 接受缓冲区的长度
init flags, // 标志，一般取0
struct sockaddr *to, // 源主机地址
socklen_t *tolen // 源主机地址长度
);
注意：参数6必须要初始化为对应地址的长度！
3) recv
功能：UDP客户端用于接收数据
原型： ssize_t recv (int sockfd, void *buf, size_t len,
int flags);
注意： 该调用的参数不需要指定地址。
因为当使用udp时，对应的套接字被自动绑定在一个短暂的动态的端口上。
4.实例
实例1: 服务器接收、客户端发送
client_01.c
#include <sys/un.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#define BUFF_SIZE 1024
int main() {
int sockfd;
struct sockaddr_in server_addr;
int ret;
int c;
char buff[BUFF_SIZE];
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
server_addr.sin_port = htons(9000);
strcpy(buff, "hello world");
ret = sendto(sockfd, buff, strlen(buff) + 1, 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
if (ret == -1) {
perror("sendto");
exit(errno);
}
printf("ret = %d\n", ret);
return 0;
}
server_01.c
#include <sys/un.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#define BUFF_SIZE 1024
int main() {
int server_sockfd;
int client_sockfd;
char ch;
int ret;
int recv_len;
char buff[BUFF_SIZE];
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int client_addr_len = sizeof(struct sockaddr_in);
server_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(9000);
ret = bind(server_sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
if (ret == -1) {
perror("bind");
exit(1);
}
while (1) {
printf("server waiting\n");
recv_len = recvfrom(server_sockfd, buff, sizeof(buff), 0, (struct sockaddr*)&client_addr, &client_addr_len);
if (recv_len < 0) {
perror("recvfrom");
exit(errno);
}
printf("received: %s\n", buff);
}
close(server_sockfd);
return 0;
}
运行结果
实例2：服务器收发、客户方发送、接收。
server_02.c
#include <sys/un.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#define BUFF_SIZE 1024
static void str2up(char* str) {
while (*str) {
if (*str >= 'a' && *str <= 'z') {
*str = *str - 'a' + 'A';
}
str++;
}
}
int main() {
int server_sockfd;
int client_sockfd;
char ch;
int ret;
int recv_len;
int send_len;
char buff[BUFF_SIZE];
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int client_addr_len = sizeof(struct sockaddr_in);
server_sockfd = socket(AF_INET, SOCK_DGRAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(9000);
ret = bind(server_sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
if (ret == -1) {
perror("bind");
exit(1);
}
while (1) {
printf("server waiting\n");
recv_len = recvfrom(server_sockfd, buff, sizeof(buff), 0, (struct sockaddr*)&client_addr, &client_addr_len);
if (recv_len < 0) {
perror("recvfrom");
exit(errno);
}
printf("received: %s\n", buff);
str2up(buff);
send_len = sendto(server_sockfd, buff, strlen(buff) + 1, 0, (struct sockaddr*)&client_addr, client_addr_len);
if (send_len == -1) {
perror("sendto");
exit(errno);
}
}
clone(server_sockfd);
return 0;
}
client_02.c
#include <sys/un.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#define BUFF_SIZE 1024
int main() {
int sockfd;
struct sockaddr_in server_addr;
int ret;
int c;
char buff[BUFF_SIZE];
socklen_t addr_len;
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
server_addr.sin_port = htons(9000);
strcpy(buff, "hello world");
ret = sendto(sockfd, buff, strlen(buff) + 1, 0, (struct sockaddr*)&server_addr, sizeof(server_addr));
if (ret == -1) {
perror("sendto");
exit(errno);
}
printf("send %d bytes\n", ret);
ret = recv(sockfd, buff, sizeof(buff), 0);
if (ret == -1) {
perror("recv");
exit(errno);
}
printf("received %d bytes\n", ret);
printf("received %s\n", buff);
return 0;
}
运行结果
同步IO和异步IO
场景1： 小明去打开水，而开水塔此时没有水，小明在现场一直等待开水到来，
或者不断的轮询查看是否有开水，直到有开水取到水为止，
这是同步IO的一种案例！
同步IO的特点：
同步IO指的是用户进程触发I/O操作并等待或者轮询的去查看I/O操作是否就绪。
同步IO的执行者是IO操作的发起者。
同步IO需要发起者进行内核态到用户态的数据拷贝过程，所以这里必须阻塞
场景2： 小明去打开水，而开水塔此时没有水，开水塔的阿姨叫小明把水壶
放到现场，来水后会帮他打好水，
并打电话叫他来取，这是异步IO的一种案例！
异步IO的特点：
异步IO是指用户进程触发I/O操作以后就立即返回，继续开始做自己的事情，
而当I/O操作已经完成的时候会得到I/O完成的通知。
异步IO的执行者是内核线程，内核线程将数据从内核态拷贝到用
户态，所以这里没有阻塞
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
