main.c

为了满足每个项目终端的需求

	{
		MAIN_DPRINTF("APP_StorageBlock,PktIndex or DataLen err\n");

		if((ret = SendPkt(gChannelHandle,send_statype_err,&sto_returntemp,sizeof(FILE_DATA) -1))== -1)
		{
			MAIN_DPRINTF("APP_StorageBlock,SendPkt err\n");
		}

		return -1;
	}

	/*storage the pkt into gfileram.buffer*/
	if(storage_index == (gFileRAM.DataPktIndexBak+1))
	{
		memcpy((gFileRAM.Buffer + gFileRAM.UsedSize),storage_buffer->Data,pkt_Len);
		gFileRAM.UsedSize += pkt_Len;
		ret = SendPkt(gChannelHandle,send_statype_ok,&sto_returntemp,sizeof(FILE_DATA) -1);
		gFileRAM.DataPktIndexBak = storage_index;
		if(ret == -1)
		{
			MAIN_DPRINTF("APP_StorageBlock,SendPkt err\n");
			return -1;
		}
//debug
		MAIN_DPRINTF("APP_StorageBlock,storage ok\n");
///////////////

	}
	else
	{
		MAIN_DPRINTF(" APP_StorageBlock,Send Packed err\n");
	}

#if 0
	if(storage_index== storage_pktsum)
	{
		MAIN_DPRINTF("buffer received is %s\n",gFileRAM.Buffer);
	}

#endif
	return 0;

}


/************************************************************************
* APP_EraseBlock
********************************pkt->Msg.Index*****************************************
FUNCTION: get start block number and end block number from pkt,then start
			erasing rom,notify peer erase ok or err
INPUTS:   pkt pointer
OUTPUTS:  none
RETURN:   0 is OK, otherwise error
*
*/

int APP_EraseBlock(PKT* pkt)
{
	int ret;
	FILE_DATA *era_returntemp;
	U16 i;
	U16 start_eraseblock,end_eraseblock;

	era_returntemp = &(pkt->Msg);
#ifdef NTOHS_DEBUG
	//startblock_num = ntohs(pkt->Msg.Index);
	gSumera_Num = ntohs(pkt->Msg.Sum);
#else
	//startblock_num = pkt->Msg.Index;
	gSumera_Num = pkt->Msg.Sum;
#endif


	era_returntemp->Sum = gSumera_Num;
	era_returntemp->DataLen = MAX_FILE_DATA_LEN;
	memset(era_returntemp->Data,'\0',MAX_FILE_DATA_LEN+1);
	memset(era_returntemp->Data,'0',MAX_FILE_DATA_LEN);
	era_returntemp->BCC = PktCalcCRC(era_returntemp->Data,era_returntemp->DataLen);

	if(gTemp_Msgtype== CMD_PPCBOOT_DATA)
	{
		start_eraseblock = 0;
		end_eraseblock = 15;
		era_returntemp->Sum = 16;
		gWrite_Endnum = start_eraseblock + gSumera_Num - 1;
		if(gWrite_Endnum > 15)
		{
			MAIN_DPRINTF(" APP_EraseBlock,PPCBOOT_DATA eraseblock_num is too large\n");
			return -1;
		}
	}
	else if(gTemp_Msgtype== CMD_KERNEL_DATA)
	{
		start_eraseblock = 16;
		end_eraseblock = 79;
		era_returntemp->Sum = 64;
		gWrite_Endnum = start_eraseblock + gSumera_Num - 1;
		if(gWrite_Endnum > 79)
		{
				MAIN_DPRINTF(" APP_EraseBlock,KERNEL_DATA eraseblock_num is too large\n");
				return -1;
		}
	}
	else if(gTemp_Msgtype== CMD_RAMDISK_DATA)
	{
		start_eraseblock = 80;
		end_eraseblock = 271;
		era_returntemp->Sum = 192;
		gWrite_Endnum = start_eraseblock + gSumera_Num - 1;
		if(gWrite_Endnum > 271)
		{
				MAIN_DPRINTF(" APP_EraseBlock,RAMDISK_DATA eraseblock_num is too large\n");
				return -1;
		}
	}
	else
	{
		MAIN_DPRINTF("APP_EraseBlock：err msgtype，client is sb\n");
    	return -1;
	}

	//for(i = start_eraseblock; i <= 1000; i++)
	for(i = start_eraseblock; i <= end_eraseblock; i++)
	{
		era_returntemp->Index = i;
//debug
//ret = 1;
////////
#if 1
		ret = ROM_EraseBlock(gRom_Type, gFlashHandle, i);
#endif
		if(ret != -1)
		{
			ret = SendPkt(gChannelHandle,STA_ERASEBLOCK_OK, era_returntemp, sizeof(FILE_DATA) -1);
			if(ret== -1)
			{
				MAIN_DPRINTF("APP_EraseBlock,SendPkt err\n");
				return -1;
			}
		}
		else
		{
			MAIN_DPRINTF("APP_EraseBlock,block %x err\n", i);
			ret = SendPkt(gChannelHandle,STA_ERASEBLOCK_ERR, era_returntemp, sizeof(FILE_DATA) -1);
			if(ret== -1)
			{
				MAIN_DPRINTF("APP_EraseBlock,SendPkt err\n");
				return -1;
			}
		}

		MAIN_DPRINTF("APP_EraseBlock,era_returntemp->Index is %d\n",i);
	}
	return 0;
}




/************************************************************************
* APP_WriteBlock
*************************************************************************
FUNCTION: write blocks
INPUTS:   pkt
OUTPUTS:  none
RETURN:   0 is OK, otherwise error
*
*/

int APP_WriteBlock(PKT* pkt)
{
	int ret,nwrite;
	U8 *tempbuffer;
	U8 *tempbufferbak;
	U16 return_index,start_blockwrite;
	FILE_DATA *write_returntemp;

	write_returntemp = &(pkt->Msg);
	
	/*gWrite_Endnum is the num of endblock,but write_returntemp->Sum is   */
	write_returntemp->Sum = gSumera_Num;
	//write_returntemp->Sum = 0;
	write_returntemp->DataLen = MAX_FILE_DATA_LEN;
	memset(write_returntemp->Data,'\0',MAX_FILE_DATA_LEN+1);
	memset(write_returntemp->Data,'0',MAX_FILE_DATA_LEN);
	write_returntemp->BCC = PktCalcCRC(write_returntemp->Data,write_returntemp->DataLen);

	tempbuffer = malloc(gBlock_Size + 5);
	tempbufferbak = tempbuffer;

	MAIN_DPRINTF("APP_WriteBlock,gWrite_Endnum is %d,gTemp_Msgtype is %d\n",gWrite_Endnum,gTemp_Msgtype);
	if(gTemp_Msgtype== CMD_PPCBOOT_DATA)
	{
		start_blockwrite = 0;
	}
	else if(gTemp_Msgtype== CMD_KERNEL_DATA)
	{
		start_blockwrite = 16;
	}
	else if(gTemp_Msgtype== CMD_RAMDISK_DATA)
	{
		start_blockwrite = 80;
	}
	else
	{
		MAIN_DPRINTF("APP_WriteBlock: err msgtype, client is sb\n");
    	return -1;
	}

	for(return_index = start_blockwrite; return_index <= gWrite_Endnum; return_index++) // DUB 080829 gWrite_Endnum is err
	{
		write_returntemp->Index = return_index;
		memset(tempbuffer,'\0',sizeof(tempbuffer));
		*(int *)(tempbuffer) = return_index;
		tempbuffer += 4;
		//MAIN_DPRINTF("APP_WriteBlock: gFileRAM.Buffer is %s\n",gFileRAM.Buffer); 
		memcpy(tempbuffer,gFileRAM.Buffer,gBlock_Size);
		tempbuffer -= 4;
		//MAIN_DPRINTF("APP_WriteBlock: &tempbuffer[0] is %d,&tempbuffer[1] is %d,&tempbuffer[2] is %d,&tempbuffer[3] is %d\n",
// tempbuffer[0], tempbuffer[1], tempbuffer[2], tempbuffer[3]);
		//MAIN_DPRINTF("APP_WriteBlock: write buffer is %s\n",&tempbuffer[4]);
//debug
//nwrite = 1;
////////
#if 1
		nwrite = ROM_WriteBlock(gRom_Type, gFlashHandle, return_index, tempbuffer, gBlock_Size);
#endif
		MAIN_DPRINTF(" APP_WriteBlock,write_num is %d,return_index is %d\n",return_index,return_index);
		gFileRAM.Buffer += gBlock_Size;

		if(nwrite != -1 )
		{	/* write ok */
			MAIN_DPRINTF("APP_WriteBlock: write block %d ok\n",return_index);

			gFileRAM.WritenSize += gBlock_Size;
			if((ret = SendPkt( gChannelHandle,STA_WRITEBLOCK_OK,write_returntemp,sizeof(FILE_DATA) -1))== -1)
			{
				MAIN_DPRINTF(" APP_WriteBlock,SendPkt err\n");
				//return -1;
			}
		}
		else
		{
			/* write err */
			MAIN_DPRINTF("APP_WriteBlock, write block err\n");
			if((ret = SendPkt(gChannelHandle,STA_WRITEBLOCK_ERR,write_returntemp,sizeof(FILE_DATA) -1))== -1)
			{
				MAIN_DPRINTF(" APP_WriteBlock,SendPkt err\n");
				return -1;
			}

			if(tempbufferbak != NULL)
			{
				free(tempbufferbak);
			}

			if(gFileRAM.BufferBak != NULL)
			{
				free(gFileRAM.BufferBak);
				gFileRAM.Buffer = NULL;
				gFileRAM.BufferBak = NULL;
			}

			return -1;
		}

	}

	if(tempbufferbak != NULL)
	{
		free(tempbufferbak);
	}

	if(gFileRAM.BufferBak != NULL)
	{
		free(gFileRAM.BufferBak);
		gFileRAM.Buffer = NULL;
		gFileRAM.BufferBak = NULL;
	}

	return 0;
}




/************************************************************************
* APP_ReadCfg
*************************************************************************
FUNCTION: read configure msg from device and send it to client
INPUTS:   pkt
OUTPUTS:  none
RETURN:   0 is OK, otherwise error
*
*/
int APP_ReadCfg(PKT* pkt)
{
	int ret,nread;
	U8 tempbuffer[MAX_CFG_LENGTH+1];
	U8 datebuff[ALLTIME_LENGTH+1];
	U16 dev_type;
	FILE * cfg_read_fd = NULL;
	FILE_DATA errcfg_temp;
	FILE_DATA *rightcfg_temp;

	time_t tval;
	struct tm *tm;

	rightcfg_temp = &(pkt->Msg);

	//MAIN_DPRINTF("PKT msg index is %d\n",*cfg_read_fd);
#if 1
	errcfg_temp.Index = 0;
	errcfg_temp.Sum = 0;
	errcfg_temp.DataLen = MAX_FILE_DATA_LEN;
	memset(errcfg_temp.Data,'\0',MAX_FILE_DATA_LEN+1);
	memset(errcfg_temp.Data,'0',MAX_FILE_DATA_LEN);
	errcfg_temp.BCC = PktCalcCRC(errcfg_temp.Data,errcfg_temp.DataLen);
#endif

//debug
#ifdef NTOHS_DEBUG
	dev_type = ntohs(pkt->Msg.Index);
#else
	dev_type = pkt->Msg.Index;
#endif
	MAIN_DPRINTF("PKT msg index is %d\n",dev_type);
	rightcfg_temp->Index = dev_type;
	rightcfg_temp->Sum = 0;

	//receive_temp->Index = dev_type;
	//MAIN_DPRINTF("rightcfg_temp->Sum is %d\n",rightcfg_temp->Sum);
	//MAIN_DPRINTF("errcfg_temp.Index  is %d\n",errcfg_temp.Index);

	time(&tval);
	tm = localtime(&tval);
	memset(datebuff,'\0',ALLTIME_LENGTH+1);
	sprintf(datebuff,"%04d%02d%02d%02d%02d%02d",(1900 + tm->tm_year),
			(1 + tm->tm_mon),(tm->tm_mday),(tm->tm_hour)
			,(tm->tm_min),tm->tm_sec);

	if(dev_type== DEV_CZT_CFG)
	{
		if((cfg_read_fd = fopen(ADDR_CZT, "r+"))== NULL)
		{
			MAIN_DPRINTF("APP_ReadCfg,OpenCfg err\n");
			ret = SendPkt(gChannelHandle, STA_READCFG_ERR, &errcfg_temp, sizeof(FILE_DATA) -1);
			if(ret== -1)
			{
				MAIN_DPRINTF("APP_ReadCfg,SendPkt err\n");
			}

			return -1;
		}

		memset(tempbuffer,'\0',sizeof(tempbuffer));
		memcpy(tempbuffer,datebuff,ALLTIME_LENGTH);

		//tempbuffer += ALLTIME_LENGTH;
		if((nread = fread(&tempbuffer[ALLTIME_LENGTH],sizeof(char),CZT_CFG_LENGTH,cfg_read_fd))!= CZT_CFG_LENGTH)
		{
			MAIN_DPRINTF("APP_ReadCfg,ReadCfg err\n");
			/*if(tempbufferbak != NULL)
			{
				free(tempbufferbak);
			}*/
			return -1;
		}

		//tempbuffer -= ALLTIME_LENGTH;
		rightcfg_temp->DataLen = 70;
		memset(rightcfg_temp->Data,'\0',MAX_FILE_DATA_LEN+1);
		memcpy(rightcfg_temp->Data,tempbuffer,70);
		rightcfg_temp->BCC = PktCalcCRC(rightcfg_temp->Data,rightcfg_temp->DataLen);
		//MAIN_DPRINTF("rightcfg_temp->Data is %s\n",rightcfg_temp->Data);
		if((ret = SendPkt( gChannelHandle,STA_READCFG_OK,rightcfg_temp,sizeof(FILE_DATA) -1)== -1))
		{
			MAIN_DPRINTF("APP_ReadCfg,SendCFGPkt err\n");
			/*if(tempbufferbak != NULL)
			{
				free(tempbufferbak);
			}*/
			if(cfg_read_fd != NULL)
			{
				fclose(cfg_read_fd);
				cfg_read_fd = NULL;
			}
			return -1;
		}
	}
	else if(dev_type== DEV_GDT_CFG)
	{
		if((cfg_read_fd = fopen( ADDR_GDT , "r+"))== NULL)
		{
			MAIN_DPRINTF("APP_ReadCfg,OpenCfg err\n");
			ret = SendPkt(gChannelHandle,STA_READCFG_ERR,&errcfg_temp,sizeof(FILE_DATA) -1);
			if(ret== -1)
			{
				MAIN_DPRINTF("APP_ReadCfg,SendPkt err\n");
			}
			/*if(tempbufferbak != NULL)
			{
				free(tempbufferbak);
			}*/
			return -1;
		}

		memset(tempbuffer,'\0',sizeof(tempbuffer));
		memcpy(tempbuffer,datebuff,ALLTIME_LENGTH);
		//tempbuffer += ALLTIME_LENGTH;
		if((nread = fread(&tempbuffer[ALLTIME_LENGTH],sizeof(char),GDT_CFG_LENGTH,cfg_read_fd))!= GDT_CFG_LENGTH)
		{
			MAIN_DPRINTF("APP_ReadCfg,ReadCfg err\n");
			/*if(tempbufferbak != NULL)
			{
				free(tempbufferbak);
			}*/
			if(cfg_read_fd != NULL)
			{
				fclose(cfg_read_fd);
				cfg_read_fd = NULL;
			}

			return -1;
		}

		//tempbuffer -= ALLTIME_LENGTH;
		rightcfg_temp->DataLen = sizeof(tempbuffer) - 1;
		memset(rightcfg_temp->Data,'\0',MAX_FILE_DATA_LEN+1);
		memcpy(rightcfg_temp->Data,tempbuffer,sizeof(tempbuffer));
		rightcfg_temp->BCC = PktCalcCRC(rightcfg_temp->Data,rightcfg_temp->DataLen);
		if((ret = SendPkt(gChannelHandle,STA_READCFG_OK,rightcfg_temp,sizeof(FILE_DATA) -1))== -1)
		{
			MAIN_DPRINTF("APP_ReadCfg,SendCFGPkt err\n");
			/*if(tempbufferbak != NULL)
			{
				free(tempbufferbak);
			}*/
			if(cfg_read_fd != NULL)
			{
				fclose(cfg_read_fd);
				cfg_read_fd = NULL;
			}

			return -1;
		}
	}
	else