pack.c

CBS（小区广播）程序实现手稿

			case '7':
			case '8':
			case '9':
				c-='0';
				offset=offset*10+c;
				if(offset>64) offset=64;
				break;
			case ' ':
			case ')':
				if(offset==0) break;				//跳过空格
				j=temp;								//将协议数据按要求移位
				j<<=(32-offset);
				j>>=(32-offset);
				*(int*)p[0]>>=offset;				//屏蔽编程数据的某几位
				*(int*)p[0]<<=offset;
				*(int*)p[0]|=(int)j;				//将协议数据的比特位按要求赋给编程数据
				p++;								//P指针后移
				temp>>=offset;						//重置各变量
				offset=0;
				break;
			default:
				break;
			}
	}
	i-=1;
	len+=state;										//计算解出的协议数据字节数
	break;
    }
    finish[0]=(int)p;
    return len;										//返回解出的协议数据字节数
}

//*******************************************
//	调用上两函数，实现F类 V类描述符			*
//	返回值    1： 成功   0： 失败			*
//*******************************************
int CommonSubUnFlatPack(BYTE * buf,BYTE * format,int format_len,int p[],int finish[])
{
    int  i,len,j,k,count_of_VPart,Lflag,r;
    int  pos_V[128],m;
    BYTE c;

	if(format[0]=='L') Lflag=1;						//看有无 L 字符 置相应标志码 
	else Lflag=0;

    count_of_VPart=0;

    for (i=0;i<format_len;i++)						//计算格式串中V的个数
    {
		c=format[i];
		if (c=='V' || c=='v')
			pos_V[count_of_VPart++]=i;				//记录V在格式串中的位置
    }

	pos_V[count_of_VPart]=i;						//置最后一个V类描述符在格式串中的位置

    len=SubCommonSubUnFlatPack(buf,format,pos_V[0],p,finish);	//调用上层函数处理F类描述符
    if (count_of_VPart)								//若有V类描述符则处理之
	{
		if(Lflag)
			for (j=0;j<count_of_VPart;j++)
			{
				(int)p=finish[0];					//取得编程数据地址
				k=0;
				memcpy(&k,buf+len,2);				//取得协议数据地址
				m=SubCommonSubUnFlatPack(buf+len+k+2,	//调用处理F类描述符的程序对之进行处理
					format+pos_V[j]+1,pos_V[j+1]-pos_V[j],p,finish);
													//判断解包是否完整，若否 则错误
				r=0;
				memcpy(&r,buf+len+k,2);
				if(r!=m) return 0;
			}
		else
			for (j=0;j<count_of_VPart;j++)
			{
				(int)p=finish[0];						//取得编程数据地址
				k=buf[len++];							//取得协议数据地址
				m=SubCommonSubUnFlatPack(buf+len+k,		//调用处理F类描述符的程序对之进行处理
					format+pos_V[j]+1,pos_V[j+1]-pos_V[j],p,finish);
				if(buf[len+k-1]!=m) return 0;
			}
	}
	return 1;
}

//*******************************************************
//					一次性解包函数						*
// buf->协议数据区，format->格式串, para->编程数据区	*
//*******************************************************
int FlatUnPack(BYTE * buf,BYTE * format,...)
{ 
    int x;
    return CommonSubUnFlatPack(buf,format,strlen(format),((int *)&format)+1,&x);
}

//	MFLATP~1 C           8,019  12-16-98  13:29 mflatpack.c
//*******************************
//	多步打包函数组MFlatPack		*
//*******************************
//***********************************
//	调用资源申请函数				*
//	申请一个打包句柄				*
//返回值	若>=0:成功，若<0:失败	*
//***********************************
int FlatPackBegin()
{
	int i;

	i=AllocFlatResource();				//调用资源申请函数
	if(i==-1) return -1;
	else	PackControl[i].Mode=1;
	return i;
}

//***********************************************************
//		把一个打包句柄与一个输出流联系起来					*
//		打包指针->流的开始处								*
//handle:打包句柄，s:输出字节流，s_len:输出流的最大长度		*
//vc:V部分的个数，o_flag:是否有O部分的标记					*
//返回值	无意义											*
//***********************************************************
int FlatPackAttach(int handle,int vc,int o_flag,BYTE * s,int s_len)
{
	memset(&PackControl[handle],0,sizeof(struct FlatPackControl_t));
	PackControl[handle].StreamPtr=s;			//置相应的控制结构的值
	PackControl[handle].StreamLen=s_len;
	PackControl[handle].Oflag=o_flag;
	PackControl[handle].Lflag=0;
	PackControl[handle].Vcount=vc;
	return 1;
}

//***********************************
//	设置V O部分长度指示语的长度		*
//  1 为一个字节，2为两个字节		*
//***********************************
int FlatPackSetVOLenLen(int handle,int LenLen)
{
	if(LenLen==1||LenLen==2)
	{
		PackControl[handle].Lflag=LenLen-1;
		return 1;
	}
	else return 0;
}

//***********************************************************
//在打包指针的位置处写入一些F部分参数，然后指针后移			*
//handle:打包句柄，format:F类描述串，para1:各编程数据		*
//返回值	>0:本次写入的字节数，==0:写入字节数超出最大长度	*
//***********************************************************
int FlatPackFPart(int handle,BYTE *format,...)
{
	int x;
	int len;
	BYTE *i;

								//取当前工作指针所指地址
	i=PackControl[handle].StreamPtr+PackControl[handle].WorkingPos;
								//调用处理F类描述符的程序对之进行处理
	len=SubCommonSubFlatPack(i,format,strlen(format),((int *)&format)+1,&x);
								//检查是否越界，若否指针后移
	if(PackControl[handle].WorkingPos+len>PackControl[handle].StreamLen) return 0;
	else 	PackControl[handle].WorkingPos+=len;
	return len;
}


//***********************************************************
//在打包指针的位置处写入一个V部分参数，然后指针后移			*
//handle:打包句柄，format:F类描述串，para1:各编程数据		*
//返回值	>0:本次写入的字节数（净内容）					*
//			==0:写入字节数超出最大长度						*
//***********************************************************
int FlatPackVPart(int handle,BYTE *format,...)
{
	int x;
	int j,len,k;
	BYTE *i;

								//取当前工作指针所指地址
	i=PackControl[handle].StreamPtr+PackControl[handle].WorkingPos;
	if(PackControl[handle].Lflag)
	{
								//计算指针区大小
		j=2*(PackControl[handle].Vcount+PackControl[handle].Oflag);
								//若当前为第一个V参数，置F部分长度
								//指针区清零，将工作指针移至第一个V部分入口
		if(!PackControl[handle].Vencounted)
		{
			PackControl[handle].FpartLen=PackControl[handle].WorkingPos;
			memset(i,0,j);
			PackControl[handle].WorkingPos+=j;
		}
								//将指针指向当前V部分净内容
		i=PackControl[handle].StreamPtr+PackControl[handle].WorkingPos+2;
								//调用处理F类描述符的程序对之进行处理
		len=SubCommonSubFlatPack(i,format,strlen(format),((int *)&format)+1,&x);
								//检查是否越界，若是返回零
		if(PackControl[handle].WorkingPos+len+1>PackControl[handle].StreamLen) return 0;
		memcpy(i-2,&len,2);		//填入V部分长度
								//填写指针区
		k=PackControl[handle].FpartLen+2*PackControl[handle].Vencounted;
		j=PackControl[handle].WorkingPos-k;
		memcpy(PackControl[handle].StreamPtr+k,&j,2);
								//工作指针后移
		PackControl[handle].WorkingPos+=(len+2);
	}
	else
	{
								//计算指针区大小
		j=PackControl[handle].Vcount+PackControl[handle].Oflag;
								//若当前为第一个V参数，置F部分长度
								//指针区清零，将工作指针移至第一个V部分入口
		if(!PackControl[handle].Vencounted)
		{
			PackControl[handle].FpartLen=PackControl[handle].WorkingPos;
			memset(i,0,j);
			PackControl[handle].WorkingPos+=j;
		}
								//将指针指向当前V部分净内容
		i=PackControl[handle].StreamPtr+PackControl[handle].WorkingPos+1;
								//调用处理F类描述符的程序对之进行处理
		len=SubCommonSubFlatPack(i,format,strlen(format),((int *)&format)+1,&x);
								//检查是否越界，若是返回零
		if(PackControl[handle].WorkingPos+len+1>PackControl[handle].StreamLen) return 0;
		(i-1)[0]=len;				//填入V部分长度
								//填写指针区
		k=PackControl[handle].FpartLen+PackControl[handle].Vencounted;
		(PackControl[handle].StreamPtr+k)[0]=PackControl[handle].WorkingPos-k;
								//工作指针后移
		PackControl[handle].WorkingPos+=(len+1);
	}
								//已处理的V参数个数加一
	PackControl[handle].Vencounted+=1;
	return len;
}

//*******************************************************
//在打包指针的位置处写入一个O部分参数，然后指针后移		*
//	handle:打包句柄，format:F类描述串					*
//	para1:各编程数据,name:O部分参数名					*
//	返回值	>0:本次写入的字节数（净内容）				*
//			==0:写入字节数超出输出流最大长度			*
//*******************************************************
int FlatPackOPart(int handle,BYTE * format,int name,...)
{
	int x;
	int k,len,j;
	BYTE *i;

								//取当前工作指针所指地址
	i=PackControl[handle].StreamPtr+PackControl[handle].WorkingPos;
	i[0]=(BYTE)name;			//填写O部分参数名
	
	if(PackControl[handle].Lflag)
	{
								//若当前为第一个O参数，填写指向O部分的指针
		if(!PackControl[handle].Oencounted)
		{
			if(!PackControl[handle].Vcount)
			{
				PackControl[handle].FpartLen=PackControl[handle].WorkingPos;
				i[0]=1;i[1]=0;
				PackControl[handle].WorkingPos+=2;
				i+=2;i[0]=(BYTE)name;
			}
			else
			{
			k=PackControl[handle].FpartLen+2*PackControl[handle].Vcount;
			j=PackControl[handle].WorkingPos-k;
			memcpy(PackControl[handle].StreamPtr+k,&j,2);
			}
		}
								//调用处理F类描述符的程序对之进行处理
		len=SubCommonSubFlatPack((BYTE *)(i+3),format,strlen(format),((int *)&format)+2,&x);
								//检查是否越界，若是返回零
		if(PackControl[handle].WorkingPos+len+3>PackControl[handle].StreamLen) return 0;
		memcpy(i+1,&len,2);		//填入O部分长度
								//工作指针后移
		PackControl[handle].WorkingPos+=(len+3);
	}
	else
	{
								//若当前为第一个O参数，填写指向O部分的指针
		if(!PackControl[handle].Oencounted)
		{
			if(!PackControl[handle].Vcount)
			{
				PackControl[handle].FpartLen=PackControl[handle].WorkingPos;
				i[0]=1;
				PackControl[handle].WorkingPos++;
				i++;i[0]=(BYTE)name;
			}
			else
			{
				k=PackControl[handle].FpartLen+PackControl[handle].Vcount;
				(PackControl[handle].StreamPtr+k)[0]=PackControl[handle].WorkingPos-k;
			}
		}
								//调用处理F类描述符的程序对之进行处理
		len=SubCommonSubFlatPack((BYTE *)(i+2),format,strlen(format),((int *)&format)+2,&x);
								//检查是否越界，若是返回零
		if(PackControl[handle].WorkingPos+len+2>PackControl[handle].StreamLen) return 0;
		(i+1)[0]=len;				//填入O部分长度
								//工作指针后移
		PackControl[handle].WorkingPos+=(len+2);
	}
								//已处理的O参数个数加一
	PackControl[handle].Oencounted+=1;
	return len;
}

//*******************************************
//结束打包并根据要求，插入或不插入一个EOC	*
//返回值	输出流的字节数					*
//*******************************************
int FlatPackEnd(int handle,int EOC_f)
{
	if(EOC_f)
	{
		*(PackControl[handle].StreamPtr+PackControl[handle].WorkingPos)=(BYTE)0;
		return(PackControl[handle].WorkingPos+1);
	}
	return(PackControl[handle].WorkingPos);
}

//*******************************
//		释放打包句柄			*
//返回值	若0:成功，1:失败	*
//*******************************
int FlatPackRelease(int handle)
{
	FreeFlatResource(handle);
	return 0;
}

//	MFLATU~1 C          10,775  12-17-98   8:42 MFlatUnPack.c
//***********************************
//		多步解包函数组MFlatUnPack	*
//***********************************

//***********************************
//	调用资源申请函数				*
//	申请一个解包句柄				*
// 返回值	若>=0:成功，若<0:失败	*
//***********************************
int FlatUnPackBegin()
{
	int i;

	i=AllocFlatResource();				//调用资源申请函数
	if(i==-1) return -1;
	else	PackControl[i].Mode=0;
	return i;
}

//***************************************************
//把一个解包句柄与一个输入流联系起来				*
//解包指针->流的开始处								*
//handle:解包句柄，s:输入字节流，s_len:输入流的长度	*
//返回值	无意义									*
//***************************************************		
int FlatUnPackAttach(int handle,BYTE * s,int s_len)
{
	memset(&PackControl[handle],0,sizeof(struct FlatPackControl_t));

	PackControl[handle].StreamPtr=s;			//置相应的控制结构的值
	PackControl[handle].StreamLen=s_len;
	PackControl[handle].Lflag=0;
	return 1;
}

//***********************************
//	设置V O部分长度指示语的长度		*
//  1 为一个字节，2为两个字节		*
//***********************************
int FlatUnPackSetVOLenLen(int handle,int LenLen)
{
	if(LenLen==1||LenLen==2)
	{
		PackControl[handle].Lflag=LenLen-1;
		return 1;
	}
	else return 0;
}

//****************************************************		
//在解包指针的位置处读一些F部分参数，然后指针后移	 *	
//handle:解包句柄，format:F类描述串，para1:各编程数据*
//返回值	无意义									 *
//****************************************************		
int FlatUnPackFPart(int handle,BYTE *format,...)
{
	int x;
	int len;
	BYTE *i;

								//取当前工作指针所指地址
	i=PackControl[handle].StreamPtr+PackControl[handle].WorkingPos;
								//调用处理F类描述符的程序对之进行处理
	len=SubCommonSubUnFlatPack(i,format,strlen(format),((int *)&format)+1,&x);
								//检查是否越界，若否指针后移
	if(PackControl[handle].WorkingPos+len>PackControl[handle].StreamLen) return 0;
	else 	PackControl[handle].WorkingPos+=len;
	PackControl[handle].EOIPos=PackControl[handle].WorkingPos;
	return len;
}

//*******************************		
//	取当前F部分的地址指针		*
//*******************************
BYTE * FlatUnPackGetFPartBODY(int handle)
{
	return PackControl[handle].StreamPtr+PackControl[handle].WorkingPos;
}

//*******************************
//	从当前位置取一个无符号字节	*
//	返回：该字节				*
//*******************************
BYTE FlatUnPackGetBYTE(int handle)
{
	return (BYTE)*(PackControl[handle].StreamPtr+PackControl[handle].WorkingPos);
}

//*******************************
//	从当前位置取一个无符号字	*
//*******************************
DWORD FlatUnPackGetWORD(int handle)
{
	DWORD i;

	i=(BYTE)*(PackControl[handle].StreamPtr+PackControl[handle].WorkingPos+1);
	i<<=8;
	i|=(BYTE)*(PackControl[handle].StreamPtr+PackControl[handle].WorkingPos);
	return i;
}

//***************************************		
//	取当前工作指针距流开始处的偏移		*
//	返回值	若>0:成功，否则失败			*