recver.c

升级协议接受方教程阿达洒洒萨法萨达洒洒洒洒嗒嗒嗒萨

#define WINDOWS

#ifdef VXWORKS
#include "VxWorks.h"
#include "netinet\\udp.h"
#include "inetLib.h"
#include "sockLib.h"
#include "stdio.h"
#include "string.h"
#include "ioLib.h"
#include "taskLib.h"
#include "symLib.h "
#include "loadlib.h"
#include "logLib.h"
#include "dosFsLib.h"
#include "ramDrv.h"
#include "usrLib.h" 
extern SYMTAB_ID sysSymTbl ;
#define SOCKET         int
#define SOCKET_ERROR   ERROR 
#define INVALID_SOCKET ERROR
#define DEFAULT_NAME "/selfdev/"
#define RECVER_IP         "90.0.0.1"

#define DIAG_RAM_DISK_SIZE        0x100000  
#define DIAG_RAM_DISK_NAME        "/selfdev/" 
#endif


#ifdef WINDOWS
#pragma once
#include <stdio.h>
#include <winsock2.h>
#pragma comment( lib , "ws2_32.lib" )
#define STATUS int
#define RECVER_IP         "127.0.0.1"
#endif


#include "recver.h"
#ifdef WINDOWS
void myMain();
void main()
{
	myMain();
}
#endif
void myMain()
{
	SOCKET recverSkt;
#ifdef VXWORKS
	fsInit();
#endif
	recverSkt = hostInit(RECVER_PORT);
	recver(recverSkt);
	hostShutDown(recverSkt);
}


void recver(SOCKET sockfd)
{
	struct sockaddr_in senderAddr;

	int seqExpected = INT_ERROR;
	int seqRecv     = INT_ERROR;
	unsigned char recvPkt[PKT_SIZE];
	unsigned char recvMsg[SIZE_MSG_MAX];
	unsigned char sendBackPkt[PKT_BACK_SIZE];
	int  fileSize = 0;
	int   msgSize = 0;
	int  addrSize = sizeof(struct sockaddr);
	char fileName[NAME_SIZE];
	char*p = NULL;
	char*q = NULL;
	unsigned char type = 0x00;
	unsigned char typeBack = 0x00;
#ifdef WINDOWS
	FILE* dstFile;
#endif
	
#ifdef VXWORKS
	int  dstFile = 0;
#endif

	while ( 1 )
	{
		memset(recvMsg,0,SIZE_MSG_MAX);
		memset(recvPkt,0,PKT_SIZE);
		memset(sendBackPkt,0,PKT_BACK_SIZE);

		recvfrom(sockfd,recvPkt,PKT_SIZE,0,(struct sockaddr*)&senderAddr,&addrSize);

		if (corrupted(recvPkt))
		{
			printf("Recv Corrupted Packet!\n");
			continue;
		}
		seqRecv = getSeqNum(recvPkt);
		if (seqExpected == INT_ERROR)
		{
			if (seqRecv == INT_ERROR)
			{
				seqExpected = 0;
			}
			else
				seqExpected = seqRecv;
		}
		else 
		{
			if ((seqRecv != seqExpected) && (seqRecv != INT_ERROR))
			{
				printf("Recv Unexpected Packet!SeqRecv:%d  SeqExpect:%d\n",seqRecv,seqExpected);
				continue;
			}
		}
		type = getType(recvPkt);
		extractMsg(recvMsg,recvPkt);
		if (type == PKT_TYPE_CTRL)
		{
			if (recvMsg[0] == CMD_CREATE)
			{
				memset(fileName,0,sizeof(fileName));
				printf("\n%s    %s\n",recvMsg,recvMsg+SIZE_CMD+NAME_SIZE);
				fileSize = atoi(recvMsg + SIZE_CMD + NAME_SIZE);
				p = malloc(sizeof(char)*(fileSize+1));
				if (p == NULL)
				{
					printf("Can not get enough memory!\n");
					typeBack = NO_ENOUGH_MEMORY;
				}
				else
				{
					q = p;
					memset(q,0,fileSize+1);
					typeBack = NO_ERROR_1;
#ifdef VXWORKS
					strcpy(fileName,DEFAULT_NAME);
					strcat(fileName,recvMsg + SIZE_CMD);
#endif
#ifdef WINDOWS
					strcpy(fileName,recvMsg + SIZE_CMD);
#endif
					printf("\nFile Name:%s    size:%d\n",fileName,fileSize);
				}
			}
			else if (recvMsg[0] == CMD_CLOSE)
			{
#ifdef VXWORKS
				dstFile = creat(fileName,O_RDWR);
				msgSize = write(dstFile,p,fileSize);
				if (msgSize != fileSize)
				{
					printf("Can not get enough disk!\n");
					typeBack = NO_ENOUGH_DISK;
				}
				else 
				{
					typeBack = NO_ERROR_1;
					free(p);
				}
				close( dstFile );
#endif
#ifdef WINDOWS
				dstFile = fopen(fileName,"wb");
				msgSize = fwrite(p,1,fileSize,dstFile);
				if (msgSize != fileSize)
				{
					printf("Can not get enouth disk!\n");
					typeBack = NO_ENOUGH_DISK;
				}
				else 
				{
					typeBack = NO_ERROR_1;
					free(p);
				}
				fclose(dstFile);
				printf("\nFile Finish!\n");
#endif
			}
		}
		else if (type == PKT_TYPE_DATA)
		{
			msgSize = atoi(recvPkt+SIZE_SEQNUM+SIZE_TYPE);
			printf("\nMsg Len:%d  %s\n",msgSize,recvMsg);
#ifdef VXWORKS
			memcpy(q,recvMsg,msgSize);
			q = q + msgSize;
			typeBack = NO_ERROR_1;
#endif
#ifdef WINDOWS
			memcpy(q,recvMsg,msgSize);
			q = q + msgSize;
			typeBack = NO_ERROR_1;
#endif
		}
		makeSendBackPkt(seqExpected,typeBack,sendBackPkt);
		sendto(sockfd,sendBackPkt,PKT_BACK_SIZE,0,(struct sockaddr*)&senderAddr,addrSize);	
		printf("\nANCK Send Out!\n");
		seqExpected = (seqExpected + 1) % NUM_SPACE;
	}
}
void makeSendBackPkt(int seq,unsigned char type,unsigned char *pkt)
{
	pkt[0] = (seq & 0xff);
	pkt[SIZE_SEQNUM] = type;

	/*填写校验序列*/

}
void extractMsg(unsigned char *msg,unsigned char *pkt)
{
	int i = 0;
	while (i < SIZE_MSG_MAX)
	{
		msg[i] = pkt[SIZE_SEQNUM+SIZE_TYPE+SIZE_LENTH+i];
		i ++;
	}
}
int  getSeqNum( unsigned char *pkt )
{
	return (pkt[0] & 0x000000ff);
}
unsigned char getType(unsigned char *pkt)
{
	return pkt[SIZE_SEQNUM];
}
int corrupted(unsigned char *pkt)
{
	return 0;
}

SOCKET hostInit(u_short port)
{
	struct sockaddr_in hostAddr;
	SOCKET sockfd;
#ifdef WINDOWS
	WSADATA wsaData;
	WSAStartup( WINSOCK_VERSION , &wsaData ) ;
#endif
	sockfd = socket( AF_INET , SOCK_DGRAM , 0 ) ;
	if ( sockfd == INVALID_SOCKET )
	{
#ifdef WINDOWS
		printf( "Create Error----%d\n" , WSAGetLastError() ) ;
		WSACleanup() ;
#endif
		return SOCKET_ERROR;
	}
	
	hostAddr.sin_addr.s_addr = inet_addr(RECVER_IP) ;
	hostAddr.sin_family = AF_INET ;
	hostAddr.sin_port   = htons( port ) ;
#ifdef VXWORKS
	hostAddr.sin_len         = (u_char)sizeof(struct sockaddr_in);
#endif
	
	if ( bind( sockfd , (struct sockaddr*)&hostAddr , sizeof(hostAddr) ) 
		== SOCKET_ERROR)
	{
#ifdef WINDOWS
		printf( "Bind Error----%d\n" , WSAGetLastError() ) ;
		WSACleanup() ;
#endif
		return SOCKET_ERROR;
	}
	printf("hostInit successfully!\nLocal IP:%s\n",inet_ntoa(hostAddr.sin_addr));
	return sockfd;
}

void hostShutDown(SOCKET sockfd)
{
#ifdef VXWORKS
	close(sockfd);
#endif
#ifdef WINDOWS
	WSACleanup();
	closesocket(sockfd);
#endif
}

#ifdef VXWORKS
STATUS fsInit()
{
	BLK_DEV     *pBlkDev;
	char        *pFileSysRamDiskBase = NULL;
	
	ramDrv();
	pFileSysRamDiskBase = malloc(DIAG_RAM_DISK_SIZE);
	if(NULL == pFileSysRamDiskBase)
	{
		logMsg("Malloc Error!\n",0,0,0,0,0,0);
		return ERROR;
	}
	
	bzero(pFileSysRamDiskBase,DIAG_RAM_DISK_SIZE); 
	
	pBlkDev = ramDevCreate( pFileSysRamDiskBase,  
		/* start address */                
		512,        
		/* sector size */                                                  
		64,     
		/* sectors per track */                                                      
		(int)(DIAG_RAM_DISK_SIZE/512),    
		/* total sectors  */
		0);                               
	/* offset */
	if(NULL == pBlkDev)
	{
		free(pFileSysRamDiskBase);
		logMsg("ramDevCreate Error!\n",0,0,0,0,0,0);
		return ERROR;
	} 
	
	if(NULL == dosFsMkfs (DIAG_RAM_DISK_NAME, pBlkDev))
	{
		free(pFileSysRamDiskBase);
		logMsg("dosFsMkfs Error!\n",0,0,0,0,0,0);
		return ERROR; 
	} 
	logMsg("dosFs Init OK!\n",0,0,0,0,0,0);
	return OK;
} 

void loadNewModule(char* name)
{
	int fd;     
	MODULE_ID hModule ;
	
	if ((fd = open(name, O_RDONLY, 0)) < 0) 
	{
		printf("\nCannot open memory device.\n");
		return;
	}
	
	if ((hModule=loadModule(fd,LOAD_ALL_SYMBOLS))==NULL)
	{
		printf("loadModule error = 0x%x.\n",errno) ;
		
		if (fd >= 0)
			close(fd);   
	}
	printf("\nModule Load Success\n");
}
void runModule(char* name)
{
	STATUS status=ERROR;
	FUNCPTR taskEntry = NULL ;
	SYM_TYPE * pType = NULL;
	int              taskId = ERROR;
	char funcEntryName[NAME_SIZE];
	
	printf("%s\n",name);
	memset(funcEntryName,0,NAME_SIZE);
	funcEntryName[0] = '_';
	strcat(funcEntryName,name);
	status = symFindByName(sysSymTbl,
		funcEntryName,
		(char **)&taskEntry,pType ) ;
	if (status==ERROR)
	{
		printf("symFindByName error=%d\\n", errno) ;
	}
	else
	{
		taskId = taskNameToId(name);
		if (taskId != ERROR)
		{
			taskDelete(taskId);
			printf("\n*****************Delete old task!\n");
		}
		printf("taskEntryr=0x%x, type=%d\n.",
			(int)taskEntry,(int)*pType);         
		status = taskSpawn(name,
			100,
			0,
			30000,
			taskEntry,
			0,0,0,0,0,0,0,0,0,0) ;
		if (status==ERROR)
		{
			printf("taskSpawn error=%d\n",errno) ;
		}
	}
} 

#endif