pc_server.cpp

基于LWIP的服务器

#include "stdafx.h"
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include "Winsock.h"
#include "pc_server.h"
#include "pc_lzw.h"



/*************************************************************************
//   固件升级函数

//   Handle是当前连接socket句柄，len表示传进数据的长度，data是传进的数据

//	 file是要升级的程序文件名 

//   可以根据传进的数据信息来调整具体的函数功能

//	 出错返回－1
*************************************************************************/
int UpGrade(int Handle,int len,char *data,const char *file)
{
	FILE *in;
    char recvline[DATAMAX];
	int offset;
	int count;
	int fail;
	int min_number;
	MSGHEAD program_head; 
	unsigned int addr;
	
	in=fopen(file,"rb");

	count=0;

	//计算需要传送的字节
	fseek(in,0,SEEK_END);
	count=(int)ftell(in);
	fseek(in,0,SEEK_SET);

	//发送升级的信息头，包括字节数和地址
	program_head.type=count;
	program_head.len=sizeof(unsigned int);
	addr=0x81100000;

	fail=SendMsg(Handle,&program_head,(char *)&addr);
	if(fail==-1)
		return -1;
	printf("upgrade start\n");
	printf("count= %d\n ",count);
	//发送升级数据部分
	while(count>0)
	{
		min_number=MIN(DATAMAX,count);
		fread(recvline,1,min_number,in);	

		//发消息头
		program_head.type=count;
		program_head.len =min_number;
		fail=SendMsg(Handle,&program_head,recvline);
		if(fail==-1)
			return -1;

		count-=min_number;

		fail=RcvMsgData(Handle,(char *)&offset,sizeof(int));
   		if(fail==-1)
    		return -1;
		printf("count= %d,  min_number=%d,   offset=%d\n",count,min_number,offset);
		//if(offset!=count+min_number)
		//	return -1;
	}
	printf("the end\n");

	fclose(in);
	return 1;
}


/*************************************************************************
//	发短信函数

//  Handle是当前连接socket句柄，len表示传进数据的长度，data是传进的数据

//  需要根据传进的数据信息来调整具体的函数功能，这里只是接收数据

//	出错返回－1
*************************************************************************/
int SendGSM(int Handle,int len,char *message)
{
	char  recvline[DATAMAX];
	MSGHEAD MsgHead;
	int fail;

	fail=RcvMsg(Handle,&MsgHead,recvline);
	if(fail==-1)
		return -1;
	recvline[MsgHead.len]='\0';

	printf(recvline);
	printf("\n");
	return 1;
}


/*************************************************************************
//	接收顾客信息函数

//  Handle是当前连接socket句柄，len表示传进数据的长度，message是传进的数据

//  需要根据传进的数据信息来调整具体的函数功能，这里只是接收顾客数据并显示

//	 出错返回－1
*************************************************************************/
int ReceiveRecord(int Handle,int len,char *message)
{
	int fail;
	MSGHEAD MsgHead;
	bitnode data;
	int i;
	int now_number;
	int *total_number;
	int k;

	//确定要接收的个数
	total_number=(int *)message;

	for(i=0;i<*total_number;i++)
	{
		fail=RcvMsg(Handle,&MsgHead,(char *)&data);
		if(fail==-1)
			return -1;

		printf("\ndata=%d,persion_id=%d\n",data.data,data.person_id);
		for(k=0;k<data.name_len;k++)
			printf("%c",data.name[k]);

		now_number=MsgHead.type;
	    fail=SendMsgData(Handle,(char *)&now_number,sizeof(int));
		if(fail==-1)
			return -1;
	}
	return 1;
}
	


/*************************************************************************
//	发送一个特定顾客信息函数

//  Handle是当前连接socket句柄，MsgHead指向要发送的消息头,tree指向需要发送的顾客信息

//	将tree发送出去

//	出错返回－1
*************************************************************************/
int DownLoadRecord(int Handle,P_MSGHEAD MsgHead,bitree tree)
{
	int fail;

 	fail=SendMsg(Handle,MsgHead,(char *)tree);
	if(fail==-1)
		return -1;

	return 1;
}

/*************************************************************************
//	发送顾客信息函数

//  Handle是当前连接socket句柄，len表示传进数据的长度，data是传进的数据

//  需要根据传进的数据信息来调整具体的函数功能，这里只是传一个特定节点的顾客数据

//	 出错返回－1
*************************************************************************/
int SendRecord(int Handle,int len,char *data)
{
	bitnode T;
	int i;
	int k;
	int fail;
	int count;
	MSGHEAD MsgHead;
	int *total_number;

	//确定要发送的个数
	total_number=(int *)data;

	for(i=0;i<*total_number;i++)
	{
		T.data=98+i;
		T.person_id=2+i;
		for(k=0;k<NAME_LEN;k++)
		{	
			T.name[k]='b'+k;			
		}
			
		T.name_len=NAME_LEN;

		MsgHead.type=i;
		MsgHead.len=sizeof(bitnode);

		fail=DownLoadRecord(Handle,&MsgHead,&T);
		printf("send %d\n",T.data);
		if(fail==-1)
    		return -1;

		fail=RcvMsgData(Handle,(char *)&count,sizeof(int));
   		if(fail==-1)
    		return -1;
		printf("count= %d\n",count);
	}

	return 1;

}


/*************************************************************************
//	下传配置函数

//  Handle是当前连接socket句柄，len表示传进数据的长度，data是传进的数据

//  需要根据传进的数据信息来调整具体的函数功能，这里只是发送数据

//	出错返回－1
*************************************************************************/
int SendConfigration(int Handle,int len,char *data)
{
	MSGHEAD MsgHead;
	int fail;

	MsgHead.type=CMD_DOWNLOADCONFIGRATION;
	MsgHead.len =len;
 	fail=SendMsg(Handle,&MsgHead,data);
	if(fail==-1)
		return -1;
	return 1;
}



/*************************************************************************
//	发消息头函数

//  Handle是当前连接socket句柄，MsgHead指向需要发送消息的头

//	出错时返回－1

*************************************************************************/
int SendMsgHead(int Handle,P_MSGHEAD MsgHead)
{
	int fail=0;
	
	fail=send(Handle,(char *)MsgHead,sizeof(MSGHEAD),0);
	if(fail==SOCKET_ERROR)
		return -1;
	else
		return 1;
}


/*************************************************************************
//	发消息数据函数

//  Handle是当前连接socket句柄，len表示要发送数据的长度，data是要发送的数据

//	出错时返回－1
*************************************************************************/
int SendMsgData(int Handle,char *data,int len)
{
	int fail=0;
	fail=send(Handle,data,len,0);
	if(fail==SOCKET_ERROR)
		return -1;
	else
		return 1;
}
/*************************************************************************
//	发一个完整消息函数

//  Handle是当前连接socket句柄，MsgHead指向需要发送消息的头，data是要发送的数据

//	出错时返回－1
*************************************************************************/
int SendMsg(int Handle,P_MSGHEAD MsgHead,char *data)
{
	int fail;
	fail=SendMsgHead(Handle,MsgHead);
	if(fail==-1)
		return -1;
		
	fail=SendMsgData(Handle,data,MsgHead->len);
	if(fail==-1)
		return -1;
		
	return 1;
}

/*************************************************************************
//	接受消息数据函数

//  Handle是当前连接socket句柄，len表示要接收数据的长度，data是要接收数据存放的位置

//	出错时返回－1
*************************************************************************/
int RcvMsgData(int Handle,char *data,int len)
{
	int count=0;
	int number=0;

	//count表示当前已接收字节数
    while(count<len)
    {
    	if((number = recv(Handle, data+count, len-count, 0)) > 0)
       	{
			//更新已接收字节数
       		count+=number;
       	}
       	else
       		return -1;
    }
    return 1;
}


/*************************************************************************
//	接收消息头函数

//  Handle是当前连接socket句柄，MsgHead指向要接收消息的头存放的位置

//	出错时返回－1，正确时返回消息数据的长度

*************************************************************************/
int RcvMsgHead(int Handle,P_MSGHEAD MsgHead)
{
	int fail;

	fail=RcvMsgData(Handle,(char *)MsgHead,sizeof(MSGHEAD));    
    if(fail==-1)
    	return -1;
    else  
	    return MsgHead->len;
	
}


/*************************************************************************
//	接受一个完整消息函数

//  Handle是当前连接socket句柄，MsgHead指向要接收消息的头存放的位置，data是要接收数据存放的位置

//	出错时返回－1，正确时返回消息数据的长度
*************************************************************************/
int RcvMsg(int Handle,P_MSGHEAD MsgHead,char *data)
{
	int fail;
		
	fail=RcvMsgHead(Handle,MsgHead); 
	if(fail==-1)
    	return -1;
    	
	fail=RcvMsgData(Handle,data,MsgHead->len);
	if(fail==-1)
    	return -1;
    else
	   	return MsgHead->len;

}

/*************************************************************************
//	关闭连接函数

//	Handle是当前连接socket句柄

*************************************************************************/
int CloseConnection(int Handle)
{
	shutdown(Handle,0);		
	closesocket(Handle);
	return 0;
}



/*************************************************************************
//	发送命令列表函数

//	Handle是当前连接socket句柄，Command指向要发送的命令列表的位置，number表示要发送多少个

//  出错返回－1
*************************************************************************/
int SendCmdList(int Handle,COMMAND *Command,int number)
{
	MSGHEAD MsgHead;
	int i;
	int fail;

	//发送该命令头，包含共有几个命令
	MsgHead.type=CMD_CMDLISTREQEST;
    MsgHead.len=number;
	fail=SendMsgHead(Handle,&MsgHead);     
	if(fail==-1)
	{
		return -1;
	}
	
	//依次发送个命令
	for(i=0;i<number;i++)
	{

		MsgHead.type=(*(Command+i)).type;
		MsgHead.len=(*(Command+i)).len;

		fail=SendMsg(Handle,&MsgHead,(*(Command+i)).data);
		if(fail==-1)
		{
			return -1;
		}
	}
	return 1;

}



/*************************************************************************
//	接收一个命令

//	Handle是当前连接socket句柄，cmd_type存储该接收的命令类型，data存储该接收命令的数据

//	返回该接收命令数据的长度

//  出错返回－1
*************************************************************************/
int RecOneCmd(int Handle,int *cmd_type,char *data)
{
	MSGHEAD MsgHead;
	int fail;

	fail=RcvMsg(Handle,&MsgHead,data);
	if(fail==-1)
	{	
		return -1;
	}
	*cmd_type=MsgHead.type;
	return MsgHead.len;
}




/*************************************************************************
//	与终端交换数据函数

//	Handle是当前连接socket句柄，Command指向要发送命令列表的位置，number表示要发送的命令数

//	file是要升级的程序文件名 

//  结束后返回1
*************************************************************************/
int SeverJob(int Handle,COMMAND *Command,int number,const char *file)
{
	int cmd_type;
	char data[DATAMAX];
	int len;

	while(1)
	{
		len=RecOneCmd(Handle,&cmd_type,data);
		if(len==-1)
		{
			CloseConnection(Handle);
			printf("close\n");
			return 1;
		}
		switch(cmd_type)
		{
			case CMD_CMDLISTREQEST:
				printf("SendCmdList\n");
				SendCmdList(Handle,Command,number);
				break;
			case CMD_UPLOADRECORD:
				printf("ReceiveRecord\n");
				ReceiveRecord(Handle,len,data);			
				break;  
			case CMD_DOWNLOADRECORD:	
				printf("SendRecord\n");
				SendRecord(Handle,len,data);    				
				break;	
			case CMD_UPGRADE:	
				printf("UpGrade\n");
				UpGrade(Handle,len,data,file);					
				break;
			case CMD_SENDMESSAGE:	
				printf("SendGSM\n");
				SendGSM(Handle,len,data);					
				break;  
			case CMD_DOWNLOADCONFIGRATION:
				printf("SendConfigration\n");
				SendConfigration(Handle,len,data);
				break;
		}
	}

}