secureboot.c

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

	}
	*ptr_port = ntohs(client_addr.sin_port);
	printf("client port %u\n", *ptr_port);
	return data_fd;
}

int FtpPrepareTransfer(int ctrl_fd, unsigned short port)
{
	unsigned char port_data[32];
	unsigned int i_ip;
	/**
	* Command TYPE
	*/
	if (FtpCommand(ctrl_fd, ftp_type_cmd, "I") < 0)
	{
		printf("TYPE I command error\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	/**
	* PASS reply should be "200"
	*/
	if (FtpRecvReply(ctrl_fd) < 0 || ftp_reply[0] != '2')
	{
		printf("error recv TYPE I\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	else
	{
		printf("%.3s: TYPE set to binary\n", ftp_reply);
	}
	/**
	* Command PORT
	*/
	memset(port_data, 0, 32);
	if (ifAddrGet("IPPhone0", port_data) != 0)
	{
		printf("error get ip\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	i_ip = ntohl(inet_addr(port_data));
	memset(port_data, 0, 32);
	/**
	* 获得自己的IP
	*/
	sprintf(port_data, "%u,%u,%u,%u,%u,%u", 
		(unsigned char) (i_ip >> 24), 
		(unsigned char) (i_ip >> 16),
		(unsigned char) (i_ip >> 8),
		(unsigned char) (i_ip),
		(unsigned char) (port >> 8),
		(unsigned char) port
		);
	if (FtpCommand(ctrl_fd, ftp_port_cmd, port_data) < 0)
	{
		printf("PORT command error\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	/**
	* PORT reply should be "200"
	*/
	if (FtpRecvReply(ctrl_fd) < 0 || ftp_reply[0] != '2')
	{
		printf("error recv PORT\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	else
	{
		printf("%.3s: PORT set to %u.%u.%u.%u.%u.%u\n", ftp_reply,
		(unsigned char) (i_ip >> 24), 
		(unsigned char) (i_ip >> 16),
		(unsigned char) (i_ip >> 8),
		(unsigned char) (i_ip),
		(unsigned char) (port >> 8),
		(unsigned char) port
		);
	}
	return SECURE_UPDATE_OK;
}

int FtpGetUpdate(int ctrl_fd, int data_fd, const char * filename)
{
	int transfer_fd;
	int len = sizeof(struct sockaddr);
	struct sockaddr_in addr;
	s_updateblock update_block; 
	s_updateblock * ptr_block;
	int count, result;
	int fileType;
int kkk = 0;
	/**
	* Command RETR
	*/
	if (FtpCommand(ctrl_fd, ftp_retr_cmd, filename) < 0)
	{
		printf("RETR command error\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	/**
	* RETR reply should be "150"
	*/
	if (FtpRecvReply(ctrl_fd) < 0)
	{
		printf("error recv RETR\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	else if (ftp_reply[0] != '1')
	{
		printf("RETR file error\n");
		return SECURE_UPDATE_FILE_NOTEXIST;
	}
	else
	{
		printf("%.3s: RETR success\n", ftp_reply);
	}
	/**
	* accept server connect
	*/
	if ((transfer_fd = accept(data_fd, (struct sockaddr *) &addr, &len)) < 0)
	{
		printf("accept server\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	printf("server port %u\n", ntohs(addr.sin_port));
	
	count = 0;
	update_block.next = NULL;
	ptr_block = & update_block;
	fileType = 0;
	/**
	* get data
	*/
	while ((len = recv(transfer_fd, ftp_fileblock, 1024, 0)) > 0)
	{
		/*判断文件头是否有效*/
		if ( count == 0 )
		{
			if (len > 4)
			{
#include "phonerecord.h"		

#ifndef MAX_PHONE_BOOK
#define MAX_PHONE_BOOK	200
#endif

#ifndef MAX_CALL_RECORD
#define MAX_CALL_RECORD	40
#endif

#ifndef BOOT_LINE_SIZE
#define BOOT_LINE_SIZE 	255
#endif

#ifndef CONFIG_LOCATION
#define CONFIG_LOCATION	((BOOT_LINE_SIZE + 1023) & ~1023)	/* Location of configuration items */
#endif

				struct s_config config;
				
				/*int sizePhoneBook = sizeof(struct s_phonebook) * (MAX_PHONE_BOOK+1);
				int sizeCallRecord = sizeof(struct s_callrecord) * (MAX_CALL_RECORD+1);
				int sizePhoneConfig = sizeof(struct s_config);
				int offset = CONFIG_LOCATION + sizePhoneBook + sizeCallRecord*3;
				memset(&config, 0, sizeof(struct s_config));
				if (sysNvRamGet((char *) &config, sizePhoneConfig - 1, offset) != OK)
				{
					printf("read phone config error. load default param!\n");
				*/	config.bootFileHead[0] = 0xFE;
					config.bootFileHead[1] = 0x03;
					config.bootFileHead[2] = 0x00;
					config.bootFileHead[3] = 0xEA;
					config.appFileHead[0] = 0x08;
					config.appFileHead[1] = 0x78;
					config.appFileHead[2] = 0x9C;
					config.appFileHead[3] = 0xDC;
				/*}*/
				if ( memcmp(ftp_fileblock, config.bootFileHead, 4) == 0 )
					fileType = 1;
				if ( memcmp(ftp_fileblock, config.appFileHead, 4) == 0 )
					fileType = 2;
			}
			if (fileType != 1 && fileType != 2)
			{
				printf("file type error!\n\n");
				return SECURE_UPDATE_INVALID_FILE;
			}
		}
		kkk++;
		if ((count + len) > COMPRESSED_IMAGE_SIZE ||
			(ptr_block -> next = ConstructBlockNode()) == NULL)
		{
			printf("count + len = %d\n", count+len);
			printf("COMPRESSED_IMAGE_SIZE = %d\n", COMPRESSED_IMAGE_SIZE);
			printf("kkk = %d\n", kkk);
			printf("file too long, can't malloc\n");
			/* 释放内存 */
			ClearUpdateBlock(update_block.next);
			return SECURE_UPDATE_NO_SPACE;;
		}
		ptr_block = ptr_block -> next;
		memcpy(ptr_block -> fileblock, ftp_fileblock, len);
		ptr_block -> length = len;
		count += len;
	}
	if (count == 0)
	{
		printf("file size is 0!!!\n\n");
		return SECURE_UPDATE_INVALID_FILE;
	}
	/**
	* RETR reply after transfer should be "226"
	*/
	if (FtpRecvReply(ctrl_fd) < 0 || ftp_reply[0] != '2')
	{
		printf("error while transfer\n");
		/* 释放内存 */
		ClearUpdateBlock(update_block.next);
		return SECURE_UPDATE_CONN_ERROR;
	}
	else
	{
		printf("%.3s: transfer completed\n", ftp_reply);
		printf("file %s %d bytes got\n", filename, count);
	}
	
	close(data_fd);
	FtpQuitServer(ctrl_fd);
	close(ctrl_fd);
	
	/* 写入Flash */
	result = UpdateFlashRom(update_block.next, count, fileType);
	ClearUpdateBlock(update_block.next);
	
	if (result == SECURE_UPDATE_OK)
	{
		printf("Update OK.\n");
	}

	return result;
}

int FtpQuitServer(int ctrl_fd)
{
	/**
	* Command QUIT
	*/
	if (FtpCommand(ctrl_fd, ftp_quit_cmd, NULL) < 0)
	{
		printf("QUIT error\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	/**
	* QUIT reply should be "221"
	*/
	if (FtpRecvReply(ctrl_fd) < 0 || ftp_reply[0] != '2')
	{
		printf("error recv QUIT\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	else
	{
		printf("%.3s: quit from server\n", ftp_reply);
	}
	return SECURE_UPDATE_OK;
}

/*******************************************************
* Part FTP_UPDATE
*******************************************************/
int FtpUpdate()
{
	int ctrl_fd, data_fd;
	unsigned short data_port;
	int result;
	unsigned int ftpserver;

	printf("Begin FTP Update...\n");
	printf("fujiangdong: ftp server = %s\n", ftpServer);
	printf("fujiangdong: ftp user = %s\n", ftpUser);
	printf("fujiangdong: ftp pass = %s\n", ftpPwd);
	printf("fujiangdong: update file = %s\n", updateFile);
	convertString2Int(ftpServer, &ftpserver);
	printf("fujiangdong: ftp server ip = %x\n", ftpserver);
	if ((ctrl_fd = FtpOpenCtrlConn(ftpserver)) < 0)
	{
		printf("can not connect to server\n");
		return SECURE_UPDATE_CONN_ERROR;
	}
	if ((result = FtpLoginServer(ctrl_fd, 
		(strlen(ftpUser)==0?"anonymous":ftpUser), 
		ftpPwd)) 
		< 0)
	{
		close(ctrl_fd);
		printf("login error\n");
		return result;
	}	

	if ((data_fd = FtpInitDataConn(ftpServer, &data_port)) < 0)
	{
		close(ctrl_fd);
		printf("error open data connection\n");
		return data_fd;
	}

	if ((result = FtpPrepareTransfer(ctrl_fd, data_port)) < 0)
	{
		close(data_fd);
		close(ctrl_fd);
		printf("error prepare for transfer\n");
		return result;
	}
	if ((result = FtpGetUpdate(ctrl_fd, data_fd, updateFile)) < 0)
	{
		close(data_fd);
		close(ctrl_fd);
		printf("error get ftp update file\n");
		return result;
	}
	/*close(data_fd);
	FtpQuitServer(ctrl_fd);
	close(ctrl_fd);*/
	
	printf("FTP Update OK.\n");

	return SECURE_UPDATE_OK;
}

static void showInputInfo(char *info, char *old)
{
	lcdCursorPos pos;
	ClearLcd();
	WriteLcd(info, 0, 0);
	if (old != NULL && old[0] != '\0')
	{
		WriteLcd(old, 1, 0);
		LcdDShowCursor(TRUE);
		strcpy(digit_set, old);
		digit_index = strlen(old);
		return;
	}
	else
	{
		pos.row = 1;
		pos.col = 0;
		lcdSetCurPos(pos);
		LcdDShowCursor(TRUE);
		memset(digit_set, 0, sizeof(digit_set));
		digit_index = 0;
	}
}

static void doUpdate(int* psState)
{
	int ret;
	ClearLcd();
	WriteLcd(SECURE_SYSTEM_UPDATING, 0, 0);
	WriteLcd(SECURE_PLEASE_WAIT, 1, 0);
	
	ret = FtpUpdate();
	ClearLcd();
	WriteLcd(SECURE_PLEASE_WAIT, 0, 0);
	switch(ret)
	{
		case SECURE_UPDATE_OK:
			WriteLcd(SECURE_UPDATE_OK_AND_REBOOT1, 0, 0);
			WriteLcd(SECURE_UPDATE_OK_AND_REBOOT2, 1, 0);
			taskDelay(300);
			ClearLcd();
			WriteLcd(SECURE_SYSTEM_REBOOTING, 0, 0);
			system_reboot();
			break;
			
		case SECURE_UPDATE_CONN_ERROR:
			WriteLcd(SECURE_FTP_CONNECTION_ERROR, 1, 0);
			taskDelay(300);
			*psState = SET_FTPSERVER_STATE;
			showInputInfo(stateInfo[SET_FTPSERVER_STATE], ftpServer);
			break;
			
		case SECURE_UPDATE_PASSWD_ERROR:
			WriteLcd(SECURE_FTP_INVALID_ID_OR_PIN, 1, 0);
			taskDelay(300);
			*psState = SET_PWD_STATE;
			showInputInfo(stateInfo[SET_PWD_STATE], ftpPwd);
			break;
			
		case SECURE_UPDATE_FILE_NOTEXIST:
		case SECURE_UPDATE_NO_SPACE:
		case SECURE_UPDATE_WRITE_ERROR:
		case SECURE_UPDATE_INVALID_FILE:
		case SECURE_UPDATE_TOO_LONG:
		default:
			WriteLcd(SECURE_FTP_UNKNOWN_ERROR, 1, 0);
			taskDelay(300);
			*psState = SET_UPDATEFILE_STATE;
			showInputInfo(stateInfo[SET_UPDATEFILE_STATE], updateFile);
	}
}

static void cancel_key_process(char *info)
{
	if (digit_index <= 0)
		return;

	digit_set[--digit_index] = '\0';
	ClearLcd();
	WriteLcd(info, 0, 0);
	WriteLcd(digit_set, 1, 0);
	LcdDShowCursor(TRUE);
	return;
}

static int doCancel(int* psState, int curState, char *info)
{
	if (digit_index <= 0)
	{
		*psState = curState-1;
		showInputInfo(stateInfo[curState-1], info);
		return 0;
	}
	cancel_key_process(stateInfo[curState]);
	return 0;
}

static int timeout_event_process(struct prcess_event* psEvent, int maxLen)
{
	lcdCursorPos pos;
	msg = (NonWrapperMsg *)psEvent->pMsg;
	if (msg->digit != digit_timer)
		return 0;

	pos = lcdGetCursorPos();
	pos.col++;
	lcdSetCurPos(pos);	
	lastDigit = 100;
	lastIndex = 0;
	if (digit_index < maxLen)
		digit_index++;
	return 0;	
}

static int collectIpDigit(int* psState, struct prcess_event* psEvent)
{
	char digit;

	msg = (NonWrapperMsg *) psEvent->pMsg;
	if (msg->digit == 11 || digit_index >= SECURE_COLLECT_IP_MAXSIZE)
		return 0;

	digit = msg->digit + '0';
	if ((digit_index+1) % 4 == 0)
	{
		if (msg->digit != 10)
			return 0;
		digit = '.';
	}
	else if (msg->digit == 10)
	{
		return 0;
	}
	lcdPutCharRel(digit);
	LcdDShowCursor(TRUE);
	digit_set[digit_index] = digit;
	digit_index++;
	digit_set[digit_index] = '\0';
	return 0;

}

static void formatIPStr(char *oldStr, char *newStr)
{
	char temp[4];
	temp[3] = (oldStr[12]-'0')*100+(oldStr[13]-'0')*10+(oldStr[14]-'0');
	temp[2] = (oldStr[8]-'0')*100+(oldStr[9]-'0')*10+(oldStr[10]-'0');
	temp[1] = (oldStr[4]-'0')*100+(oldStr[5]-'0')*10+(oldStr[6]-'0');
	temp[0] = (oldStr[0]-'0')*100+(oldStr[1]-'0')*10+(oldStr[2]-'0');
	sprintf(newStr, "%d.%d.%d.%d", temp[0], temp[1], temp[2], temp[3]);
}

static int setupNetwork(int* psState)
{
	char ip[16];
	unsigned int mask;
	char gateway[16];