cbse_killmessage.c

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

*/

/*
   发送消息给BSC
*/
int Process_Send_KillMessage_To_BSC(PID_t s_Pid, DIVIDE_CELLLIST_BUF_t *s_DivideCellListBuf)
{
    int             len;
	char            *BSCID;
	KILLMESSAGE_t   s_KillMessage;  
	BSCMESSAGE_t    s_BSCMessage;
	int             i,j;
	int             Tid;
	CBEMESSAGE_t    *LPCBEMessage;
	//报告失败列表参数
//	REPORTSUCCESS_t s_Report;
//	CBEMESSAGE_t    s_CBEMessage;
//	CBEMESSAGE_t    s_CBCProxyMessage;


	memcpy(&s_KillMessage,&ProcessData[s_Pid.iProcessId][(sizeof(short)+sizeof(MESSAGE_HEAD_t))],sizeof(KILLMESSAGE_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_KillMessage.p_CellList,&s_DivideCellListBuf->s_CellListOfBSC[i].s_CellList,sizeof(CELLLIST_t));
		len=Pack_KILL_MESSAGE(&s_KillMessage,&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)
			{
				/* 小区KILL操作次数加 1 */
				for(j=0;j<s_KillMessage.p_CellList.iLength;j++)
				{
#ifdef  OPEN_STATISTIC
					Update_Cell_Statistic_Count(&s_KillMessage.p_CellList.s_CellList[j].cCellId[0],Tid,KILL_STATISTIC,0,0);
#endif
				}

				memcpy(&s_BSCMessage.s_Pid,&s_Pid,sizeof(PID_t));

#ifdef  OPEN_STATISTIC			
			s_CBSECount.s_ReqBSCCnt[Tid].iCBCProxyKillReqCnt++;
#endif

				/* 发送给BSC */
				X25AppendCBESendMessage(&s_BSCMessage, Tid);
					
			}
		}

	}
#ifdef DEBUG_PRINT
            printf("Send KillMessage to BSC. Pid=%d\n",s_Pid.iProcessId); 
#endif

/*
	if (s_DivideCellListBuf->s_FailureList.bFlag==EXIST)
	{
		//报告失败列表给Cbc_proxy
		memset(&s_Report,0,sizeof(REPORTSUCCESS_t));
		memset(&s_CBEMessage,0,sizeof(CBEMESSAGE_t));
	
		memcpy(&s_Report.p_MessageIdentifier,&s_KillMessage.p_MessageIdentifier,sizeof(MESSAGEIDENTIFIER_t));
		memcpy(&s_Report.p_Serialnumber,&s_KillMessage.p_OldSerialnumber,sizeof(SERIALNUMBER_t));
		memcpy(&s_Report.p_FailureReportList,&s_DivideCellListBuf->s_FailureList,sizeof(FAILURELIST_t));

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

		s_CBEMessage.s_MessageHead.iMessageAreaId=A;
		//CBSE_REPORT_SUCCESS
		s_CBEMessage.s_MessageHead.iMessageType=3;

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

		memset(&s_CBCProxyMessage,0,sizeof(CBEMESSAGE_t));
        Convert_Response(&s_CBEMessage,&s_CBCProxyMessage);		
		AppendCBESendMessage(&s_CBCProxyMessage);
	}
*/

	return SUCCESS;

}

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

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

	posi=sizeof(KILL_MESSAGE_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;
	}


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

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

	return SUCCESS;
}

/* 删除预约消息 */
int process_Delete_Schedual_Message(PID_t s_OriginalPid,PID_t s_NewPid)
{
	int                               iReturnValue;
	WRITEREPLACE_REQUEST_t            *LPWriteReplace_Request;
	WRITEREPLACE_PROCESS_DATA_STRUCT  *LPs_WriteReplaceProcessDataStruct;
	KILLMESSAGE_t                     *LpKillMessage;
	CBEMESSAGE_t                      *LpCBEMessage;
	int                               i,j;
	unsigned char                     ListBuf[2048];

	memset(ListBuf,0,2048);

	if (s_NewPid.iProcessId==s_OriginalPid.iProcessId)
	{
		return NO_PROCESS;
	}

	iReturnValue=is_busy_pid((char *)&s_OriginalPid);
	if (iReturnValue<0)
	{
		return NO_PROCESS;
	}
	
	LPWriteReplace_Request=
		(WRITEREPLACE_REQUEST_t *)&ProcessData[s_OriginalPid.iProcessId][(sizeof(MESSAGE_HEAD_t)+sizeof(short))];

	LpKillMessage=(KILLMESSAGE_t *)&ProcessData[s_NewPid.iProcessId][(sizeof(MESSAGE_HEAD_t)+sizeof(short))];

	LPs_WriteReplaceProcessDataStruct=(WRITEREPLACE_PROCESS_DATA_STRUCT *)&ProcessData[s_OriginalPid.iProcessId][0];
	//判断消息是否匹配
	if ((memcmp(&LPWriteReplace_Request->p_MessageIdentifier.iMessageIdentifier,&LpKillMessage->p_MessageIdentifier.iMessageIdentifier,sizeof(short))!=0)||
	(memcmp(&LPWriteReplace_Request->p_NewSerialnumber.iSerialNumber,&LpKillMessage->p_OldSerialnumber.iSerialNumber,sizeof(short))!=0))
	{
	    return MSGID_OR_SERIALNUMBER_UNMATCHED;
	}

	LpCBEMessage=(CBEMESSAGE_t *)&ProcessData[s_OriginalPid.iProcessId][0];

	//从预约发送小区列表中减去要删除的小区列表
	//-----------------------------------------
    if (LPWriteReplace_Request->p_CellList.cCellIdDisc==
		LpKillMessage->p_CellList.cCellIdDisc)
	{
		//遍历删除列表
		for(i=0;i<LpKillMessage->p_CellList.iLength;i++) 
		{
			for(j=0;j<LPWriteReplace_Request->p_CellList.iLength;j++)
			{
				if (memcmp(&LpKillMessage->p_CellList.s_CellList[i].cCellId[0],
					&LPWriteReplace_Request->p_CellList.s_CellList[j].cCellId[0],
					sizeof(CELLID_t))==0)
				{
					memcpy(ListBuf, &LPWriteReplace_Request->p_CellList.s_CellList[j+1],(LPWriteReplace_Request->p_CellList.iLength-j-1)*4);
					memcpy(&LPWriteReplace_Request->p_CellList.s_CellList[j],ListBuf,(LPWriteReplace_Request->p_CellList.iLength-j-1)*4);
					j--;
					LPWriteReplace_Request->p_CellList.iLength--;
					break;
				}
			}
		}
	}

	if (LPWriteReplace_Request->p_CellList.iLength>0)
	{
		return SUCCESS;
	}
	//-----------------------------------------

	//释放定时器
	iReturnValue=kill_timer(LPs_WriteReplaceProcessDataStruct->iScheduleTimerId, (char *)&s_OriginalPid);
	if (iReturnValue<0)
	{
		//sys
		printf("Kill timer error!\n");
		return FAILURE;
	}

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

	return SUCCESS;
}

/* 
  返回响应给CBCProxy 
  只报告KillMessage的响应
*/
void Process_KillMessage_Return_To_CBCProxy(PID_t s_Pid)
{
	int                                iPosi; 
	char                               ResponseBuf[3096];
	KILL_PROCESS_DATA_STRUCT           *LPm_KillProcessDataStruct;
	KILLMESSAGE_t                      *LPm_KillMessage;   
	REPORT_MESSAGE_i                   *LPs_Report;  
	int                                i;
	unsigned short                     iLen;
	CELLLIST_i                         s_FailureList;

	memset(&s_FailureList,0,sizeof(CELLLIST_i));

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

	LPm_KillProcessDataStruct=(KILL_PROCESS_DATA_STRUCT *)&ProcessData[s_Pid.iProcessId][0];

	LPm_KillMessage=(KILLMESSAGE_t *)&LPm_KillProcessDataStruct->s_CBCMessage.cMessage[0];
	
	LPs_Report=(REPORT_MESSAGE_i *)&ResponseBuf[sizeof(short)];

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

	LPs_Report->s_MessageHead.iMessageAreaId=A;

	LPs_Report->s_MessageHead.iMessageType=CBCPROXY_REPORT_KILL;

	memcpy(&LPs_Report->p_MessageIdentifier,&LPm_KillMessage->p_MessageIdentifier,sizeof(MESSAGEIDENTIFIER_t));
	memcpy(&LPs_Report->p_Serialnumber,&LPm_KillMessage->p_OldSerialnumber,sizeof(SERIALNUMBER_t));
	memcpy(&LPs_Report->p_ChannelIndicator,&LPm_KillMessage->p_ChannelIndicator,sizeof(CHANNELINDICATOR_t));


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

	/* 完成列表 */
	LPs_Report->bComlListFlag=LPm_KillProcessDataStruct->s_NoofBroadcastComlList.bFlag;
	LPs_Report->cComlListNumberOfBSC=LPm_KillProcessDataStruct->s_NoofBroadcastComlList.cNumberOfBSC;

	/* 失败状态报告列表 */
	LPs_Report->bReportListFlag=CBCBSC_Unpack.p_FailureReportList.bFlag;//LPm_KillProcessDataStruct->s_FailureList.bFlag;
	LPs_Report->cReportListNumberOfBSC=LPm_KillProcessDataStruct->s_FailureList.cNumberOfBSC;

	/* 压缩ComlList参数 */
	for(i=0;i<LPm_KillProcessDataStruct->s_NoofBroadcastComlList.cNumberOfBSC;i++)
	{
		memcpy(&ResponseBuf[iPosi],&LPm_KillProcessDataStruct->s_NoofBroadcastComlList.s_BSC_NoOfBroadCastcoml[i],
    		LPm_KillProcessDataStruct->s_NoofBroadcastComlList.s_BSC_NoOfBroadCastcoml[i].ilength*sizeof(NOOFBROADCASTSCOML_i)+sizeof(short)+BSC_INDENTIFIER_LEN);
		iPosi=iPosi+LPm_KillProcessDataStruct->s_NoofBroadcastComlList.s_BSC_NoOfBroadCastcoml[i].ilength*sizeof(NOOFBROADCASTSCOML_i)
			+sizeof(short)+BSC_INDENTIFIER_LEN;
	}

	/* 只取失败小区 */
	Abstract_Failure_Cell(&LPm_KillProcessDataStruct->s_FailureList,&s_FailureList);

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

	iLen=iPosi-sizeof(short);

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

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

#ifdef DEBUG_PRINT
    printf("KillMessage Return To CBCProxy. Pid=%d\n",s_Pid.iProcessId); 
	Printf_file_ComlList(s_Pid,LPs_Report->s_MessageHead.iMessageType,&LPm_KillProcessDataStruct->s_NoofBroadcastComlList);
	Printf_file_FailList(s_Pid,LPs_Report->s_MessageHead.iMessageType,&s_FailureList);
#endif

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

}

/* 处理KillMessage回复定时器到时 */
int Process_Kill_Response_timer_Expired(PID_t s_Pid)
{
	KILL_PROCESS_DATA_STRUCT          *LPs_KillProcessDataStruct; 
    int                               iReturnValue;
	
	LPs_KillProcessDataStruct=(KILL_PROCESS_DATA_STRUCT *)&ProcessData[s_Pid.iProcessId][0];


	/* 返回全部响应 */
	Process_KillMessage_Return_To_CBCProxy(s_Pid);

	/* 回复定时器置-1 */
	LPs_KillProcessDataStruct->iTimerId=-1;

	/* 没有全响应 */
    /* 创建生命定时器 */  
   	iReturnValue=create_timer((WAIT_RESPONSE_TIME),LIFE_PERIOD,(char *)&s_Pid,NULL);
	if (iReturnValue<0)
	{
		printf("Create Resend timer Error!\n");
		return END;
	}
	LPs_KillProcessDataStruct->iLifeTimerId=iReturnValue;

	return CONTINUANCE;
}