网路通信的三大要素：协议，端口和IP
知识点1【字节序】
多字节在主机中的存放数据
把多字节看成一个整体存储的顺序。
为什么我们在文件中没有这个概念呢？
因为文件是字节流（流指针），流是以一个字节为操作单位，并不是多字节
字节序分为两种：大端和小端
大端格式：高字节数据存放在低地址
小端格式：低字节数据存放在低地址
记忆方式：只看低地址，看是存储的高字节数据还是低字节数据
小（低）对小 高大上
大小端是系统决定的，我们不能更改。
Linux 都是小端的。
案例1：判断当前系统是大端还是小端
判断思路：判断低地址存放的是 低字节数据还是高字节数据
代码演示
代码运行结果：
数组是 不管是什么系统，第0个元素是低地址
知识点2【网络字节序和主机字节序】
1、如果计算机没有考虑字节序的问题，容易导致传输的数据错误
这种错误会现在异构计算机上：计算机的架构不同。小端架构和大端架构
小端主机和大端数据通信时，又有字节序的不同，导致数据错误，如下图
2、解决上述问题的方法
方法引入
我们各地都有各自的方言，为了让全国都能正常沟通，国家为此规定了普通话，将方言转换为普通话，就都能正常沟通了，普通话就是一个标准。
下图只是说明问题，并非实际过程
方法
网络 里的 数据必须是大端
因此上述的实际过程。
主机A（大端格式）传输数据，传到网络，发现是大端字节序，无需数据格式转换
主机B（小端格式）接受数据，知道网络传输的数据格式是大端格式，会进行类型格式的转换，转换为小端字节序
3、主机字节序和网络字节序
引入
那么问题又来了，主机不知道自己是什么字节序，那该如何判读是否需要数据转换呢？
因此 这里 引入和 网络字节序（net） 和主机字节序（host）
转换的过程，有需要引入两个函数
hton，ntoh：这两个函数都会进行 主机字节序 的 判断，根据判断结果决定需不需要转换。
总结
发送数据：需要将 主机字节序 转换为 网络字节序 hton
接收数据：需要将 网络字节序 转换为 主机字节序 ntoh
知识点2【字节序的转换函数】
1、主机字节序 转 网络字节序（发送）
#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);//转IP
uint16_t htons(uint16_t hostshort);//转端口号
函数介绍 只介绍htonl htons类似
-
函数介绍
功能:
将 32 位主机字节序数据转换成网络字节序数据
参数：
hostint32：待转换的 32 位主机字节序数据
返回值：
成功：返回网络字节序的值
重复
端口号无符号短整型
IP地址 32位
mac地址 48位
2、网络字节序 转 主机字节序（接收）
#include <arpa/inet.h>
uint32_t ntohl(uint32_t netlong);//转ip
uint16_t ntohs(uint16_t netshort);//转端口号
-
函数介绍
功能：
将 32 位网络字节序数据转换成主机字节序数据
参数：
uint32_t： unsigned int
netint32：待转换的 32 位网络字节序数据
返回值：
成功：返回主机字节序的值
案例 htonl
代码演示
#include <stdio.h>
#include <arpa/inet.h>
int main(int argc, char const *argv[])
{
uint32_t num = 0x04030201;
printf("num = %d\\n",num);
printf("htonl(num) = %#x\\n",htonl(num));
printf("htonl(num) = %d\\n",htonl(num));
return 0;
}
代码运行结果
知识点3【地址转换函数】
这里的地址指的是IP地址
“10.9.11.5” 这种IP是 点分十进制串 （用户识别的IP地址）IPv4
“fe80::578a:738a:f506:f37a”这种IP是 冒分十六进制串 IPv6
但是：计算机 是用 32位无符号数据 存储的IP地址
大家判断一下 上面我写的这个字符串多少个字节
10个字节
那么 点分十进制串 最大的字节数是多少呢？
“192.168.100.101”
是16个字节（算’\0’）
因此我们以后 存储 点分十进制串 要用16个字节来存储
1、发送数据
需要将 点分十进制数串 转换为 32位无符号数
#include <arpa/inet.h>
int inet_pton(int af, const char *src, void *dst);
-
函数介绍
功能：
将点分十进制串 转换为 无符号数网络IP
参数：
af： (address family)
IPv4的点分十进制串→AF_INET
IPv6的冒分十六进制串→AF_INET6
src：输入参数，指向以空字符结尾的字符串，表示 IPv4 或 IPv6 地址。
点分十进制串 和 冒分十六进制串
dst： 输出参数，指向一个缓冲区，用于存储转换后的二进制数据。
返回值：
- 1：成功转换。
- 0：输入地址无效（例如，IPv4 字符串包含字母）。
- -1：发生错误（如
af参数不合法），可通过errno获取具体错误
代码演示
#include <stdio.h>
#include <arpa/inet.h>
int main(int argc, char const *argv[])
{
//实现IP 点分十进制串 向 32位IP地址（IPv4）的转换
//我们假设IP地址为：10.11.1.5
char *str_ip = "10.11.1.5";
u_int32_t addr = 0;
inet_pton(AF_INET,str_ip,&addr);
printf("addr = %u\\n",addr);
//现在我们按照字符遍历一下
unsigned char *p = (unsigned char *)&addr;
printf("%d.%d.%d.%d\\n",*p,*(p + 1),*(p + 2),*(p + 3));
return 0;
}
代码运行结果
这里我自己实现了一个 pton的函数，大家看一下，有助于大家更好地理解pton
自己实现的pton
int my_pton(char *str_ip,int *addr)
{
//先进性数据提取
char ch_p[4];
int int_p[4];
sscanf(str_ip,"%d.%d.%d.%d",&int_p[0],&int_p[1],&int_p[2],&int_p[3]);
//这里的数据高位（第一个%d） 存储到了&int_p[0]中,而数组下标小的在低地址，与我们想要的相反，因此我们下面要转换过来
//将数据提取到字符数组当中
for (size_t i = 0; i < 4; i++)
{
if(int_p[i] > 255 || int_p[i] < 0)
{
return 0;
}
ch_p[i] = (unsigned char)int_p[i];
}
*addr = ch_p[0] << 24 | ch_p[1] << 16 | ch_p[2] << 8 | ch_p[3];//这里不需要强转，因为会自动类型转换
//现在的顺序对了，但是此时是小端存储，但是pton的结果 我们分析出 是大端存储，因此我们需要 转换为大端存储
*addr = htonl(*addr);
return 1;
}
代码运行结果
2、接收数据
将32为无符号数据 转换成 点分十进制数串
-
函数介绍
#include <arpa/inet.h> const char *inet_ntop(int af, const void *src,char *dst, socklen_t size);功能：
将 二进制格式的 IP 地址 转换为 可读字符串
参数：
af：Address Family
src：输入参数，指向二进制格式的 IP 地址。
dst：输出参数，指向用于存储结果字符串的缓冲区。
size：缓冲区
dst的字节长度。需足够大以防止溢出。返回值：
- 成功：返回指向
dst的指针（即转换后的字符串地址）。 - 失败：返回
NULL，并设置errno表示具体错误。
- 成功：返回指向
知识点4【UDP编程概述】
1、socket
网络通信要解决的问题 是不同主机进程间的通信
三要素
1、IP地址
2、PORT
3、协议
socket：网络程序编程开发接口的统称
socket作用
提供不同主机上的进程之间的通信
socket特点
1、socket也称”套接字“
2、是一个特殊的文件描述符（套接字），代表一个通信管道的一个端点
3、类似对文件的操作一样，可以使用read，write，close等函数对socket套接字进行网络数据的读取和发送等操作
4、得到套接字（描述符）的方法调用socket()
5、socket可读可写，且有端口和IP
注意
不要直接成socket是文件描述符，它是一种特殊的文件描述符，它有专属名称是套接字
2、UDP的编程流
bind 绑定函数，服务器是被动的，服务器给用户一个固定的端口，而这个固定的端口的提供 需要bind绑定函数来实现，可以通过端口找到该服务器。一旦绑定了这个端口，这个端口号其他进程就不可以再使用。
绑定 客户端也是可以有的，一旦绑定，发送消息，其他客户端就知道 是本端口发送的，其他客户端也可以通过这个端口找到该客户端
客户端：创建套接字，收，发，关闭套接字
服务器：创建，绑定，收，发，关闭（图中没有，记得加上）
关闭防火墙交流
背一下：
hton：将 主机字节序 转换为 网络字节序
ntoh：将 网络字节序 转换为 主机字节序
pton：字符串转换 为 大端的二进制数据
ntop：大端二进制数据 转换为 字符串
3、socket函数创建一个套接字（通信的端点）
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
int socket(int family,int type,int protocol);
功能：
创建一个用于网络通信的 socket 套接字（描述符）
参数：
family:协议族(AF_INET、AF_INET6、PF_PACKET 等)
type:套接字类(SOCK_STREAM、SOCK_DGRAM、SOCK_RAW 等)
protocol:协议类别(0、IPPROTO_TCP、IPPROTO_UDP 等
返回值：
套接字
特点：
创建套接字时，系统不会分配端口
代码演示
代码运行结果
4、IPv4地址结构体
**作用：**定义 地址结构体变量
#include <netinet/in.h>
struct in_addr
{
in_addr_t s_addr;//4 字节
};
struct sockaddr_in//IPv4地址 结构体
{
sa_family_t sin_family;//2 字节
in_port_t sin_port;//2 字节
struct in_addr sin_addr;//4 字节
char sin_zero[8]//8 字节
};
//IPv6地址结构体 ：sockaddr_in6
sin_zero 全部需要补零。作用是将结构体补充成16个字节
我们定义结构体后，建议先把结构体清零
5、通用地址结构体
对传递给函数的参数进行类型转换 不做赋值操作
struct sockaddr
{
sa_family_t sa_family; // 2 字节
char sa_data[14] //14 字节
};
这里解释一下，为什么要这个结构体，由family可以看出，我们可以选择IPv4 也可以选择IPv6，IPv4和IPv6是两种协议，我们在设计sendto函数的时候，由于它们所需的地址结构体是不同的，但是我们又想用同一个sendto函数。
我们就定义了一个通用地址结构体，通用结构体是16个字节，它只有前两个字节有效也就是family成员，代码中会对family就行判断，确定是IPv4 还是IPv6，然后函数内部进行结构体类型强转。就可以实现一个sendto函数完成IPv4和IPv6的通用。
综上在这里 通用地址结构体的作用类似于：**void ***
大家可以在下面sendto介绍中看一下，to 的类型是什么，还有recvform中from的的类型是什么。
6、sendto发送UDP消息
TCP消息是用send发送的。
套接字，内容，大小，0，目标，大小
#include <sys/types.h>
#include <sys/socket.h>
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
功能：
向 to 结构体指针中指定的 ip，发送 UDP 数据
参数：
sockfd：套接字
buf：发送数据缓冲区
nbytes: 发送数据缓冲区的大小
flags：一般为 0
行为标志，网络数据比较复杂，紧急指针等需要特殊处理，这里我们写0就行
to：指向目的主机地址结构体的指针
addrlen：to 所指向内容的长度
返回值：
成功:发送数据的字符数
失败: -1
注意：
通过 to 和 addrlen 确定目的地址
可以发送 0 长度的 UDP 数据包
代码演示
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
int main(int argc, char const *argv[])
{
//创建一个 套接字
int sockfd = 0;
sockfd = socket(AF_INET,SOCK_DGRAM,0);
if(sockfd < 0)
{
perror("socket");
return 0;
}
printf("sockfd = %d\\n",sockfd);//遍历一下sockfd
//sendto
//输入数据
printf("请输入数据：\\n");
char buf[64] = "";
fgets(buf,sizeof(buf),stdin);
buf[strlen(buf) - 1] = 0;
//地址结构体创建
struct sockaddr_in addr;
memset(&addr,0,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(8080);
inet_pton(AF_INET,"192.168.136.1",&addr.sin_addr.s_addr);
//sendto 发送数据
int ret = sendto(sockfd,buf,strlen(buf),0,(struct sockaddr *)(&addr),sizeof(addr));
if(ret < 0)
{
perror("sendto");
return 0;
}
return 0;
}
代码运行结果
在上面运行结果我们看到，发送端口的端口号是随机的
这个端口是如何来的呢？
是又第一次sendto随机分配的，记住只有第一次send 才会分配，比如我们在程序中多次发送数据，在第一次sendto之后，端口号将不改变，我们将上面的代码加上循环
可以看到端口号没有改变。但是 结束该进程，开启一个新进程后，端口号会改变
但实际使用过程中，总不能端口号一直在改变，因此我们下面需要学习一下bind()函数设置固定的端口
7、bind给套接字绑定固定的 IP和端口
绑定的位置应在 socket()之后，在sendto()/recvfrom()之前
绑定函数只能绑定 本地机的IP和端口
int bind(int sockfd, const struct sockaddr *myaddr，socklen_t addrlen);
功能：
将本地协议地址 与 sockfd 绑定
参数：
sockfd： socket 套接字
myaddr： 指向特定协议的地址结构指针
addrlen：该地址结构的长度
返回值：
成功：返回 0
失败：其他
代码演示
#include <stdio.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
//创建socket
int sockfd = 0;
sockfd = socket(AF_INET,SOCK_DGRAM,0);
if(sockfd < 0)
{
perror("socket");
return 0;
}
printf("sockfd = %d\\n",sockfd);
//固定端口 bind 套接字 地址结构体 大小
struct sockaddr_in my_addr;
memset(&my_addr,0,sizeof(my_addr));
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(8000);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY==0，通配地址，让协议栈取本地机去找IP
int ret = bind(sockfd,(struct sockaddr *)&my_addr,sizeof(my_addr));
if(ret != 0)
{
perror("bind");
return 0;
}
//发送消息 套接字 大小 flags 地址结构体 大小
//键盘获取输入
char buf[64] = "";
fgets(buf,sizeof(buf),stdin);
buf[strlen(buf)-1] = 0;
//地址结构体的配置
struct sockaddr_in addr;
memset(&addr,0,sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(7000);
inet_pton(AF_INET,"192.168.136.1",&addr.sin_addr.s_addr);
sendto(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&addr,sizeof(addr));
//关闭套接字描述符
close(sockfd);
return 0;
}
代码运行结果
可以看到即使是两个进程，端口号也是不变的
8、recvfrom 接收数据（带阻塞）
如果负责收数据，记得绑定固定的端口及IP
ssize_t recvfrom(int sockfd, void *buf,size_t nbytes,int flags,
struct sockaddr *from,socklen_t *addrlen);
功能：
接收 UDP 数据，并将源地址信息保存在 from 指向的结构中
参数：
sockfd：套接字
buf：接收数据缓冲区
nbytes：接收数据缓冲区的大小
flags：套接字标志(常为 0)
from：源地址结构体指针，用来保存数据的来源**（可以为NULL）**
addrlen: from 的长度**（可以是NULL）**
和送礼一样，谁送的不重要，重要的是礼物
注意：
通过 from 和 addrlen 参数存放数据来源信息
from 和 addrlen 可以为 NULL, 表示不保存数据来源
返回值：
成功:接收到的字符数
失败: -1
注意：
这个返回值 我们可以利用返回值 判断数据是否收完。
接收到的数据如果小于收到的内容nybte，则表示收完了，停止接收数据。
有可能接收图片（RGB），因此我们存的话需要用unsigned char接收。
又由于以太网最大传输单元（MTU）是1500个，因此接受数组的个数1500即可
代码演示
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <string.h>
int main(int argc, char const *argv[])
{
//创建一个 socket
int sockfd = socket(AF_INET,SOCK_DGRAM,0);
if(sockfd < 0)
{
perror("socket");
return 0;
}
printf("sockfd = %d\n",sockfd);
//bind 固定端口于IP 必须要进行的操作 fd，地址结构体，大小
struct sockaddr_in my_addr;
memset(&my_addr,0,sizeof(my_addr));
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(6000);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
int ret = bind(sockfd,(struct sockaddr *)&my_addr,sizeof(my_addr));
if(ret != 0)
{
perror("bind");
return 0;
}
//接收数据
while(1)
{
unsigned char buf[1500] = "";
struct sockaddr_in addr;
memset(&addr,0,sizeof(addr));
int addr_len = sizeof(addr);
int ret = recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&addr,&addr_len);
if(ret < 0)
{
perror("recvfrom");
return 0;
}
//数据存储在buf中，数据的长度为ret
//IP来源于addr.sin_addr.s_addr，需要处理
//端口号为addr.sin_port，需要进行字节序转换
//IP处理
char str_add[16] = "";
inet_ntop(AF_INET,&addr.sin_addr.s_addr,str_add,sizeof(str_add));
//端口字节序转换
int port = ntohs(addr.sin_port);
//遍历一下
printf("从IP：%s 端口号：%hu 接收到的数据为：%s，数据长度为%d",str_add,port,buf,ret);
}
//关闭 套接字描述符
close(sockfd);
return 0;
}
结束
代码重在练习！
代码重在练习！
代码重在练习！
今天的分享就到此结束了，希望对你有所帮助，如果你喜欢我的分享，请点赞收藏夹关注，谢谢大家！！！
