tftpupgrade.c

wi－fi手机原代码

	{
		taskDelay(500);
		hp = resolvGetHostByName (pHostName, pbuf, 512);
		if (NULL == hp)
		{
			free(pbuf);
			return ERROR;
		}
	}
	inet_ntoa_b(((struct in_addr *) hp->h_addr)[0], pIpAddr);
	free(pbuf);

	return OK;
}

VOID test_resolv(char *pHostName)
{
	char tp[INET_ADDR_LEN+1];

	memset(tp,0,INET_ADDR_LEN);
	TFTPResolv(pHostName,tp);

	TFTPLOG("!!!!!test_resolv %s\n",tp);
}
//STATUS TFGetConfigFile()
#if 0
static int getErrNo(char* pbuf)
{
	char *pDest,*pDest1;
	char arHexStr[8+1];
	
	pDest1 = arHexStr;
	pDest = strstr(pbuf,"0x");
	if (NULL == pDest)
		return 0;
	pDest += 2;
	while (*pDest>='0' && *pDest <= 'f')
	{
		*pDest1 ++ = *pDest ++; 
	}
	*pDest1 = '\0';
	return strtol(arHexStr,NULL,16);
}
#endif

VOID setCurTFTPPort(int iPort)
{
	g_iTftpCurPort = iPort;
}

int getCurTFTPPort()
{
	return g_iTftpCurPort;
}

int getNextTFTPPort(int iPort)
{
	int nextPort;
	
	if (69 == iPort)
	{
		nextPort = 21;
		if (nextPort == g_iTftpCurPort)
			return 0;
		return nextPort;
	}
	if (21 == iPort)
	{
		nextPort = 2400;
		if (nextPort == g_iTftpCurPort)
			return 0;
		return nextPort;
	}
	if (2400 == iPort)
	{
		nextPort = 69;
		if (nextPort == g_iTftpCurPort)
			return 0;
		return nextPort;
	}
	return 0;
}

static STATUS TCheckSum(unsigned char *pData,int iDataLen)
{
	if (0 == iDataLen)
		return ERROR;
	
	return OK;
}
static STATUS TCreateLoctParams(char **ppDest,char* pSrc)
{
	if (*ppDest != NULL)
		free(*ppDest);
	*ppDest = malloc(strlen(pSrc)+1);
	if (NULL == *ppDest)
	{
		TFTPLOG("TFTP TCreateLoctParams malloc error\n");
		return ERROR;
	}
	strcpy(*ppDest,pSrc);
	return OK;
}

static STATUS TRestoreConfigLoct()
{
#if 0
	if (TRUE == TFTPConfigSet(LOCT_TFTP_CurCfgFileName,g_TFTPLocationParams.pConfigFileName))
	{
		return ERROR;
	}

	TFTPConfigSave();
#endif
	return OK;
}

static STATUS TActiveConfigParams(unsigned char *pData,int iDataLen)
{
	CFG_ITEM_S *pCfgItem;
	int i;
	int iItemCount;
	char stg[128+1];
	BOOLEAN bConfigChanged=FALSE;
	
	iItemCount = iDataLen;
	pCfgItem = (CFG_ITEM_S *)pData;
	for (i=0;i<iItemCount;i++)
	{
		if (TRUE == TFTPConfigGet(pCfgItem[i].uiLoctIdx,(void *)stg))
		{
			TFTPLOG("TActiveConfigParams TFTPConfigGet fail\n");
			continue;
		}
		if (strcmp(stg,(char *)pCfgItem[i].arData) == 0)
		{
			continue;
		}

		if (TRUE == TFTPConfigSet(pCfgItem[i].uiLoctIdx,(void *)pCfgItem[i].arData))
		{
			TFTPLOG("TActiveConfigParams TFTPConfigSet fail, index:%d, value:%s\n",pCfgItem[i].uiLoctIdx,
						(char *)pCfgItem[i].arData);
			continue;
		}
		bConfigChanged = TRUE;
	}
	if (TRUE == bConfigChanged)
	{
		TFTPConfigSave();
	}
	else
	{
		return ERROR;
	}
	return OK;
}
int TGetSvrPort(char* pSrvName,char* pDestSrv)
{
	char *pDest;
	
	pDest = strchr(pSrvName,':');
	if (NULL == pDest)
	{
		TFTPLOG("Server name doesn't include the port info\n");
		strcpy(pDestSrv,pSrvName);
		return (80);
	}
	strncpy(pDestSrv,pSrvName,(pDest-pSrvName));
	*(pDestSrv+(pDest-pSrvName)) = '\0';
	pDest += 1;
	return strtol(pDest,NULL,10);
}
static BOOLEAN TConfigLoctChanged()
{
	char stg[128+1];
	char stgb[128+1];
	int j;

	if (protocol_config_get((void *) stg, LOCT_Provisioning_ConfigServerFQDN))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ServerFQDN \n");
		return FALSE;
	}
	TGetSvrPort(stg, stgb);
	if (strcmp(stgb,g_TFTPLocationParams.pConfigSrvFQDN) != 0)
	{
		TFTPLOG("TFTP configuration server changed \n");
		return TRUE;
	}
	if (protocol_config_get((void *) stg, LOCT_Provisioning_ConfigPath))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ConfigurationPath \n");
		return FALSE;
	}
	j=strlen(stg);
	j = (j>0)?(j-1):(0);
	if ((stg[j] == '\\' ) || (stg[j] == '/' ) || (stg[j] == '\0'))
	{
		char  *pFileName = TGetCfgFileName();
		strcat((char *)stg,pFileName);
	}
	if (strcmp(stg,g_TFTPLocationParams.pConfigFileName) != 0)
	{
		TFTPLOG("TFTP configuration file path&name changed \n");
		return TRUE;
	}
	return FALSE;
}

static BOOLEAN TFirmwareGetVersion(char* pFileName,char *pVersion)
{
	char *pDest;
	
	pDest = strstr(pFileName,"_v");
	if (NULL == pDest)
	{
		TFTPLOG("TFTP firmware file name isn't include the version info\n");
		return FALSE;
	}
	pDest += 2;
	while ((*pDest >= '0' && *pDest <= '9' ) || (*pDest == '.') )
	{
		*pVersion ++ = *pDest ++;
	}
	*pVersion = '\0';
	if ('.' == *(pVersion-1))
	{
		*(pVersion-1) = '\0';
	}
	return TRUE;
}

static BOOLEAN TFirmwareIsChanged()
{
	char stg[128+1];
	char arVersion1[10];
	char arVersion2[10];
	char i;

	if (protocol_config_get((void *) stg, LOCT_Provisioning_FirmwareFileName))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_FirmwareFileName \n");
		return FALSE;
	}
	memset(arVersion1,0,sizeof(arVersion1));
	if (FALSE == TFirmwareGetVersion(stg,arVersion1))
	{
		TFTPLOG("TFTP local firmware file isn't include the version \n");
		return FALSE;
	}
	_GetSWVersion(arVersion2);
	for (i=0;i<10;i++)
	{
		if (((arVersion2[i] < '0')||(arVersion2[i] > '9')) && (arVersion2[i] != '.'))
		{
			arVersion2[i]='\0';
			break;
		}
	}
	if (strcmp(arVersion1,arVersion2) == 0)
		return FALSE;
	else
		return TRUE;
	
}

static BOOLEAN TFirmwareIsChangedNow()
{
	char stg[128+1];
	char arVersion1[10];
	char arVersion2[10];

	if (protocol_config_get((void *) stg, LOCT_Provisioning_FirmwareFileName))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_FirmwareFileName \n");
		return FALSE;
	}
	memset(arVersion1,0,sizeof(arVersion1));
	memset(arVersion2,0,sizeof(arVersion2));
	if (FALSE == TFirmwareGetVersion(stg,arVersion1))
	{
		TFTPLOG("TFTP there's no version in cofig file \n");
		return TRUE;
	}
	if (FALSE == TFirmwareGetVersion(g_TFTPLocationParams.pFirmwareFileName,arVersion2))
	{
		TFTPLOG("TFTP local firmware file isn't include the version \n");
		return TRUE;
	}
	if (strcmp(arVersion1,arVersion2) == 0)
		return FALSE;
	else
		return TRUE;
}

STATUS TGetCurLoctParams()
{
	char stg[128+1];
	char stgb[128+1];

	/********************************configuration file location parameters*************************************/
	if (protocol_config_get((void *) stg, LOCT_Provisioning_ConfigProtocol))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ConfigProtocol \n");
		return ERROR;
	}
	if (strcmp(stg,"tftp" ) == 0)
	{
		g_TFTPLocationParams.cProto = 0;
	}
	else if (strcmp(stg,"http") == 0)
	{
		g_TFTPLocationParams.cProto = 1;
	}
	else
	{
		g_TFTPLocationParams.cProto = 1;
	}
	if (protocol_config_get((void *) stg, LOCT_Provisioning_ConfigServerFQDN))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ServerFQDN \n");
		return ERROR;
	}
	g_TFTPLocationParams.cHttpPort = TGetSvrPort(stg, stgb);
	TCreateLoctParams(&g_TFTPLocationParams.pConfigSrvFQDN,(char *)stgb);
	if (protocol_config_get((void *) stg, LOCT_Provisioning_ConfigPath))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ConfigurationPath \n");
		return ERROR;
	}
	{
		int j=strlen(stg);

		j = (j>0)?(j-1):(0);
		if ((stg[j] == '\\' ) || (stg[j] == '/' ) || (stg[j] == '\0'))
		{
			char  *pFileName = TGetCfgFileName();
			strcat((char *)stg,pFileName);
		}
	}
	TCreateLoctParams(&g_TFTPLocationParams.pConfigFileName,(char *)stg);
	
	if (protocol_config_get((void *) stg, LOCT_Provisioning_EncryptKey))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_EncryptKey \n");
		return ERROR;
	}
	TCreateLoctParams(&g_TFTPLocationParams.pEncreptionKey,(char *)stg);

	/********************************firmware file location parameters*************************************/
	if (protocol_config_get((void *) stg, LOCT_Provisioning_FirmwareProtocol))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_UpgradeProtocol \n");
		return ERROR;
	}
	if (strcmp(stg,"tftp" ) == 0)
	{
		g_TFTPLocationParams.fProto = 0;
	}
	else if (strcmp(stg,"http") == 0)
	{
		g_TFTPLocationParams.fProto = 1;
	}
	else
	{
		g_TFTPLocationParams.fProto = 1;
	}
	if (protocol_config_get((void *) stg, LOCT_Provisioning_FirmwareServerFQDN))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ServerFQDN \n");
		return ERROR;
	}
	g_TFTPLocationParams.fHttpPort = TGetSvrPort(stg, stgb);
	TCreateLoctParams(&g_TFTPLocationParams.pFirmwareSrvFQDN,(char *)stgb);
	if (protocol_config_get((void *) stg, LOCT_Provisioning_FirmwarePath))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ConfigurationPath \n");
		return ERROR;
	}
	TCreateLoctParams(&g_TFTPLocationParams.pFirmwareFilePath,(char *)stg);
	if (protocol_config_get((void *) stg, LOCT_Provisioning_FirmwareFileName))
	{
		TFTPLOG("protocol_config_get error for LOCT_TFTP_ConfigurationPath \n");
		return ERROR;
	}
	TCreateLoctParams(&g_TFTPLocationParams.pFirmwareFileName,(char *)stg);
	
	return OK;
}

char *TGetCfgFileName()
{
	U8 MAC_Addr[6];
	char arMactext[12+1];
	static char arCfgFileName[20];

	memset( MAC_Addr, 0, 6 );
	if (ERROR == WLOwnMACAddressGet( 0, MAC_Addr ))
		return NULL;
	sprintf( arMactext, 
			"%02X%02X%02X%02X%02X%02X", 
			MAC_Addr[0],MAC_Addr[1],MAC_Addr[2], MAC_Addr[3], MAC_Addr[4], MAC_Addr[5] );		
	strcpy(arCfgFileName,"ut");
	strcat(arCfgFileName,arMactext);
	strcat(arCfgFileName,".aes");
	TFTPLOG("TFTPTGetCfgFileName: %s \n",arCfgFileName);
	return arCfgFileName;
}

int _TGetPSID(U8 *pPsidBuf,U8 bBufLen)
{
	int RecordAddress;
		
	RecordAddress = 0xE00+0x20000;
	if(0 != sysFlashGet((char *)pPsidBuf,bBufLen,RecordAddress))
		return 0;

	return 4;
}

char *TBase32_encode(unsigned char *src,int srclen)
{
  const char*  ch32="zxc1vBn3maS5DfG7hjkl9qweRt0yuioP"; 
  unsigned char *buf;
  static char dst[10+1]; 
  int i;

  buf=src;
  memset(dst,0,10);

  dst[0]=(buf[0]&0xF8)>>3;
  dst[1]=((buf[0]&0x07)<<2) + ((buf[1]&0xC0)>>6);
  dst[2]=((buf[1]&0x3E)>>1);
  dst[3]=((buf[1]&0x01)<<4) + ((buf[2]&0xF0)>>4);
  dst[4]=((buf[2]&0x0F)<<1) + ((buf[3]&0x80)>>7);
  dst[5]=((buf[3]&0x7C)>>2);
  dst[6]=((buf[3]&0x03)<<3) + ((buf[4]&0xE0)>>5);
  dst[7]=buf[4]&0x1F; 
  dst[8]=(buf[5]&0xF8)>>3;
  dst[9]=buf[5]&0x07; 
  
  for(i=0;i<10;i++)
    dst[i]=ch32[dst[i]];
  
  dst[i] = '\0';

  return dst;
}

char *TBase32_encode_Ex(const char* pMapArray,unsigned char *src,int srclen)
{
  unsigned char *buf;
  static char dst[5+1]; 
  int i;

  buf=src;
  memset(dst,0,5);

  dst[0]=(buf[0]&0xF8)>>3;
  dst[1]=((buf[0]&0x07)<<2) + ((buf[1]&0xC0)>>6);
  dst[2]=((buf[1]&0x3E)>>1);
  dst[3]=((buf[1]&0x01)<<4) + ((buf[2]&0xF0)>>4);
  dst[4]=buf[2]&0x0F;
  
  for(i=0;i<5;i++)
    dst[i]=pMapArray[dst[i]];
  
  dst[i] = '\0';

  return dst;
}

char *TGetHashDir()
{
	#define TFTP_HASH_DIR_MAX	10
	const char*  ch32="zxc1vBn3maS5DfG7hjkl9qweRt0yuioP"; 
	U8 MAC_Addr[6];
	char *pTemp;
	static char hash_buf[TFTP_HASH_DIR_MAX+1];

	memset( MAC_Addr, 0, 6 );
	memset(hash_buf,0,TFTP_HASH_DIR_MAX+1);
	if (ERROR == WLOwnMACAddressGet( 0, MAC_Addr ))
		return NULL;

	pTemp = TBase32_encode_Ex(ch32,MAC_Addr+3,3);
	strcpy(hash_buf,pTemp);
	TFTPLOG("TGetHashDir: %s \n",hash_buf);
	
	return (char*)hash_buf;
}

char *TGetAdminPsw()
{
	#define TFTP_ADMIN_PSW_MAX		12
	const char*  ch32="XZ1bvn3amS6dfG7hjKl9qRwrT0yu2oP"; 
	U8 MAC_Addr[6];
	char *pTemp;
	static char psw_buf[TFTP_ADMIN_PSW_MAX+1];
	
	memset( MAC_Addr, 0, 6 );
	memset(psw_buf,0,TFTP_ADMIN_PSW_MAX+1);
	if (ERROR == WLOwnMACAddressGet( 0, MAC_Addr ))
		return NULL;

	pTemp = TBase32_encode_Ex(ch32,MAC_Addr+3,3);
	strcat(psw_buf,pTemp);
	TFTPLOG("TGetAdminPsw: %s \n",psw_buf);
	
	return psw_buf;
}

char *TGetEncryptionKey()
{
	#define TFTP_ENC_KEY_MAX		32
	const char*  ch32="bvnXZ13amwu2oGAhjrT0yKlSDdf9qRP"; 
	U8 MAC_Addr[6];
	char *pTemp;
	static char encKey[TFTP_ENC_KEY_MAX+1];

	memset( MAC_Addr, 0, 6 );
	memset(encKey,0,TFTP_ENC_KEY_MAX+1);
	if (ERROR == WLOwnMACAddressGet( 0, MAC_Addr ))
		return NULL;

	MAC_Addr[0] += MAC_Addr[3];MAC_Addr[1] += MAC_Addr[4];
	MAC_Addr[2] += MAC_Addr[5];
	sprintf( encKey, "%02X%02X%02X", MAC_Addr[0],MAC_Addr[1],MAC_Addr[2]);	
	pTemp = TBase32_encode_Ex(ch32,MAC_Addr+3,3);
	strcat(encKey,pTemp);

	TFTPLOG("TGetEncryptionKey: %s \n",encKey);
	return encKey;
}

STATUS TFTPUpgradeProc()
{
	char stg[128+1];
	char stgb[128+1];
	char ipAddr[INET_ADDR_LEN+1];
	int	tftpPort;
	int	DataFd;
	int	num;
	unsigned char	buf[TFTP_PACKET_BYTES+2];
	int	buf_offset;
  	unsigned char	*buf64K;
	unsigned char	*plainbuf;
	int 	iBinDestLen;
	char loopIdx=0;
	int 	plain_len;
	BOOLEAN bCfgChanged=FALSE;
	int 	iErrNo;

	TftpCleanRetryTimer();
	if (ERROR == TFTPResolv(g_TFTPLocationParams.pConfigSrvFQDN,ipAddr))
	{
		TFTPLOG("TFTPResolv error : %s\n",g_TFTPLocationParams.pConfigSrvFQDN);
		return ERROR;
	}
	TFTPLOG("TFTPResolv Success! ip:%s\n",ipAddr);
	tftpPort = getCurTFTPPort();
	buf64K = (unsigned char *)malloc(TFTP_CONFIGFILE_MAX);	/* allocate 64KB for one sector of data */
	if(buf64K == NULL) 
	{
		TFTPLOG("TFTP malloc 64k error\n");

		return ERROR;
	}
	/* Following while(1) loop is for downloading the configuration file, 
	     if some error happens, program will break from this loop, then check the firmware */
	while (1)
	{
		if (TRUE == g_bTFTPNeedCancel)
		{
			g_bTFTPNeedCancel = FALSE;
			TFTPLOG("TFTP process exit by user \n");
			free(buf64K);

			return OK;
		}
		g_bTFTPXferInProcess = TRUE;

		TFTPWriteLog(TFTP_LOG_CONFIGFILE);
		/* The following function dxXfer will spawn a task which will read the data from 
		     UDP socket then write the data to DataFd  */
		if (g_TFTPLocationParams.cProto == 1)
		{
			tftpPort = g_TFTPLocationParams.cHttpPort;
		}
		if (dxXfer(g_TFTPLocationParams.pConfigSrvFQDN, 
				ipAddr, 
				 tftpPort,
				 g_TFTPLocationParams.pConfigFileName, 
				 "GET",
                 			"binary", 
				 &DataFd, 
				 g_TFTPLocationParams.cProto) == ERROR)
    		{
        			TFTPLOG("TFTP transfer initiation failed.\n");
			free(buf64K);
			break;
    		}