secureboot.c

来自「基于h323协议的软phone」· C语言 代码 · 共 1,453 行 · 第 1/3 页

#ifndef NOWP
#define NOWP
#endif
#include <string.h>
#include "event.h"
#include "beptimer.h"
#include "SysDep.h"
#include "stdlib.h"
#include "sockLib.h" 
#include "inetLib.h"
#include <routelib.h>

typedef enum
{
	SET_SUBMASK_STATE,
	SET_IPADDR_STATE,
	SET_GATEWAY_STATE,
	SET_FTPSERVER_STATE,
	SET_USER_STATE,
	SET_PWD_STATE,
	SET_UPDATEFILE_STATE
} UpdateState;

typedef enum
{
	UPDATE_DIGIT_EVENT,
	UPDATE_OK_KEY_EVENT,
	UPDATE_CANCEL_KEY_EVENT,
	UPDATE_TIMEOUT_EVENT,
	UPDATE_NULL_EVENT
} UpdateEvent;

typedef struct prcess_event
{
	int iEvent;
	char* pMsg;
} prcess_event;

typedef int (*f_action)(int* psState, struct prcess_event* psEvent);

typedef struct s_updateblock
{
	unsigned char * fileblock;
	int length;
	struct s_updateblock * next;
} s_updateblock;

#define SECURE_UPDATE_STATE	7
#define SECURE_UPDATE_EVENT	4
/**
* 升级函数的返回状态
*/
#define SECURE_UPDATE_OK				        0		/* 升级文件下载成功 */
#define SECURE_UPDATE_CONN_ERROR		       -1		/* 网络连接错误 */
#define SECURE_UPDATE_PASSWD_ERROR		-2		/* 用户名或者密码错误 */
#define SECURE_UPDATE_FILE_NOTEXIST		-3		/* 文件不存在 */
#define SECURE_UPDATE_NO_SPACE			-4		/* 空间不足 */
#define SECURE_UPDATE_WRITE_ERROR		-5		/* 写Flash错误*/
#define SECURE_UPDATE_INVALID_FILE		-6		/* 无效文件*/
#define SECURE_UPDATE_TOO_LONG                   -7
#define SECURE_UPDATE_ERROR_UNKNOWN	       -8		/* 未知错误 */
#define SECURE_BOORROMSIZE 400 * 1024
#define SECURE_APPSIZE          1300 * 1024

#define SECURE_SYSTEM_UPDATING			"System updating..."
#define SECURE_PLEASE_WAIT				"Please wait..."
#define SECURE_SYSTEM_REBOOTING			"Rebooting..."
#define SECURE_UPDATE_OK_AND_REBOOT1	"Ok!  Please reboot "
#define SECURE_UPDATE_OK_AND_REBOOT2	"the system."
#define SECURE_FTP_CONNECTION_ERROR		"Connection error."
#define SECURE_FTP_INVALID_ID_OR_PIN		"Invalid ID or pin."
#define SECURE_FTP_FILE_NOT_EXIST			"File not exist."
#define SECURE_FTP_SPACE_NOT_ENOUGH		"Space not enough."
#define SECURE_FTP_WRITE_ERROR			"Write error."
#define SECURE_FTP_INVALID_FILE			"Invalid file."
#define SECURE_FTP_FILE_TO_LONG			"File too long."
#define SECURE_FTP_UNKNOWN_ERROR			"Unknown error."


#define SECURE_COLLECT_IP_MAXSIZE			15

void ClearLcd( void );
void WriteLcd( char *msg, int row, int col );
extern void KeyLampMonitor( MSG_Q_ID eventQ );
extern int SpawnTask( char *taskId, FUNCPTR taskProc, char giveMsgQueue,
                int priority, int stackSize );


static int digit_index;
static char digit_set[32];
static NonWrapperMsg* msg;
static char localIPAddr[SECURE_COLLECT_IP_MAXSIZE+1];
static char localSubMask[SECURE_COLLECT_IP_MAXSIZE+1];
static char localGateway[SECURE_COLLECT_IP_MAXSIZE+1];
static char ftpServer[SECURE_COLLECT_IP_MAXSIZE+1];
static char ftpUser[20];
static char ftpPwd[10];
static char updateFile[20];

static char *keyMap[12] = 
{
	"0",
	"1",
	"2abcABC",
	"3defDEF",
	"4ghiGHI",
	"5jklJKL",
	"6mnoMNO",
	"7pqrsPQRS",
	"8tuvTUV",
	"9wxyzWXYZ",
	"*.",
	"#"
};

static char lastDigit = 100, lastIndex = 0;

static char *stateInfo[SECURE_UPDATE_STATE] = 
{
	"Subnet Mask:",
	"IP Address:",
	"Gateway:",
	"FTP Server:",
	"FTP Account:",
	"FTP Password:",
	"Update File:"
};

static int digit_timer = 0;

static int yes = 1;
static int addr_len = sizeof(struct sockaddr_in);
static char * ftp_user_cmd = "USER";
static char * ftp_pass_cmd = "PASS";
static char * ftp_type_cmd = "TYPE";
static char * ftp_port_cmd = "PORT";
static char * ftp_retr_cmd = "RETR";
static char * ftp_quit_cmd = "QUIT";
static unsigned char ftp_request[32];
static unsigned char ftp_reply[3];
static unsigned char ftp_fileblock[1024];

#if 1
#include "rebootLib.h"
#include "sysLib.h"
#endif

static void system_reboot()
{
#if 1
	printf("system rebooting...\n");
	reboot(BOOT_QUICK_AUTOBOOT);
#endif

}

static void convertString2Int(char *digit_set, unsigned int *num)
{
	char temp[4];
	temp[3] = (digit_set[12]-'0')*100+(digit_set[13]-'0')*10+(digit_set[14]-'0');
	temp[2] = (digit_set[8]-'0')*100+(digit_set[9]-'0')*10+(digit_set[10]-'0');
	temp[1] = (digit_set[4]-'0')*100+(digit_set[5]-'0')*10+(digit_set[6]-'0');
	temp[0] = (digit_set[0]-'0')*100+(digit_set[1]-'0')*10+(digit_set[2]-'0');
	*num = temp[3] + temp[2]*0x100 + temp[1]*0x10000 + temp[0]*0x1000000; 
}

/*******************************************************
* Part UPDATE_COMMON
*******************************************************/
static s_updateblock * ConstructBlockNode(void)
{
	s_updateblock * ptr_block;
	if ((ptr_block = (s_updateblock *) malloc(sizeof(s_updateblock))) == NULL)
	{
		return NULL;
	}
	if ((ptr_block -> fileblock = (unsigned char *) malloc(1024)) == NULL)
	{
		free(ptr_block);
		return NULL;
	}
	memset(ptr_block -> fileblock, 0, 1024);
	ptr_block -> length = 0;
	ptr_block -> next = NULL;
	return ptr_block;
}

static void ClearUpdateBlock(s_updateblock * ptr_updatefile)
{
	s_updateblock * p, * q;
	
	printf("Clear Update Node...\n");
	
	if (ptr_updatefile == NULL)
	{
		return;
	}
	for (p = ptr_updatefile; p != NULL; p = q)
	{
		free(p -> fileblock);
		q = p -> next;
		free(p);
	}	
	return;
}

static void CheckUpdateBlock(s_updateblock * ptr)
{
	s_updateblock * p;
	int i;
	
	for (p = ptr, i = 0; p != NULL; p = p -> next, i++)
	{
	}
	printf("There are %d blocks in the Update file\n", i);
	return;
}

static int UpdateFlashRom(s_updateblock * ptr_updatefile, int count, int fileT)
{
	s_updateblock * p;
	unsigned short * pAddr = (unsigned short *) COMPRESSED_IMAGE_ADDR;
	unsigned char * ptr;
	int offset = 0;

	CheckUpdateBlock(ptr_updatefile);

	if (fileT == 1)
	{
		if (count > SECURE_BOORROMSIZE)
		{
			printf("file too long!\n\n");
			return SECURE_UPDATE_TOO_LONG;
		}
		if ((ptr = (unsigned char *) malloc(300 * 1024)) == NULL)
		{
			printf("error malloc boot\n");
			return -1;
		}
		for (p = ptr_updatefile; p != NULL; p = p -> next)
		{
			memcpy(ptr + offset, p -> fileblock, p -> length);
			offset += p -> length;
		}
		Program_Boot_Flash_Mem((unsigned short *) ptr, offset);
		free(ptr);
	}
	else if (fileT == 2)
	{
		if (count > SECURE_APPSIZE)
		{
			printf("file too long!\n\n");
			return SECURE_UPDATE_TOO_LONG;
		}
		if (count > COMPRESSED_IMAGE_SIZE)
		{
			printf("The Version is too Large!\n");
			return SECURE_UPDATE_NO_SPACE;
		}
		
		SetVersionUpdateFlag ( 0xff );/*2004-7-12 fujiangdong update begin*/
		
		if (Erase_Version_Flash_Mem () != OK)
		{
			printf("Erase Flash ROM ERROR!\n");
			return SECURE_UPDATE_WRITE_ERROR;
		}
		for (p = ptr_updatefile; p != NULL && count > 0; p = p -> next)
		{
			if (Program_Version_Flash_Mem((unsigned short *) p -> fileblock, pAddr, p -> length) != OK)
			{
				printf("Write Flash ROM ERROR!\n");
				return SECURE_UPDATE_WRITE_ERROR;
			}
			pAddr += p -> length / 2;
			count -= p -> length / 2;
		}
             SetVersionUpdateFlag ( 0x32 );/*2004-7-12 fujiangdong update ok*/
	}
	printf("Write Flash OK.\n");

	return SECURE_UPDATE_OK;
}

int FtpCommand(int sockfd, char * cmd, const char * param)
{
	int len;
	memset(ftp_request, 0, 32);
	len = sprintf(ftp_request, "%s %s\r\n", cmd, (param == NULL)? "" : param);
	#ifdef __FTP_DEBUG
	printf("%s %s\r\n", cmd, (param == NULL)? "" : param);
	#endif
	return send(sockfd, ftp_request, len, 0);
}

int FtpRecvReply(int sockfd)
{
	int len;
	char data;
	if ((len = recv(sockfd, ftp_reply, 3, 0)) <= 0)
	{
		memset(ftp_reply, 0, sizeof(ftp_reply));
		return -1;
	}
	while (data != '\n')
	{
		if ((len = recv(sockfd, &data, 1, 0)) <= 0)
		{
			memset(ftp_reply, 0, sizeof(ftp_reply));
			return -1;
		}
	}
	return len;
}

/**
* 打开控制连接
*/
int FtpOpenCtrlConn(unsigned int server_ip)
{
	struct sockaddr_in server_addr;
	int ctrl_fd;
	struct timeval timeVal = {20, 0};
	
	#if 1
	printf("Begin FtpOpenCtrlConn\n");
	#endif
	if ((ctrl_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		printf("create control socket\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	if (setsockopt(ctrl_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof(yes)) < 0)
	{
		close(ctrl_fd);
		printf("setsockopt ctrl socket\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	memset(&server_addr, '\0', addr_len);
	server_addr.sin_family = AF_INET;
	server_addr.sin_len = addr_len;
	server_addr.sin_port = htons(21);
	server_addr.sin_addr.s_addr = htonl(server_ip);

	printf("try connect\n");
	if (connectWithTimeout(ctrl_fd, (struct sockaddr *) &server_addr, addr_len, &timeVal) < 0)
	{
		close(ctrl_fd);
		printf("connect to ctrl\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	/**
	* Reply should be "220"
	*/
	if (FtpRecvReply(ctrl_fd) < 0 || ftp_reply[0] != '2')
	{
		close(ctrl_fd);
		printf("error while open control connection\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	else
	{
		printf("connected to server %u.%u.%u.%u\n", 
				(unsigned char) (server_ip >> 24),
				(unsigned char) (server_ip >> 16),
				(unsigned char) (server_ip >> 8),
				(unsigned char) (server_ip >> 0)
				);
	}
	return ctrl_fd;
}

/**
* 登录FTP服务器
*/
int FtpLoginServer(int ctrl_fd, const char * user, const char * pass)
{
	printf("FtpLoginServer\n");
	/**
	* Command USER
	*/
	if (FtpCommand(ctrl_fd, ftp_user_cmd, user) < 0)
	{
		printf("USER command error\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	/**
	* USER reply should be "331"
	*/
	if (FtpRecvReply(ctrl_fd) < 0 || ftp_reply[0] != '3')
	{
		if (ftp_reply[0] == '2')
		{
			printf("%.3s: user %s logging, needn't pass\n", ftp_reply, user);
			return SECURE_UPDATE_OK;
		}
		printf("error recv USER\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	else
	{
		printf("%.3s: user %s logging\n", ftp_reply, user);
	}
	/**
	* Command PASS
	*/
	if (FtpCommand(ctrl_fd, ftp_pass_cmd, pass) < 0)
	{
		printf("PASS command error\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	/**
	* PASS reply should be "230"
	*/
	for (;;)
	{
		if (FtpRecvReply(ctrl_fd) < 0)
		{
			printf("error recv PASS\n");
			return SECURE_UPDATE_CONN_ERROR;
		}
		else if (ftp_reply[0] == '2')
		{
			printf("%.3s: user %s logged in\n", ftp_reply, user);
			return SECURE_UPDATE_OK;
		}
		else if (ftp_reply[0] == '3')
		{
			printf("%.3s: user %s\n", ftp_reply, user);
			continue;
		}
		else
		{
			printf("PASS or USER error\n");
			return SECURE_UPDATE_PASSWD_ERROR;
		}
	}
}

/**
* 打开数据连接
*/
int FtpInitDataConn(unsigned int server_ip, unsigned short * ptr_port)
{
	struct sockaddr_in client_addr;
	int data_fd;
	int len = addr_len;

	printf("FtpInitDataConn\n");

	if ((data_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
	{
		printf("create data socket\n");
		return SECURE_UPDATE_CONN_ERROR;
	}	
	if (setsockopt(data_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &yes, sizeof(yes)) < 0)
	{
		close(data_fd);
		printf("setsockopt data socket\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	
	memset(&client_addr, '\0', addr_len);
	client_addr.sin_family = AF_INET;
	client_addr.sin_len = addr_len;
	client_addr.sin_port = 0;
	client_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	
	if (bind(data_fd, (struct sockaddr *) &client_addr, addr_len) < 0)
	{
	    	printf("bind data socket\n");
		close(data_fd);
		return SECURE_UPDATE_CONN_ERROR;
	}
	if (listen(data_fd, 1) < 0)
	{
		printf("listen on data socket\n");
		close(data_fd);
		return SECURE_UPDATE_CONN_ERROR;
	}
	if (getsockname(data_fd, (struct sockaddr *) &client_addr, &len) < 0)
	{
		printf("getsockname\n");
		close(data_fd);
		return SECURE_UPDATE_CONN_ERROR;