• 嵌入式学习第二十五天！（网络的概念、UDP编程）

    网络：

        可以用来：数据传输、数据共享

    1. 网络协议模型：

        1. OSI协议模型：

    应用层实际收发的数据
    表示层发送的数据是否加密
    会话层是否建立会话连接
    传输层数据传输的方式（数据包，流式）
    网络层数据的路由（如何从一个局域网到达另一个局域网）
    数据链路层局域网下如何通信
    物理层物理介质的连接

          2. TCP/IP协议模型：

    应用层传输的数据
    传输层传输的方式
    网络层数据如何从一个台主机到达另一台主机
    网络接口层物理介质的连接
            1. 应用层：

                   例如有：HTTP      超文本传输协议

                                  HTTPS   

                                  FTP        文件传输协议

                                  TFTP      简单文本传输协议

                                  SMTP     邮件传输协议

                                  MQTT

                                  TELNET

                                  ...

            2. 传输层：

                  UDP：用户数据报协议

                        特点：1. 实现机制简单

                                   2. 资源开销小

                                   3. 不安全不可靠

                  TCP：传输控制协议

                          特点：1. 实现机制复杂

                                     2. 资源开销大

                                     3. 安全可靠

            3. 网络层：

                  IPv4

                  IP地址：唯一网络中一台主机的标号

                  IP地址：网络位 + 主机位

                  子网掩码：用来标识IP地址的网络位和主机位

                                    子网掩码是1的部分表示IP地址的网络位

                                    子网掩码是0的部分表示IP地址的主机位

                    网段号：网络位不变，主机位全位0，表示网段号

                    广播地址：网络位不变，主机位全为1，表示广播地址

                    IP地址类型：

                    A类：

                            1.0.0.0  -  126.255.255.255

                            子网掩码：255.0.0.0

                            管理超大规模网络

                            私有IP地址：10.0.0.0  -  10.255.255.255

                    B类：

                            128.0.0.0  -  191.255.255.255

                            子网掩码：255.255.0.0

                            管理大中规模型网络

                            私有IP地址：172.16.0.0  -  172.31.255.255

                    C类：

                            192.0.0.0  -  223.255.255.255

                            子网掩码：255.255.255.0

                            管理中小规模型网络

                            私有IP地址：192.168.0.0  -  192.168.255.255

                    D类：

                            224.0.0.0  -  239.0.0.0

                            用于组播

                    E类：

                            240.0.0.0  -  255.255.255.255

                            用于实验

            4. UDP编程：

                socket套接字（全双工）编程：

                发端：socket  ->  sendto  ->  close

                收端：socket  ->  bind  ->  recvfrom  ->  close

                1. 发端
                    1. socket：
    int socket(int domain, int type, int protocol);

                        功能：创建一个用来通信的文件描述符

                        参数：

                            domain：使用的协议族 AF_INET(IPv4协议族)

                            type：套接字类型

                                    SOCK_STREAM：流式套接字

                                    SOCK_DGRAM：数据报套接字

                                    SOCK_RAW：原始套接字

                            protocol：协议

                                    默认为0；

                        返回值：

                            成功返回文件描述符
                            失败返回-1

                    2. sendto：
    1. ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
    2.                       const struct sockaddr *dest_addr, socklen_t addrlen);

                        功能：利用套接字向指定地址发送数据信息

                        参数：

                            sockfd：套接字文件描述符

                            buf：发送数据空间首地址

                            len：发送数据的长度

                            flags：属性默认为0

                            dest_addr：目的地址信息存放的空间首地址

                            addrlen：目的地址的长度

    1. struct sockaddr_in {
    2.     sa_family_t    sin_family; /* address family: AF_INET */
    3.     in_port_t      sin_port;   /* port in network byte order */
    4.     struct in_addr sin_addr;   /* internet address */
    5. };
    6.  
    7. /* Internet address. */
    8. struct in_addr {
    9.     uint32_t       s_addr;     /* address in network byte order */
    10. };

                        返回值：

                            成功返回实际发送字节数
                            失败返回-1

                    3. inet_addr：
    in_addr_t inet_addr(const char *cp);

                        功能：将字符串IP地址转换为内存中的IP地址

                    4. htons：
    uint16_t htons(uint16_t hostshort);

                        功能：将本地字节序转换为网络的大端字节序

                练习：

                    1. 编写程序实现从终端接收字符串发送给windows软件调试助手，并接收软件助手的回复，显示在终端屏幕上

    1. #include "head.h"
    2.  
    3. int main(void)
    4. {
    5. 	int sockfd = 0;
    6. 	ssize_t nsize = 0;
    7. 	char tmpbuff[1024] = {0};
    8. 	struct sockaddr_in recvaddr;
    9.  
    10. 	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    11. 	if(sockfd == -1)
    12. 	{
    13. 		perror("fail to socket");
    14. 		return -1;
    15. 	}
    16. 	
    17. 	gets(tmpbuff);
    18.  
    19.  
    20. 	recvaddr.sin_family = AF_INET;
    21. 	recvaddr.sin_port = htons(50000);
    22. 	recvaddr.sin_addr.s_addr = inet_addr("192.168.1.162");
    23. 	
    24. 	bind(sockfd, (struct sockaddr *)&recvaddr, sizeof(&recvaddr));
    25.  
    26. 	nsize = sendto(sockfd, tmpbuff, strlen(tmpbuff), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    27. 	if(nsize == -1)
    28. 	{
    29. 		perror("fail to sendto");
    30. 		return -1;
    31. 	}
    32.  
    33. 	printf("成功发送 %ld 字节！\n", nsize);
    34.  
    35. 	
    36. 	memset(tmpbuff, 0, sizeof(tmpbuff));
    37. 	nsize = recvfrom(sockfd, tmpbuff, sizeof(tmpbuff), 0, (struct sockaddr *)&recvaddr, (socklen_t *)sizeof(&recvaddr));
    38. 	printf("%s\n",tmpbuff);
    39.  
    40. 	close(sockfd);
    41.  
    42. 	return 0;
    43. }
                 2. 收端
                    1. recvfrom：
    1. ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
    2.                         struct sockaddr *src_addr, socklen_t *addrlen);

                        功能：从套接字中接收数据

                        参数：

                            sockfd：套接字文件描述符

                            buf：存放数据空间首地址

                            flags：属性，默认为0

                            src_addr：存放IP地址信息的空间首地址

                            addlen：存放接收到IP地址大小空间的首地址

                        返回值：

                            成功返回实际接收字节数
                            失败返回-1 

                    2. 修改虚拟机到桥接模式：

                        点击“虚拟机”

                        点击“设置”

                        点击“网络适配器”

                        选择“桥接模式”

                        点击“确定”

                    3. 将网卡桥接到无线网卡：

                        点击“编辑”

                        点击“虚拟网络编辑器”

                        点击“更改设置”

                    4. 在Ubuntu中重启网络服务：
    sudo /etc/init.d/networking restart
                    5. 通过ifconfig查看虚拟机IP地址
                    6. bind：
    int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

                        功能：在套接字上绑定一个IP地址和端口号

                        参数：

                            sockfd：套接字文件描述符

                            addr：绑定IP地址空间首地址

                            addrlen：绑定IP地址的长度

                        返回值：

                            成功返回0 
                            失败返回-1 

                3. UDP需要注意的细节点：

                    1. UDP是无连接，发端退出，收端没有任何影响

                    2. UDP发送数据上限，最好不要超过1500个字节

                    3. UDP是不安全不可靠的，连续且快速的传输数据容易产生数据丢失

                4. wireshark

                    可以通过wireshark抓包工具来查看收发的数据

                    操作流程：

                        1. 打开wireshark：

    sudo wireshark

                        2. 选择抓取数据包的网卡：any

                        3. 执行通信的代码

                        4. 停止通信

                        5. 设定过滤条件

                            ip.addr == IP地址  ：通过IP地址查找

                            udp                        ：通过传输方式udp查找

                            tcp                         ：通过传输方式tcp查找

                            udp.port == 端口号：通过端口号查找

                5. UDP包头长度：8个字节

                    源端口号（2个字节）

                    目的端口号（2个字节）

                    长度（2个字节）

                    检验和（2个字节）

                练习：

                    要求在不同主机中编写两个程序，实现全双工聊天功能

                    1. 进入软件后接收当前用户的昵称

                    2. 显示的格式为对方用户昵称 (对方IP：对方端口) > 接收到的内容

                    3. 用户输入“.quit”退出聊天

                    4. 网络通信时收发结构体

    1. struct person 
    2. {
    3.     char name[32];
    4.     char text[512];
    5. };
    1. #include "head.h"
    2.  
    3. int sockfd = 0;
    4. ssize_t nsize = 0;
    5. struct sockaddr_in tmpaddr;
    6. struct sockaddr_in sendaddr;
    7. socklen_t addrlen = sizeof(tmpaddr);
    8.  
    9. struct person
    10. {
    11. 	char name[32];
    12. 	char text[512];
    13. };
    14.  
    15. pthread_t tid_recv;
    16. pthread_t tid_send;
    17.  
    18. void *RecvInfo(void *arg)
    19. {
    20. 	struct person user;
    21. 	while(1)
    22. 	{
    23. 		memset(&user, 0, sizeof(user));
    24. 		nsize = recvfrom(sockfd, &user, sizeof(user), 0, (struct sockaddr *)&tmpaddr, &addrlen);
    25. 		if(nsize == -1)
    26. 		{
    27. 			perror("fail to recvfrom");
    28. 			return NULL;
    29. 		}
    30. 		printf("%s %s : %d > %s\n", user.name, inet_ntoa(tmpaddr.sin_addr), ntohs(tmpaddr.sin_port), user.text);
    31. 		if(!strcmp(user.text, ".quit"))
    32. 		{
    33. 			break;
    34. 		}
    35. 	}
    36. 	pthread_cancel(tid_send);
    37. 	return NULL;
    38. }
    39.  
    40. void *SendInfo(void *arg)
    41. {
    42. 	struct person user;
    43. 	while(1)
    44. 	{
    45. 		memset(&user, 0, sizeof(user));
    46. 		scanf("%s", user.name);
    47. 		scanf("%s", user.text);
    48. 		nsize = sendto(sockfd, &user, sizeof(user), 0, (struct sockaddr *)&sendaddr, sizeof(sendaddr));
    49. 		if(nsize == -1)
    50. 		{
    51. 			perror("fail to sendto");
    52. 			return NULL;
    53. 		}
    54. 		printf("success send %ld byte\n", nsize);
    55. 		if(!strcmp(user.text, ".quit"))
    56. 		{
    57. 			break;
    58. 		}
    59. 	}
    60. 	pthread_cancel(tid_recv);
    61. 	
    62. 	return NULL;
    63. }
    64.  
    65. int main(void)
    66. {
    67. 	struct sockaddr_in recvaddr;
    68.  
    69. 	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    70. 	if(sockfd == -1)
    71. 	{
    72. 		perror("fail to socket");
    73. 		return -1;
    74. 	}
    75. 	
    76. 	recvaddr.sin_family = AF_INET;
    77. 	recvaddr.sin_port = htons(30000);
    78. 	recvaddr.sin_addr.s_addr = inet_addr("192.168.1.153");
    79. 	bind(sockfd, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    80. 	
    81. 	sendaddr.sin_family = AF_INET;
    82. 	sendaddr.sin_port = htons(30000);
    83. 	sendaddr.sin_addr.s_addr = inet_addr("192.168.1.152");
    84. 	
    85. 	pthread_create(&tid_recv, NULL, RecvInfo, NULL);
    86. 	pthread_create(&tid_send, NULL, SendInfo, NULL);
    87.  
    88. 	pthread_join(tid_recv, NULL);
    89. 	pthread_join(tid_send, NULL);
    90.  
    91.  
    92. 	close(sockfd);
    93.  
    94. 	return 0;
    95.  
    96. }
            5. UDP项目练习：

            题目：基于UDP实现直播间聊天的功能：

            需求：

                    软件划分为用户客户端和主播服务端两个软件client.c和server.c

                    用户客户端负责：

                            1.接收用户的昵称
                            2.接收用户输入的信息，能够将信息发送给服务端
                            3.接收服务端回复的数据信息,并完成显示

                    主播服务端负责：

                            1.对所有加入直播间的用户的IP地址和端口实现管理（加入、退出）
                            2.当有新的客户端加入时,能够向所有客户端提示:"欢迎 XXX 用户进入直播间"
                            3.当有客户端退出时,能够向所有客户端提示:"XXX 离开直播间"
                            4.能够实现客户端聊天内容的转发,当某个客户端发送聊天信息时,能够将该信息转给除了该用户之外聊天室内所有其余客户端用户

    client.c

    1. #include "head.h"
    2.  
    3. int sockfd = 0;
    4. char name[32];
    5. struct sockaddr_in recvaddr;
    6. pthread_t tid_send;
    7. pthread_t tid_recv;
    8.  
    9. void *SendMsg(void *arg)
    10. {
    11. 	struct msgbuf sendmsg;
    12. 	ssize_t nsize = 0;
    13. 	while(1)
    14. 	{
    15. 		memset(&sendmsg, 0, sizeof(sendmsg)); 
    16. 		sendmsg.type = USER_TYPE_CHAT;
    17. 		sprintf(sendmsg.name, "%s", name);
    18. 		gets(sendmsg.text);
    19. 		if(strcmp(sendmsg.text,".quit") == 0)
    20. 		{
    21. 			sendmsg.type = USER_TYPE_OUT;
    22. 		}
    23. 		nsize = sendto(sockfd, &sendmsg, sizeof(sendmsg), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    24. 		if(nsize == -1)
    25. 		{
    26. 			perror("fail to sendto");
    27. 			return NULL;
    28. 		}
    29. 		if(sendmsg.type == USER_TYPE_OUT)
    30. 		{
    31. 			break;
    32. 		}
    33. 	}
    34. 	pthread_cancel(tid_recv);
    35.  
    36. 	return NULL;
    37. }
    38.  
    39. void *RecvMsg(void *arg)
    40. {
    41. 	struct msgbuf recvmsg;
    42. 	ssize_t nsize = 0;
    43.  
    44. 	while(1)
    45. 	{
    46. 		nsize = recvfrom(sockfd, &recvmsg, sizeof(recvmsg), 0, NULL, NULL);
    47. 		if(nsize == -1)
    48. 		{
    49. 			perror("fail to recvfrom");
    50. 			return NULL;
    51. 		}
    52. 		if(recvmsg.type == USER_TYPE_CHAT)
    53. 		{
    54. 			printf("%s>%s\n", recvmsg.name, recvmsg.text);
    55. 		}
    56. 		if(recvmsg.type == USER_TYPE_OUT)
    57. 		{
    58. 			break;
    59. 		}
    60. 	}
    61. 	
    62. 	return NULL;
    63. }
    64.  
    65. int main(void)
    66. {
    67. 	ssize_t nsize = 0;
    68. 	struct msgbuf sendmsg; 
    69.  
    70.  
    71. 	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    72. 	if(sockfd == -1)
    73. 	{
    74. 		perror("fail to socket");
    75. 		return -1;
    76. 	}
    77. 	
    78. 	printf("请输入你的名字：\n");
    79. 	gets(name);
    80. 	
    81. 	memset(&sendmsg, 0, sizeof(sendmsg));
    82. 	sendmsg.type = USER_TYPE_INT;
    83. 	sprintf(sendmsg.name, "%s", name);
    84.  
    85. 	recvaddr.sin_family = AF_INET;
    86. 	recvaddr.sin_port = htons(SERVER_PORT);
    87. 	recvaddr.sin_addr.s_addr = inet_addr(SERVER_ADDR);
    88. 	nsize = sendto(sockfd, &sendmsg, sizeof(sendmsg), 0, (struct sockaddr *)&recvaddr, sizeof(recvaddr));
    89. 	if(nsize == -1)
    90. 	{
    91. 		perror("fail to sendto");
    92. 		return -1;
    93. 	}
    94.  
    95. 	pthread_create(&tid_send, NULL, SendMsg, NULL);
    96. 	pthread_create(&tid_recv, NULL, RecvMsg, NULL);
    97.  
    98. 	pthread_join(tid_send, NULL);
    99. 	pthread_join(tid_recv, NULL);
    100.  
    101. 	close(sockfd);
    102. }

    server.c

    1. #include "head.h"
    2.  
    3. int main(void)
    4. {
    5. 	int sockfd = 0;
    6. 	ssize_t nsize = 0;
    7. 	ssize_t size = 0;
    8. 	struct sockaddr_in serveraddr;
    9. 	
    10. 	struct address useraddr[100];
    11. 	struct sockaddr_in userinfo;
    12. 	socklen_t addrlen = 0;
    13. 	addrlen = sizeof(userinfo);
    14.  
    15. 	struct msgbuf recvuser;
    16. 	int i = 0;
    17.  
    18. 	sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    19. 	if(sockfd == -1)
    20. 	{
    21. 		perror("fail to socket");
    22. 		return -1;
    23. 	}
    24. 	
    25. 	serveraddr.sin_family = AF_INET;
    26. 	serveraddr.sin_port = htons(SERVER_PORT);
    27. 	serveraddr.sin_addr.s_addr = inet_addr(SERVER_ADDR);
    28. 	bind(sockfd, (struct sockaddr *)&serveraddr, sizeof(serveraddr));
    29. 	
    30. 	memset(useraddr, 0, sizeof(useraddr));
    31.  
    32. 	while(1)
    33. 	{
    34. 		memset(&recvuser, 0, sizeof(recvuser));
    35. 		memset(&userinfo, 0, sizeof(userinfo));
    36. 		nsize = recvfrom(sockfd, &recvuser, sizeof(recvuser), 0, (struct sockaddr *)&userinfo, &addrlen);
    37. 		if(nsize == -1)
    38. 		{
    39. 			return -1;
    40. 		}
    41. 		if(recvuser.type == USER_TYPE_INT)
    42. 		{
    43. 			for(i = 0; i < 100; i++)
    44. 			{
    45. 				if(useraddr[i].mark == 1)
    46. 				{
    47. 					continue;
    48. 				}
    49. 				else if(useraddr[i].mark == 0)
    50. 				{
    51. 					useraddr[i].mark = 1;
    52. 					useraddr[i].cltaddr.sin_family = AF_INET;
    53. 					useraddr[i].cltaddr.sin_port = userinfo.sin_port;
    54. 					useraddr[i].cltaddr.sin_addr.s_addr = userinfo.sin_addr.s_addr;
    55. 					printf("欢迎用户：%s来到直播间！\n", recvuser.name);
    56. 					break;
    57. 				}
    58. 			}
    59. 		}
    60. 		else if(recvuser.type == USER_TYPE_OUT)
    61. 		{
    62. 			for(i = 0; i < 100; i++)
    63. 			{
    64. 				if(memcmp(&useraddr[i].cltaddr, &userinfo, sizeof(userinfo)) == 0)
    65. 				{
    66. 						useraddr[i].mark = 0;
    67. 						printf("用户：%s离开直播间！\n", recvuser.name);
    68. 				}
    69. 			}
    70. 		}
    71. 		else if(recvuser.type == USER_TYPE_CHAT)
    72. 		{
    73. 			printf("%s(%s:%d)>%s\n", recvuser.name, inet_ntoa(userinfo.sin_addr), ntohs(userinfo.sin_port), recvuser.text);
    74. 			for(i = 0; i < 100; i++)
    75. 			{
    76. 				if(useraddr[i].mark != 0)
    77. 				{
    78. 					size = sendto(sockfd, &recvuser, sizeof(recvuser), 0, (struct sockaddr *)&useraddr[i].cltaddr, sizeof(useraddr[i].cltaddr));
    79. 					if(size == -1)
    80. 					{
    81. 						perror("fail to sendto");
    82. 						return -1;
    83. 					}
    84. 				}
    85. 			}
    86. 		}
    87. 	}	
    88. 	close(sockfd);
    89.  
    90. 	return 0;
    91. }

    在这里head.h中定义了两个结构体，已经定义了客户发过来的状态

    1. #ifndef _HEAD_H_
    2. #define _HEAD_H_
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16. #include 
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27.  
    28. struct msgbuf
    29. {
    30. 	int type;
    31. 	char name[32];
    32. 	char text[512];
    33. };
    34.  
    35. struct address
    36. {
    37. 	struct sockaddr_in cltaddr;
    38. 	int mark;
    39. };
    40.  
    41. #define USER_TYPE_INT  100
    42. #define USER_TYPE_OUT   200
    43. #define USER_TYPE_CHAT  300
    44.  
    45. #define SERVER_ADDR  "192.168.1.162"
    46. #define SERVER_PORT  5000
    47.  
    48. #endif

  • 相关阅读:
    使用方便、易于集成、可扩展的用于物流运输行业的文档管理软件
    AR人体姿态识别，实现无边界的人机交互
    es : java 查询
    Spring之事务开发
    ChatGPT：深度学习和机器学习的知识桥梁
    工业4.0 IO-Link RFID传感器|读写器应用前景与优势分析
    【笔记】《C++性能优化指南》Ch3 测量性能
    关于解决前后端分离开发——跨域问题
    OVS-DPDK/虚拟化学习
    2.1.6.15 漏洞利用-smb-RCE远程命令执行
  • 原文地址：https://blog.csdn.net/weixin_52799506/article/details/136492573