基于搜索协议实现工业设备升级

目录

1、背景引入

2、技术分析

 3、过程概述

4、服务器端流程

5、客户端流程

6、效果展示 

7、源码 

7.1 master（主控）

7.2 device（设备）

8、注意事项

1、背景引入

        在工业生产中，设备的升级和维护是非常重要的环节。随着技术的不断进步，工厂设备通常需要定期进行软件或固件的升级，以确保其性能、安全性和功能的持续改进。在这一过程中，文件传输是一个关键的步骤，因为升级文件的准确、高效地传输直接影响着设备升级的成功与否。

        在工业环境中，设备通常会连接到一个局域网中，并且可能分布在不同的位置。因此，为了实现设备升级，需要一种可靠的网络通信机制，能够让设备发现服务器上的升级文件，并将文件安全地传输到设备中进行应用。

        UDP（用户数据报协议）和TCP（传输控制协议）是两种常用的网络通信协议，它们分别适用于不同的场景。UDP适用于广播和简单的数据传输，而TCP适用于建立可靠的连接并进行大规模数据传输。

        因此，基于UDP和TCP模拟工厂设备升级过程中的文件传输，有助于理解和展示工业设备升级过程中的网络通信原理和流程。

2、技术分析

• UDP：UDP（用户数据报协议）用于在局域网内广播消息，以便设备能够发现服务器并获取升级文件的信息。
• TCP：TCP（传输控制协议）用于建立可靠的连接，并传输升级文件的数据。
• 文件IO：通过文件I/O，程序能够从文件中读取数据，或者将数据写入文件。可以将程序中的数据持久化到文件中，以便在程序关闭后能够保存数据。
• 并发服务：三种方法使得TCP具有并发处理的能力。分别是：多线程、多进程、IO多路复用（select、poll、epoll）。
•  数据库：嵌入式常用的轻量级小型数据库（sqlite3），用来存储每次升级的设备信息以及每次升级的时间信息等，便于后期管理以及维护。

 3、过程概述

1. 服务器端创建UDP套接字并设置允许广播；
2. 服务器端发送广播消息，告知设备有升级文件可用；
3. 客户端接收到广播消息后，提取服务器地址和端口信息，并使用TCP连接请求连接服务器；
4. 服务器端并发接受客户端的连接请求，并开始传输文件；
5. 客户端接收文件数据，并应用升级。

4、服务器端流程

1. 创建UDP套接字并设置允许广播；
2. 件可发送广播消息，告知设备有升级文用；
3. 创建TCP套接字并绑定端口；
4. 监听客户端连接请求；
5. 接受客户端连接请求；
6. 读取升级文件并发送给客户端；
7. 关闭客户端连接（心跳包）。

5、客户端流程

1. 创建UDP套接字并绑定端口；
2. 接收广播消息；
3. 创建TCP套接字并连接服务器；
4. 接收文件数据并保存到本地文件；
5. 关闭TCP连接。

6、效果展示 

7、源码 

7.1 master（主控）

#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/ip.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sqlite3.h>
#include <time.h>
#include <sys/stat.h>

int data_base(char *);

//线程函数处理与每一台设备进行数据发送
void *handler(void *arg)
{
	//获取文件描述符
	int acceptfd = (int)arg;
	printf("acceptfd = %d\n", acceptfd);
	int fd;
	//打开要发送的文件，（要是想通过命令行传参，你可以给线程传入结构体）
	if ((fd = open("new.txt", O_RDONLY)) < 0)
	{
		perror("open:");
		return NULL;
	}
	char buf[64] = {0};
	while (1)
	{
		int n = read(fd, buf, 64);
		if (n < 0)
		{
			perror("read err");
			return NULL;
		}
		if (n == 0)
			break;
		//发送数据给设备
		if (send(acceptfd, buf, n, 0) < 0)
		{
			perror("send err");
			return NULL;
		}
	}
	printf("线程处理结束\n");
	close(acceptfd);
	close(fd);
	pthread_exit(NULL);
}

int main(int argc, char *argv[])
{
	//UDP
	int sockfd;
	//搜索协议套接字
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
	{
		perror("socket err:");
		return -1;
	}
	int tv = 1;
	//发送方设置为发送广播
	if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &tv, sizeof(tv)) < 0)
	{
		perror("setsockopt err:");
		return -1;
	}
	struct sockaddr_in brandaddr;
	//填充结构体
	brandaddr.sin_family = AF_INET;
	brandaddr.sin_port = htons(8888);
	brandaddr.sin_addr.s_addr = inet_addr("192.168.0.255");
	int len_bra = sizeof(brandaddr);

	printf("我已经准备发送\n");
	int ret;
	//以广播的形式发送这条信息。
	ret = sendto(sockfd, "connect", 8, 0, (struct sockaddr *)&brandaddr, len_bra);
	if (ret < 0)
	{
		perror("sendto err:");
		return -1;
	}
	ssize_t num;
	printf("我已经发送完成\n");

	//TCP
	int decfd;
	//流式套接字
	if ((decfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		perror("socket err:");
		return -1;
	}
	int optval = 1;
	//设置地址重用
	setsockopt(decfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
	//绑定
	struct sockaddr_in ser_addr;
	//填充服务器的结构体
	ser_addr.sin_family = AF_INET;
	ser_addr.sin_port = htons(8888); //
	ser_addr.sin_addr.s_addr = inet_addr("0.0.0.0");
	int len_ser = sizeof(ser_addr);

	//绑定
	if (bind(decfd, (struct sockaddr *)&ser_addr, len_ser) < 0)
	{
		perror("bind err is:");
		return -1;
	}
	//启动监听，变为被动打开
	if (listen(decfd, 5) < 0)
	{
		perror("listen err:");
		return -1;
	}
	int dat = data_base(argv[1]);
	if(dat)//判断数据库的操作
	{
		printf("database is err");
		return -1;
	}
	struct sockaddr_in dev_addr;
	while (1)
	{
		char buf[4] = {};
		//接收确认信息
		num = recvfrom(sockfd, buf, 4, 0, (struct sockaddr *)&dev_addr, &len_bra);
		if (strncmp(buf, "yes", 3) == 0)
		{
			printf("wait accept\n");
			int acceptfd;
			//链接建立之后的信息交互文件描述符
			if ((acceptfd = accept(decfd, (struct sockaddr *)&dev_addr, &len_ser)) < 0)
			{
				perror("accept err:");
				return -1;
			}
			printf("链接成功 %s %s %d %p\n", inet_ntoa(dev_addr.sin_addr), buf, acceptfd, &acceptfd);
			pthread_t tid;
			if (pthread_create(&tid, NULL, handler, (void *)acceptfd))
			{
				perror("pthread create err:");
				break;
			}
		}
	}
	close(sockfd);
	close(decfd);
	return 0;
}


int data_base(char *file)
{
	sqlite3 *db = NULL; //防止野指针
	if (sqlite3_open("./my.db", &db) != 0)
	{
		//不能用perror， perror只能打印操作系统级别的错误  sqlite是独立的
		//fprintf代表 格式化输出到流内
		fprintf(stderr, "sqlite_open is err: %s\n", sqlite3_errmsg(db));
		//printf("sqlite3_open is err: %s\n",sqlite3_errmsg(db);
		return -1;
	}
	printf("create is success\n");
	char *errmsg = NULL;
	if (sqlite3_exec(db, "create table version(time char,file_name char,size int);",
					 NULL, NULL, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "create table is err: %s\n", errmsg);
	}
	printf("table is success\n");

	time_t tim;
	struct tm *localtim = NULL;
	tim = time(NULL);
	localtim = localtime(&tim);
	int year = localtim->tm_year + 1900;
	int mon = localtim->tm_mon;
	int day = localtim->tm_mday;
	int hour = localtim->tm_hour;
	int min = localtim->tm_min;
	int sec = localtim->tm_sec;
	char timebuf[32]={0};
	sprintf(timebuf, "%d-%02d-%02d %02d:%02d:%02d", year, mon, day, hour, min, sec);
	struct stat buf;
	stat(file, &buf);
	char sql[128] = {0};
	sprintf(sql, "insert into version values(\"%s\",\"%s\",%ld);", timebuf, file, buf.st_size);
	if (sqlite3_exec(db, sql, NULL, NULL, &errmsg) != SQLITE_OK)
	{
		fprintf(stderr, "create table is err: %s\n", errmsg);
		return -1;
	}
	return 0;
}

7.2 device（设备）

 #include <stdio.h>
#include <string.h>
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int main(int argc, char *argv[])
{
	//当作搜索协议使用
	int sockfd;
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)//先打开数据包式套接字
	{
		perror("socket err:");
		return -1;
	}
    int optval = 1;
	//用于本地测试并发的。主要是设置地址重用
	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
	
	struct sockaddr_in addr;
	//填充结构体
	addr.sin_family = AF_INET;
	addr.sin_addr.s_addr = inet_addr("192.168.0.255");
	// addr.sin_addr.s_addr = INADDR_ANY;
	addr.sin_port = htons(8888);
	socklen_t addrlen = sizeof(addr);
	//绑定addr
	if (bind(sockfd, (struct sockaddr *)&addr, addrlen) < 0)
	{
		perror("bind err:");
		goto err;
	}
	ssize_t num;
	char buf[8] = {0};
	//接受对端ip、port等的结构体
	struct sockaddr_in clientaddr;
	//接受内容，之后比较接受到的内容
	num = recvfrom(sockfd, buf, 8, 0, (struct sockaddr *)&clientaddr, &addrlen);
    if(num <0)
    {
        perror("recvfrom err");
		goto err;
    }
	if (strncmp(buf, "connect", 7) != 0)
	{
		printf("quit\n");
		goto err;
	}
    
	sendto(sockfd, "yes", 4, 0, (struct sockaddr *)&clientaddr, addrlen);
	printf("回复完成\n");
	//搜索协议生命周期结束
    close(sockfd);

	int decfd;
	//新的流式套接字
	if ((decfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		perror("socket err:");
		return -1;
	}
    int optva = 1;
	//设置地址重用，为了测试并发
	setsockopt(decfd, SOL_SOCKET, SO_REUSEADDR, &optva, sizeof(optval));
	//定义结构体，用来接受服务器发送的文件信息等。保证可靠。
	struct sockaddr_in dev_addr;
	dev_addr.sin_family = AF_INET;
	dev_addr.sin_port = htons(8888); //
	dev_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	int len = sizeof(dev_addr);
    //请求链接服务器
	if (connect(decfd, (struct sockaddr *)&dev_addr, len) < 0)
	{
		perror("connect err:");
		close(decfd);
		return -1;
	}
	printf("connet success\n");
	int fd;
	//打开文件，用于后续接收数据
	if ((fd = open(argv[1], O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
	{
		perror("open:");
		close(decfd);
		return -1;
	}
	char buff[64] = {0};
	while (1)
	{
		int ret;
		ret = recv(decfd, buff, 64, 0);
		if (ret < 0)
		{
			perror("recv err:");
			return -1;
		}
		else if (ret > 0)
		{
			//写入文件
			write(fd, buff, ret);
			memset(buff, 0, 64);
		}
		else
		{
			break;
		}
	}
	printf("Upgrade successful\n");
    close(decfd);
	close(fd);
	return 0;
err:
	close(sockfd);
	return 0;
}

8、注意事项

        使用多线程的时候，因为线程的特性，不得不使用线程栈保存文件描述符来保证并发的完成。但是线程传参的时候，传入地址导致传输的地址是同一个。这是因为变量的定义在局部中，结束之后销毁，再次创建变量，编译器可能会再次为变量分配这块内存地址。导致问题一直无法解决。