cbse_status_cbch_queryrequest.c

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

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

/* STATUS_CBCH_QUERY 初始化 */
int Process_STATUS_CBCH_QUERY_init(STATUSCBCH_REQ_t *s_StatusCBCH_Req);
/* 返回确认给CBC_Proxy */
int Process_Status_CBCH_Query_Return(PID_t s_Pid,unsigned char cNumberOfReturnMessage);

/* 发送消息给BSC */
int	Process_Send_StatusCBCHQuery_To_BSC(PID_t s_Pid, DIVIDE_CELLLIST_BUF_t *s_DivideCellListBuf);

int Process_STATUS_CBCH_QUERY(unsigned char *MessageBuf,PID_t s_Pid)
{
    int                      iReturnValue;
	STATUSCBCH_REQ_t         *LPm_StatusCBCHREQ; 
	/* 拆分小区缓冲区 */
	DIVIDE_CELLLIST_BUF_t    s_DivideCellListBuf;
	CELLID_t                 s_CellId;
	SCQ_PROCESS_DATA_STRUCT  *LPs_SCQProcessDataStruct;
	CELLLIST_i               s_CellCBCHLoadList;

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

	LPs_SCQProcessDataStruct=(SCQ_PROCESS_DATA_STRUCT  *)&ProcessData[s_Pid.iProcessId][0];
	
	/* 数据拷贝到进程数据区 */
	memcpy(&LPs_SCQProcessDataStruct->s_CBCMessage,MessageBuf,sizeof(CBEMESSAGE_t));

	/* 去掉MessageHead */
	LPm_StatusCBCHREQ=(STATUSCBCH_REQ_t *)&LPs_SCQProcessDataStruct->s_CBCMessage.cMessage[0];

#ifdef DEBUG_PRINT
	Print_StatusCBCHQuery(s_Pid, LPm_StatusCBCHREQ);
#endif

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

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

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

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

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

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

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


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

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

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


	return END;

}

//STATUS_CBCH_QUERY 初始化
int Process_STATUS_CBCH_QUERY_init(STATUSCBCH_REQ_t *s_StatusCBCH_Req)
{
	//检查必备参数

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

	//检查参数内容

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

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

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

//返回确认给CBC_Proxy
int Process_Status_CBCH_Query_Return(PID_t s_Pid,unsigned char cNumberOfReturnMessage)
{
    CBEMESSAGE_t       s_CBEMessage;
	CBEMESSAGE_t       *LPCBEMessage;
	MESSAGE_CONFIRM_i  s_MessageConfirm;
	MESSAGE_HEAD_t     *LPMessageHead;

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

	LPMessageHead=(MESSAGE_HEAD_t *)&ProcessData[s_Pid.iProcessId][sizeof(short)];
	LPCBEMessage=(CBEMESSAGE_t *)&ProcessData[s_Pid.iProcessId][0];

	s_MessageConfirm.s_MessageHead.iMessageAreaId=A;
	s_MessageConfirm.s_MessageHead.iMessageType=LPMessageHead->iMessageType;
	memcpy(&s_MessageConfirm.s_MessageHead.s_ReceiverPid,&LPMessageHead->s_SenderPid,sizeof(PID_t));
    memcpy(&s_MessageConfirm.s_MessageHead.s_SenderPid,&s_Pid,sizeof(PID_t));
	s_MessageConfirm.s_MessageHead.iMessageLength=1;
	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);
	
	AppendCBESendMessage(&s_CBEMessage);

	return SUCCESS;

}

/*发送消息给BSC
*/
int	Process_Send_StatusCBCHQuery_To_BSC(PID_t s_Pid, DIVIDE_CELLLIST_BUF_t *s_DivideCellListBuf)
{
    int                len;
	char               *BSCID;

	STATUSCBCH_REQ_t   s_StatusCBCReq;

	BSCMESSAGE_t       s_BSCMessage;
	int                i,j;
	int                Tid;
	CBEMESSAGE_t       *LPCBEMessage;

	memcpy(&s_StatusCBCReq,&ProcessData[s_Pid.iProcessId][(sizeof(short)+sizeof(MESSAGE_HEAD_t))],sizeof(STATUSCBCH_REQ_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_StatusCBCReq.p_CellList,&s_DivideCellListBuf->s_CellListOfBSC->s_CellList,sizeof(CELLLIST_t));
		len=Pack_STATUS_CBCH_QUERY(&s_StatusCBCReq,&s_BSCMessage.cMessage[0]);
		if (len>0)
		{
			s_BSCMessage.iLen=len;

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

			if (Tid!=FAILURE)
			{
				/* 小区CBCH操作次数加 1 */
				for(j=0;j<s_StatusCBCReq.p_CellList.iLength;j++)
				{
#ifdef  OPEN_STATISTIC
					Update_Cell_Statistic_Count(&s_StatusCBCReq.p_CellList.s_CellList[j].cCellId[0],Tid,CBCH_STATISTIC,0,0);
#endif
				}
				
				/* 发送给BSC */
				memcpy(&s_BSCMessage.s_Pid,&s_Pid,sizeof(PID_t));
#ifdef  OPEN_STATISTIC			
			s_CBSECount.s_ReqBSCCnt[Tid].iCBCProxyCBCHReqCnt++;
#endif
				X25AppendCBESendMessage(&s_BSCMessage, Tid);
			}
		}

	}

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

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

		s_CBEMessage.s_MessageHead.iMessageAreaId=A;
		//Status-CBCH-Resp  5
		s_CBEMessage.s_MessageHead.iMessageType=5;

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

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

	}
*/

	return SUCCESS;

}