cbse_status_message_query.c

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

#include "..\sys\Include.h"

//发送消息给BSC
//发送失败小区列表给CBC_Proxy
int Process_Send_StatusMessage_Req_To_BSC(PID_t s_Pid,STATUSMESSAGE_QUERY_t  *s_StatusMessage, DIVIDE_CELLLIST_BUF_t *s_DivideCellListBuf);

//STATUS_MESSAGE_QUERY 初始化
int Process_Status_Message_Query_init(STATUSMESSAGE_QUERY_t *s_StatusMessageReq);

//返回确认给CBC_Proxy
int Process_StatusMessage_Req_Return(PID_t s_Pid,unsigned char cNumberOfReturnMessage);

/*
 * 处理正常的消息状态查询
 */
int Process_STATUS_MESSAGE_QUERY(unsigned char *MessageBuf,PID_t s_Pid)
{
    int                     iReturnValue;
	STATUSMESSAGE_QUERY_t   *LPm_StatusMessageQuery;
	/* 拆分小区缓冲区 */
	DIVIDE_CELLLIST_BUF_t   s_DivideCellListBuf;
	CELLID_t                s_CellId;
	SMQ_PROCESS_DATA_STRUCT *LPs_SMQProcessDataStruct;
	CELLLIST_i              s_ReportCellList;

	memset(&s_ReportCellList,0,sizeof(CELLLIST_i));
	memset(&s_DivideCellListBuf,0,sizeof(DIVIDE_CELLLIST_BUF_t));
	memset(&ProcessData[s_Pid.iProcessId][0],0,LPCB_DATA_SIZE);

	LPs_SMQProcessDataStruct=(SMQ_PROCESS_DATA_STRUCT *)&ProcessData[s_Pid.iProcessId][0];

	/* 数据拷贝到进程数据区 */
	memcpy(&LPs_SMQProcessDataStruct->s_CBCMessage,MessageBuf,sizeof(CBEMESSAGE_t));

	/* 去掉MessageHead */
	LPm_StatusMessageQuery=(STATUSMESSAGE_QUERY_t *)&LPs_SMQProcessDataStruct->s_CBCMessage.cMessage[0];;

#ifdef DEBUG_PRINT
	Print_StatusMessageQuery(s_Pid, LPm_StatusMessageQuery);
#endif

	/* 判断参数 */
	iReturnValue=Process_Status_Message_Query_init(LPm_StatusMessageQuery);
	if (iReturnValue<0)
	{
		return iReturnValue;
	}

	/* 构造响应结果 */
    iReturnValue=Process_Divide_CellList_AccordingToResponse(&LPm_StatusMessageQuery->p_CellList,
		0,&s_ReportCellList,&s_CellId);
	if (iReturnValue<0)
	{
		return iReturnValue;
	}

	memcpy(&LPs_SMQProcessDataStruct->s_ResponseCellList ,
		&s_ReportCellList,sizeof(CELLLIST_i));
	
    /* 从响应列表得到拆分列表 */
    Process_Get_DividedCellList_from_ResponseCellList(&s_ReportCellList,&s_DivideCellListBuf);

    /* 标志是否等待响应 */
	IfNeedResponse(&LPs_SMQProcessDataStruct->s_ResponseCellList,&s_DivideCellListBuf);

	/* 此时用s_DivideCellListBuf.s_CellListOfBSC,
	  不用s_ResponseCellList.cNumberOfBSC 
      前者可能小于后者              */
	LPs_SMQProcessDataStruct->cNoOfResponseReq=s_DivideCellListBuf.cNumberOfCellList;

	/* 小区全失败 */
	if (LPs_SMQProcessDataStruct->cNoOfResponseReq==0)
	{
		return ALL_CELLS_NOT_AVAILABLE;
	}

	/* 记录定时器的ID置为-1 */
	LPs_SMQProcessDataStruct->iTimerId=-1;


    /* 返回确认给CBC_Proxy */
	Process_StatusMessage_Req_Return(s_Pid,s_DivideCellListBuf.cNumberOfCellList);

    /* 发送消息给BSC */
	Process_Send_StatusMessage_Req_To_BSC(s_Pid,LPm_StatusMessageQuery, &s_DivideCellListBuf);

	/* 创建回复定时器 */
	iReturnValue=create_timer(STATUS_MSG_QUERY_RETURN_DELAY_TIME,
	STATUS_MSG_QUERY_RETURN,(char *)&s_Pid,NULL);
	/* 创建定时器失败 */
	//sys
	if (iReturnValue<0)
	{
		printf("Create timer Error!\n");
		return iReturnValue;
	}
	else
	{
		LPs_SMQProcessDataStruct->iTimerId=iReturnValue;
		return CONTINUANCE;
	}

}

/* STATUS_MESSAGE_QUERY 初始化
*/
int Process_Status_Message_Query_init(STATUSMESSAGE_QUERY_t *s_StatusMessageReq)
{
	//检查必备参数

	if (s_StatusMessageReq->p_MessageIdentifier.bFlag!=EXIST)
	{
		return NO_MESSAGE_IDENTIFIER;
	}

	if (s_StatusMessageReq->p_CurrentSerialnumber.bFlag!=EXIST)
	{
		return NO_OLD_SERIAL_NUMBER;
	}
	

	if (s_StatusMessageReq->p_CellList.bFlag!=EXIST)
	{
		return NO_CELLLIST;
	}

	//检查参数内容

	//检查小区识别器CellIdDisc
	if ((s_StatusMessageReq->p_CellList.cCellIdDisc!=1)&&
		(s_StatusMessageReq->p_CellList.cCellIdDisc!=2)&&
		(s_StatusMessageReq->p_CellList.cCellIdDisc!=5)&&
		(s_StatusMessageReq->p_CellList.cCellIdDisc!=6))
	{
		return CELLIDDISC_OUTOFRANG;
	}

	//对于必备参数不用判断其存在
	//检查小区数目
	if ((s_StatusMessageReq->p_CellList.iLength<=0)||(s_StatusMessageReq->p_CellList.iLength>MAXCELLCOUNT))
	{
		return NUMBEROFCELL_ERROR;
	}

	//检查信道指示
	if (s_StatusMessageReq->p_ChannelIndicator.bFlag==EXIST)
	{
		if(s_StatusMessageReq->p_ChannelIndicator.cChannelIndicator>1)
		{
			return NUMBEROFCELL_ERROR;
		}
	}

	return SUCCESS;
}

/*
//该查询由写入一个消息触发
//处理定时查询
int Process_Scheduled_StatusMessage_Query(PID_t s_Pid)
{
	WRITEREPLACE_REQUEST_t *LPWriteReplace_Request;
	//拆分小区缓冲区
	DIVIDE_CELLLIST_BUF_t  s_DivideCellListBuf;
	STATUSMESSAGE_QUERY_t  s_StatusMessage;


	memset(&s_DivideCellListBuf,0,sizeof(DIVIDE_CELLLIST_BUF_t));
	memset(&s_StatusMessage,0,sizeof(STATUSMESSAGE_QUERY_t));

	//去掉MessageHead
	LPWriteReplace_Request=(WRITEREPLACE_REQUEST_t *)&ProcessData[s_Pid.iProcessId][(sizeof(MESSAGE_HEAD_t)+sizeof(short))];

	//MESSAGEIDENTIFIER
	memcpy(&s_StatusMessage.p_MessageIdentifier.bFlag,&LPWriteReplace_Request->p_MessageIdentifier.bFlag,
		sizeof(MESSAGEIDENTIFIER_t));

	//SERIALNUMBER
	memcpy(&s_StatusMessage.p_CurrentSerialnumber.bFlag,&LPWriteReplace_Request->p_NewSerialnumber.bFlag,
		sizeof(SERIALNUMBER_t));

	//CELLLIST
	memcpy(&s_StatusMessage.p_CellList.bFlag,&LPWriteReplace_Request->p_CellList.bFlag,
		sizeof(CELLLIST_t));

	//ChannelIndicator
	if (LPWriteReplace_Request->p_ChannelIndicator.bFlag==1)
	{
		memcpy(&s_StatusMessage.p_ChannelIndicator.bFlag,&LPWriteReplace_Request->p_ChannelIndicator,
			sizeof(CHANNELINDICATOR_t));
	}

	//分配小区路由
	//
    Process_Divide_CellList_EX(&s_StatusMessage.p_CellList,&s_DivideCellListBuf);
	
    //发送消息给BSC
    //发送失败小区列表给CBC_Proxy
    Process_Send_StatusMessage_Req_To_BSC(s_Pid,&s_StatusMessage, &s_DivideCellListBuf);

	//释放进程
	if (free_pid((char *)&s_Pid)<0)
	{
		//sys error
		printf("Warning! Free Pid Error.pid=%d\n",s_Pid.iProcessId);
	}

	return SUCCESS;
}
*/

/*
   发送消息给BSC
*/
int Process_Send_StatusMessage_Req_To_BSC(PID_t s_Pid,	STATUSMESSAGE_QUERY_t  *s_StatusMessage, DIVIDE_CELLLIST_BUF_t *s_DivideCellListBuf)
{
    int                    len;
	char                   *BSCID;
	BSCMESSAGE_t           s_BSCMessage;
	STATUSMESSAGE_QUERY_t  s_StatusMessageQuery;
//	STATUSMESSAGE_RESP_t   s_StatusMessageResp;
	int                    i,j;
	int                    Tid;
	CBEMESSAGE_t           *LPCBEMessage;
//	CBEMESSAGE_t           s_CBEMessage;
//	CBEMESSAGE_t           s_CBCProxyMessage;


	memcpy(&s_StatusMessageQuery,s_StatusMessage,sizeof(STATUSMESSAGE_QUERY_t));

	LPCBEMessage=(CBEMESSAGE_t *)&ProcessData[s_Pid.iProcessId][0];

	for(i=0;i<s_DivideCellListBuf->cNumberOfCellList;i++) 
	{
		memset(&s_BSCMessage,0,sizeof(BSCMESSAGE_t));

		memcpy(&s_StatusMessageQuery.p_CellList,&s_DivideCellListBuf->s_CellListOfBSC[i].s_CellList,sizeof(CELLLIST_t));
		len=Pack_STATUS_MESSAGE_QUERY(&s_StatusMessageQuery,&s_BSCMessage.cMessage[0]);
		
		if (len>0)
		{
			s_BSCMessage.iLen=len;

			BSCID=&s_DivideCellListBuf->s_CellListOfBSC[i].BSCIdentifier[0];
            Tid=GetTid(BSCID);

			if (Tid!=FAILURE)
			{
				/* 小区QUERY操作次数加 1 */
				for(j=0;j<s_StatusMessageQuery.p_CellList.iLength;j++)
				{
#ifdef  OPEN_STATISTIC
					Update_Cell_Statistic_Count(&s_StatusMessageQuery.p_CellList.s_CellList[j].cCellId[0],Tid,QUERY_STATISTIC,0,0);
#endif
				}

				memcpy(&s_BSCMessage.s_Pid,&s_Pid,sizeof(PID_t));
#ifdef  OPEN_STATISTIC			
    			s_CBSECount.s_ReqBSCCnt[Tid].iCBCProxyMsgQueryCnt++;
#endif
				/* 发送给BSC */
				X25AppendCBESendMessage(&s_BSCMessage, Tid);
				
			}
		}

	}

/*
	if (s_DivideCellListBuf->s_FailureList.bFlag==EXIST)
	{
		//报告失败列表给Cbc_proxy
    	memset(&s_StatusMessageResp,0,sizeof(STATUSMESSAGE_RESP_t));
		memset(&s_CBEMessage,0,sizeof(CBEMESSAGE_t));

		memcpy(&s_StatusMessageResp.p_MessageIdentifier,&s_StatusMessageQuery.p_MessageIdentifier,sizeof(MESSAGEIDENTIFIER_t));
		memcpy(&s_StatusMessageResp.p_OldSerialnumber,&s_StatusMessageQuery.p_CurrentSerialnumber,sizeof(SERIALNUMBER_t));
		memcpy(&s_StatusMessageResp.p_FailureList,&s_DivideCellListBuf->s_FailureList,sizeof(FAILURELIST_t));

		if (s_StatusMessageQuery.p_ChannelIndicator.bFlag==EXIST)
		{
			memcpy(&s_StatusMessageResp.p_ChannelIndicator,&s_StatusMessageQuery.p_ChannelIndicator,sizeof(CHANNELINDICATOR_t));
		}

		s_CBEMessage.s_MessageHead.iMessageAreaId=A;
		//Status-Message-Resp     7 
		s_CBEMessage.s_MessageHead.iMessageType=7;

		s_CBEMessage.s_MessageHead.s_SenderPid.cFunctionId=FUNCTIONID;
		s_CBEMessage.s_MessageHead.s_SenderPid.cModuleId=MODULEID;
		s_CBEMessage.s_MessageHead.iMessageLength=sizeof(STATUSMESSAGE_RESP_t);
		s_CBEMessage.iLen=sizeof(MESSAGE_HEAD_t)+s_CBEMessage.s_MessageHead.iMessageLength;
		memcpy(&s_CBEMessage.cMessage[0],(char *)&s_StatusMessageResp,s_CBEMessage.s_MessageHead.iMessageLength);
//		s_CBEMessage.SocketHandle=LPCBEMessage->SocketHandle;

		memset(&s_CBCProxyMessage,0,sizeof(CBEMESSAGE_t));
        Convert_StatusMessageResponse(&s_CBEMessage,&s_CBCProxyMessage);		
		AppendCBESendMessage(&s_CBCProxyMessage);

	}

*/
    return SUCCESS;
}

/* 返回确认给CBC_Proxy */
int Process_StatusMessage_Req_Return(PID_t s_Pid,unsigned char cNumberOfReturnMessage)
{
    CBEMESSAGE_t        s_CBEMessage;
//	CBEMESSAGE_t        *LPCBEMessage;


	MESSAGE_CONFIRM_i   s_MessageConfirm;
	MESSAGE_HEAD_t      *LPs_MessageHead;

	memset(&s_MessageConfirm,0,sizeof(MESSAGE_CONFIRM_i));
	memset(&s_CBEMessage,0,sizeof(CBEMESSAGE_t));

	LPs_MessageHead=(MESSAGE_HEAD_t *)&ProcessData[s_Pid.iProcessId][sizeof(short)];


	s_MessageConfirm.s_MessageHead.iMessageAreaId=A;
	s_MessageConfirm.s_MessageHead.iMessageType=LPs_MessageHead->iMessageType;
	memcpy(&s_MessageConfirm.s_MessageHead.s_ReceiverPid,&LPs_MessageHead->s_SenderPid,sizeof(PID_t));
    memcpy(&s_MessageConfirm.s_MessageHead.s_SenderPid,&s_Pid,sizeof(PID_t));
	s_MessageConfirm.s_MessageHead.iMessageLength=sizeof(int);
	s_MessageConfirm.NumberOfReturnMessage=cNumberOfReturnMessage;

	s_CBEMessage.iLen=s_MessageConfirm.s_MessageHead.iMessageLength+sizeof(MESSAGE_HEAD_t);

//	s_CBEMessage.SocketHandle=LPCBEMessage->SocketHandle;

	memcpy(&s_CBEMessage.s_MessageHead,&s_MessageConfirm.s_MessageHead,sizeof(MESSAGE_HEAD_t));

	memcpy(&s_CBEMessage.cMessage[0],&s_MessageConfirm.s_MessageHead,s_MessageConfirm.s_MessageHead.iMessageLength);
	
#ifdef DEBUG_PRINT
    printf("Return StatusMessageQuery confirm to CBCProxy. ConfirmValue=%d\n",cNumberOfReturnMessage); 
#endif
	AppendCBESendMessage(&s_CBEMessage);

	return SUCCESS;
}


//将列表转为标准格式,用于StatusMessageQuery
//in:   s_CBEMessage Cbcproxy发送来的原始信息
//out:  s_ProxyMessage
//返回:
//  1: 成功,
//  -1:失败
int Convert_StatusMessageQuery(CBEMESSAGE_t *s_CBEMessage,CBEMESSAGE_t *s_ProxyMessage)
{
	int                    posi;
	unsigned short         iListLen;
	STATUSMESSAGE_QUERY_t  *LPStatusMessageQuery;
	
	LPStatusMessageQuery=(STATUSMESSAGE_QUERY_t *)&s_ProxyMessage->cMessage[0];

	memcpy(&s_ProxyMessage->s_MessageHead,&s_CBEMessage->s_MessageHead,sizeof(MESSAGE_HEAD_t));
    
	memcpy(&s_ProxyMessage->cMessage[0],&s_CBEMessage->cMessage[0],
		(sizeof(STATUS_MESSAGE_QUERY_i)-sizeof(MESSAGE_HEAD_t)));

//	s_ProxyMessage->SocketHandle=s_CBEMessage->SocketHandle;	

	posi=sizeof(STATUS_MESSAGE_QUERY_i)-sizeof(MESSAGE_HEAD_t);

	//得到CELLLIST的长度
	memcpy(&iListLen,&s_CBEMessage->cMessage[posi+1],sizeof(unsigned short));
	iListLen=iListLen*sizeof(CELLID_t)+4; //4=sizeof(bFlag)+sizeof(CellIddisc)+sizeof(iLength)
	
	//长度溢出,返回错误
	if (iListLen>sizeof(CELLLIST_t))	
	{
		return FAILURE;
	}
	
	//没有该参数,返回成功
	if (iListLen==0)
	{
		return SUCCESS;
	}

//	posi=posi+sizeof(unsigned short);

	//复制小区列表
    memcpy(&LPStatusMessageQuery->p_CellList, &s_CBEMessage->cMessage[posi],iListLen);

	s_ProxyMessage->iLen=sizeof(STATUSMESSAGE_QUERY_t)+sizeof(MESSAGE_HEAD_t);

	return SUCCESS;
}

/* 处理StatusMessageQuery回复定时器到时 
   全返回  
*/
int Process_StatusMessageQuery_Response_timer_Expired(PID_t s_Pid)
{
	unsigned short               iLen;
	int                          i;
	char                         ResponseBuf[3096];
	SMQ_PROCESS_DATA_STRUCT      *LPs_SMQProcessDataStruct;
	int                          iPosi;
	STATUS_MESSAGE_QUERY_RESP_i  *LPs_StatusMessageQueryResponse;
    STATUSMESSAGE_QUERY_t        *LPs_StatusMessageQuery;

	memset(&ResponseBuf[0],0,3096);
	
	LPs_SMQProcessDataStruct=(SMQ_PROCESS_DATA_STRUCT *)&ProcessData[s_Pid.iProcessId][0];
	LPs_StatusMessageQuery=(STATUSMESSAGE_QUERY_t *)&LPs_SMQProcessDataStruct->s_CBCMessage.cMessage[0];

	iPosi=sizeof(short);
	
	LPs_StatusMessageQueryResponse=(STATUS_MESSAGE_QUERY_RESP_i *)&ResponseBuf[iPosi];

	memcpy(&LPs_StatusMessageQueryResponse->p_MessageIdentifier,
		&LPs_StatusMessageQuery->p_MessageIdentifier,sizeof(MESSAGEIDENTIFIER_t));
	memcpy(&LPs_StatusMessageQueryResponse->p_OldSerialNumber,
		&LPs_StatusMessageQuery->p_CurrentSerialnumber,sizeof(SERIALNUMBER_t));
	memcpy(&LPs_StatusMessageQueryResponse->p_ChannelIndicator,
		&LPs_StatusMessageQuery->p_ChannelIndicator,sizeof(CHANNELINDICATOR_t));

	LPs_StatusMessageQueryResponse->bReportListFlag=1;
	LPs_StatusMessageQueryResponse->cReportListNumberOfBSC=
		LPs_SMQProcessDataStruct->s_ResponseCellList.cNumberOfBSC;

	LPs_StatusMessageQueryResponse->s_MessageHead.iMessageAreaId=A;
	LPs_StatusMessageQueryResponse->s_MessageHead.iMessageType=CBCPROXY_STATUS_MESS_QUERY_RESP;	

	memcpy(&LPs_StatusMessageQueryResponse->s_MessageHead.s_SenderPid,&s_Pid,sizeof(PID_t));
	memcpy(&LPs_StatusMessageQueryResponse->s_MessageHead.s_ReceiverPid,
		&LPs_SMQProcessDataStruct->s_CBCMessage.s_MessageHead.s_SenderPid,sizeof(PID_t));


	iPosi=iPosi+sizeof(STATUS_MESSAGE_QUERY_RESP_i);
	
	for(i=0;i<LPs_SMQProcessDataStruct->s_ResponseCellList.cNumberOfBSC;i++)
	{
		memcpy(&ResponseBuf[iPosi],&LPs_SMQProcessDataStruct->s_ResponseCellList.s_BSCCellList[i],
			(LPs_SMQProcessDataStruct->s_ResponseCellList.s_BSCCellList[i].ilength*sizeof(CELLREPORT_i)+BSC_INDENTIFIER_LEN+sizeof(short)));
		iPosi=iPosi+LPs_SMQProcessDataStruct->s_ResponseCellList.s_BSCCellList[i].ilength*sizeof(CELLREPORT_i)+BSC_INDENTIFIER_LEN+sizeof(short);
	}

	iLen=iPosi-sizeof(short);

	memcpy(&ResponseBuf[0],&iLen,sizeof(short));
	LPs_StatusMessageQueryResponse->s_MessageHead.iMessageLength=iLen-sizeof(MESSAGE_HEAD_t);

#ifdef DEBUG_PRINT
    printf("Return StatusMessage Response to CBCProxy.\n"); 
    Printf_file_ResponseList(s_Pid,LPs_StatusMessageQueryResponse->s_MessageHead.iMessageType,&LPs_SMQProcessDataStruct->s_ResponseCellList);
#endif

    AppendCBESendMessage((CBEMESSAGE_t *)&ResponseBuf[0]);

	return END;
}