cbse_set_drx.c

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

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

/* Set_DRX 初始化 */
int Process_Set_DRX_init(SET_DRX_t *s_SetDRX);

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

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


/* 处理设置不连续接收参数 */
int Process_SET_DRX(unsigned char *MessageBuf,PID_t s_Pid)
{
    int                         iReturnValue;
	SET_DRX_t                   *LPm_SetDRX; 
	SETDRX_PROCESS_DATA_STRUCT  *LPs_SetDrxProcessDataStruct;
	/* 拆分小区缓冲区 */
	DIVIDE_CELLLIST_BUF_t       s_DivideCellListBuf;
	CELLID_t                    s_CellId;

	memset(&s_DivideCellListBuf,0,sizeof(DIVIDE_CELLLIST_BUF_t));
	memset(&ProcessData[s_Pid.iProcessId][0],0,LPCB_DATA_SIZE);
	
	LPs_SetDrxProcessDataStruct=(SETDRX_PROCESS_DATA_STRUCT  *)&ProcessData[s_Pid.iProcessId][0];
	
	/* 数据拷贝到进程数据区 */
	memcpy(&LPs_SetDrxProcessDataStruct->s_CBCMessage,MessageBuf,sizeof(CBEMESSAGE_t));

	/* 去掉MessageHead */
	LPm_SetDRX=(SET_DRX_t *)&LPs_SetDrxProcessDataStruct->s_CBCMessage.cMessage[0];

#ifdef DEBUG_PRINT
	Print_SETDRX(s_Pid,LPm_SetDRX);
#endif

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

	/* 构造响应结果 */
    iReturnValue=Process_Divide_CellList_AccordingToResponse(&LPm_SetDRX->p_CellList,
		0,&LPs_SetDrxProcessDataStruct->s_ResponseCellList,&s_CellId);
	if (iReturnValue<0)
	{
		return iReturnValue;
	}
	
    /* 从响应列表得到拆分列表 */
    Process_Get_DividedCellList_from_ResponseCellList(&LPs_SetDrxProcessDataStruct->s_ResponseCellList,&s_DivideCellListBuf);
    /* 标志是否等待响应 */
	IfNeedResponse(&LPs_SetDrxProcessDataStruct->s_ResponseCellList,&s_DivideCellListBuf);

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

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

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

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

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

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

	return END;

}

/* Set_DRX 初始化 */
int Process_Set_DRX_init(SET_DRX_t *s_SetDRX)
{
	//检查必备参数

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

	if ((s_SetDRX->p_SchedulePeriod.bFlag!=EXIST)&&(s_SetDRX->p_ReservedSlots.bFlag!=EXIST))
	{
		return LACK_PARA;
	}
	

	//检查参数内容

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

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

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

	return SUCCESS;
}

/* 返回确认给CBC_Proxy */
int Process_SetDRX_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=sizeof(int);
    s_MessageConfirm.NumberOfReturnMessage=cNumberOfReturnMessage;

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

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

	memcpy(&s_CBEMessage.cMessage[0],&s_MessageConfirm.NumberOfReturnMessage,s_MessageConfirm.s_MessageHead.iMessageLength);
	
	AppendCBESendMessage(&s_CBEMessage);

	return SUCCESS;
	
}

/* 发送消息给BSC */
int Process_Send_SETDRX_To_BSC(PID_t s_Pid, DIVIDE_CELLLIST_BUF_t *s_DivideCellListBuf)
{
    int               len;
	char              *BSCID;
    SET_DRX_t         s_SetDRX; 
	BSCMESSAGE_t      s_BSCMessage;
	int               i;
	int               Tid;
//	CBEMESSAGE_t      *LPCBEMessage;
//	SET_DRX_REPORT_t  s_SetDRXReport;
//	CBEMESSAGE_t      s_CBEMessage;
//	CBEMESSAGE_t      CBCProxyMessage;

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

			BSCID=&s_DivideCellListBuf->s_CellListOfBSC->BSCIdentifier[0];
            Tid=GetTid(BSCID);
				if (Tid!=FAILURE)
				{
					memcpy(&s_BSCMessage.s_Pid,&s_Pid,sizeof(PID_t));
					/* 发送给BSC */
					X25AppendCBESendMessage(&s_BSCMessage, Tid);
				}
		}

	}

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

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

		s_CBEMessage.s_MessageHead.iMessageAreaId=A;
		//SET_DRX_REPORT 13
		s_CBEMessage.s_MessageHead.iMessageType=13;

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

		memset(&CBCProxyMessage,0,sizeof(CBEMESSAGE_t));
        //压缩列表参数
		Convert_SETDRX_Report(&s_CBEMessage,&CBCProxyMessage);
		AppendCBESendMessage(&CBCProxyMessage);
		
	}
*/

	return SUCCESS;

}

//将列表转为标准格式,用于SetDRX
//in:   s_CBEMessage Cbcproxy发送来的原始信息
//out:  s_ProxyMessage
//返回:
//  1: 成功,
//  -1:失败
int Convert_SETDRX(CBEMESSAGE_t *s_CBEMessage,CBEMESSAGE_t *s_ProxyMessage)
{
	int             posi;
	unsigned short  iListLen;
	SET_DRX_t       *LPm_SetDRX;
	
	LPm_SetDRX=(SET_DRX_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(SET_DRX_i)-sizeof(MESSAGE_HEAD_t)));

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

	/* 得到CELLLIST的长度 */
	memcpy(&iListLen,&s_CBEMessage->cMessage[posi],sizeof(unsigned short));

	/* 长度溢出,返回错误 */
	if (iListLen>sizeof(CELLLIST_t))	
	{
		return FAILURE;
	}
	
	/* 没有该参数,返回成功 */
	if (iListLen==0)
	{
		return SUCCESS;
	}

	posi=posi+sizeof(unsigned short);

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

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

	return SUCCESS;
}

/* 
   处理SET_DRX回复定时器到时 
   返回响应列表
*/
void Process_SET_DRX_Response_timer_Expired(PID_t s_Pid)
{
	int                                iPosi; 
	char                               ResponseBuf[3096];
	SETDRX_PROCESS_DATA_STRUCT         *LPs_SetDrxProcessDataStruct;
	SET_DRX_t                          *LPm_SetDRX;
	SET_DRX_RESP_i                     *LPs_SetDrxResp; 
	int                                i,j;
	unsigned short                     iLen;


	memset(&ResponseBuf[0],0,3096);

	LPs_SetDrxProcessDataStruct=(SETDRX_PROCESS_DATA_STRUCT *)&ProcessData[s_Pid.iProcessId][0];

	LPm_SetDRX=(SET_DRX_t *)&LPs_SetDrxProcessDataStruct->s_CBCMessage.cMessage[0];
	
	LPs_SetDrxResp=(SET_DRX_RESP_i *)&ResponseBuf[sizeof(short)];

	/*   */
	memcpy(&LPs_SetDrxResp->s_MessageHead.s_ReceiverPid,
		&LPs_SetDrxProcessDataStruct->s_CBCMessage.s_MessageHead.s_SenderPid,sizeof(PID_t));
    /*  */
	memcpy(&LPs_SetDrxResp->s_MessageHead.s_SenderPid,&s_Pid,sizeof(PID_t));

	LPs_SetDrxResp->s_MessageHead.iMessageAreaId=A;

	LPs_SetDrxResp->s_MessageHead.iMessageType=CBCPROXY_SET_DRX_REPORT;

	/* ChannelIndicator */
	memcpy(&LPs_SetDrxResp->p_ChannelIndicator,&LPm_SetDRX->p_ChannelIndicator,sizeof(CHANNELINDICATOR_t));

	iPosi=sizeof(SET_DRX_RESP_i)+sizeof(short);

	LPs_SetDrxResp->bReportListFlag=EXIST;
	LPs_SetDrxResp->cReportListNumberOfBSC=LPs_SetDrxProcessDataStruct->s_ResponseCellList.cNumberOfBSC;

	/* 没响应置为全失败 */
	for(i=0;i<LPs_SetDrxProcessDataStruct->s_ResponseCellList.cNumberOfBSC;i++)
	{
		/* 如果没响应置为全失败 */
		if(LPs_SetDrxProcessDataStruct->s_ResponseCellList.s_BSCCellList[i].bReceiveRespons==0)
		{
			for(j=0;LPs_SetDrxProcessDataStruct->s_ResponseCellList.s_BSCCellList[i].ilength;j++)
			{
				LPs_SetDrxProcessDataStruct->s_ResponseCellList.s_BSCCellList[i].s_CellReport[j].cCellStatus=PERMANENT_FAILURE;
			}
		}
	}

	/* 压缩ReportList参数 */
	for(i=0;i<LPs_SetDrxProcessDataStruct->s_ResponseCellList.cNumberOfBSC;i++)
	{
		memcpy(&ResponseBuf[iPosi],&LPs_SetDrxProcessDataStruct->s_ResponseCellList.s_BSCCellList[i],
			LPs_SetDrxProcessDataStruct->s_ResponseCellList.s_BSCCellList[i].ilength*sizeof(CELLREPORT_i )+sizeof(short)+BSC_INDENTIFIER_LEN);
		iPosi=iPosi+LPs_SetDrxProcessDataStruct->s_ResponseCellList.s_BSCCellList[i].ilength*sizeof(CELLREPORT_i )+sizeof(short)+BSC_INDENTIFIER_LEN;
	}


	iLen=iPosi-sizeof(short);

	LPs_SetDrxResp->s_MessageHead.iMessageLength=iLen-sizeof(MESSAGE_HEAD_t);

	memcpy(&ResponseBuf[0],&iLen,sizeof(short));

#ifdef DEBUG_PRINT
    printf("SETDRX Return To CBCProxy. Pid=%d\n",s_Pid.iProcessId); 
#endif

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

}