m2pa_slm.c

No7信令,我需要交换类似的代码, 请店长审核,谢谢了,急着交换,谢谢

			return(0);
		case MS_PROCESSOR_OUTAGE:
			if ( !(sl->flags & MF_RPO) ) {
				if ( (err = sl_remote_processor_outage_ind(sl)) )
					return(err);
				sl->flags |= MF_RPO;
			}
			if ( sl->notify.events & SL_EVT_RPO_BEGIN )
				if ( (err = lmi_event_ind(sl, SL_EVT_RPO_BEGIN, 0, NULL, 0)) )
					return(err);
			ptrace(("RPO Begins\n"));
			return(0);
	}
	ptrace(("Received status PROCESSOR_OUTAGE in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_local_processor_outage(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_OUT_OF_SERVICE:
		case MS_NOT_ALIGNED:
		case MS_ALIGNED:
		case MS_PROVING:
			/* just remember for later */
			sl->flags |= MF_LPO;
			return(0);
		case MS_ALIGNED_READY:
			if ( (err = sl_send_status(sl, M2PA_STATUS_PROCESSOR_OUTAGE)) )
				return(err);
			sl->flags |= MF_LPO;
			sl_timer_stop(sl, t7);
			sl_timer_stop(sl, t6);
			sl->flags &= ~MF_RECV_MSU;
			sl->state = MS_ALIGNED_NOT_READY;
			return(0);
		case MS_IN_SERVICE:
			if ( (err = sl_send_status(sl, M2PA_STATUS_PROCESSOR_OUTAGE)) )
				return(err);
			sl->flags |= MF_LPO;
			sl_timer_stop(sl, t7);
			sl_timer_stop(sl, t6);
			sl->flags &= ~MF_RECV_MSU;
			switch ( sl->option.pvar )
			{
				default:
				case SS7_PVAR_ITUT_93:
				case SS7_PVAR_ITUT_96:
					sl->flags &= ~MF_CONTINUE;
					break;
				case SS7_PVAR_ANSI_92:
					sl->rack += xchg(&sl->rmsu,0);
					fixme(("Bad idea\n"));
					if ( sl->flags & MF_LOC_BUSY )
						if ( (err = sl_send_status(sl, M2PA_STATUS_BUSY_ENDED)) )
							return(err);
					sl->flags &= ~MF_LOC_BUSY;
					break;
			}
			sl_rpo_stats(sl);
			sl->state = MS_PROCESSOR_OUTAGE;
			return(0);
		case MS_PROCESSOR_OUTAGE:
			if ( !(sl->flags & MF_LPO) )
				if ( (err = sl_send_status(sl, M2PA_STATUS_PROCESSOR_OUTAGE)) )
					return(err);
			sl->flags |= MF_LPO;
			sl_timer_stop(sl, t7);  /* ??? */
			sl_timer_stop(sl, t6);  /* ??? */
			return(0);
	}
	ptrace(("Received primitive SL_LOCAL_PROCESSOR_OUTAGE_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_clear_rtb(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_PROCESSOR_OUTAGE:
			bufq_purge(&sl->rtb);
			sl->tack = 0;
			sl->flags &= ~MF_RTB_FULL;
			sl->flags &= ~MF_CLEAR_RTB;
			if ( (err = sl_rtb_cleared_ind(sl)) )
				return(err);
			if ( (err = sl_check_congestion(sl)) )
				return(err);
			sl_timer_stop(sl, t7);
			sl_timer_stop(sl, t6);
			sl->flags &= ~MF_LPO;
			if ( sl->flags & MF_RPO ) {
				if ( sl->notify.events & SL_EVT_RPO_END )
					if ( (err = lmi_event_ind(sl, SL_EVT_RPO_END, 0, NULL, 0)) )
						return(err);
				ptrace(("RPO Ends\n"));
				sl_rpr_stats(sl);
				sl->flags &= ~MF_RPO;
			}
			sl->flags &= ~MF_SEND_MSU;
			sl->flags |= MF_SEND_MSU;
			if ( (err = sl_remote_processor_recovered_ind(sl)) )
				return(err);
			sl_is_stats(sl);
			sl->state = MS_IN_SERVICE;
			return(0);
	}
	ptrace(("Received primitive SL_CLEAR_RTB_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_clear_buffers(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_OUT_OF_SERVICE:
		case MS_NOT_ALIGNED:
		case MS_ALIGNED:
		case MS_PROVING:
			switch ( sl->option.pvar )
			{
				default:
				case SS7_PVAR_ITUT_93:
				case SS7_PVAR_ITUT_96:
					return(0);
				case SS7_PVAR_ANSI_92:
					if ( (err = sl_rtb_cleared_ind(sl)) )
						return(err);
					sl->flags &= ~MF_LPO;  /* ??? */
					return(0);
			}
			return(0);
		case MS_ALIGNED_NOT_READY:
			switch ( sl->option.pvar )
			{
				default:
				case SS7_PVAR_ITUT_93:
				case SS7_PVAR_ITUT_96:
					return(0);
				case SS7_PVAR_ANSI_92:
					if ( (err = sl_rtb_cleared_ind(sl)) )
						return(err);
					sl->flags &= ~MF_LPO;
					sl_timer_stop(sl, t7);  /* ??? */
					sl_timer_stop(sl, t6);  /* ??? */
					sl->flags &= ~MF_SEND_MSU;
					sl->state = MS_ALIGNED_READY;
					return(0);
			}
			return(0);
		case MS_PROCESSOR_OUTAGE:
			bufq_purge(&sl->rtb);
			sl->tack = 0;
			bufq_purge(&sl->tb);
			flushq(sl->wq, FLUSHDATA);
			sl_timer_stop(sl, t7);
			sl_timer_stop(sl, t6);
			sl->flags &= ~MF_RTB_FULL;
			sl->flags &= ~MF_CLEAR_RTB;
			if ( (err = sl_check_congestion(sl)) )
				return(err);
			switch ( sl->option.pvar )
			{
				default:
				case SS7_PVAR_ITUT_93:
				case SS7_PVAR_ITUT_96:
					sl->flags &= ~MF_NEED_FLUSH;
					if ( sl->flags & MF_CONTINUE ) {
						sl->flags |= MF_NEED_FLUSH;
						break;
					}
					return(0);
				case SS7_PVAR_ANSI_92:
					if ( (err = sl_rtb_cleared_ind(sl)) )
						return(err);
					bufq_purge(&sl->rb);
					flushq(sl->rq, FLUSHDATA);
					if ( (err = sl_rb_cleared_ind(sl)) )
						return(err);
					if ( sl->flags & MF_RPO ) {
						if ( (err = sl_remote_processor_recovered_ind(sl)) )
							return(err);
						sl->flags &= ~MF_RPO;
					}
					if ( sl->notify.events & SL_EVT_RPO_END )
						if ( (err = lmi_event_ind(sl, SL_EVT_RPO_END, 0, NULL, 0)) )
							return(err);
					ptrace(("RPO Ends\n"));
					sl_rpr_stats(sl);
					break;
			}
			sl->flags |= MF_RECV_MSU;
			sl->flags |= MF_SEND_MSU;
			sl->flags &= ~MF_LPO;
			sl_is_stats(sl);
			sl->state = MS_IN_SERVICE;
			return(0);
	}
	ptrace(("Received primitive SL_CLEAR_BUFFERS_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static void sl_lsc_no_processor_outage(sl_t* sl)
{
	switch ( sl->state )
	{
		case MS_PROCESSOR_OUTAGE:
			sl->flags |= MF_CONTINUE;
			if ( !(sl->flags & MF_NEED_FLUSH) )
			{
				sl->flags &= ~MF_LPO;
				sl->flags |= MF_NEED_FLUSH;
				sl->flags |= MF_RECV_MSU;
				sl->flags |= MF_SEND_MSU;
				if ( sl->rtb.q_count ) {
					if ( sl->flags & MF_REM_BUSY )
						sl_timer_start(sl, t6);
					else	sl_timer_start(sl, t7);
				}
				sl_is_stats(sl);
				sl->state = MS_IN_SERVICE;
			}

	}
}

#if 0
/* This was the blue book way of doing things... */
static int sl_lsc_continue(sl_t* sl, mblk_t *mp)
{
	switch ( sl->state )
	{
		case MS_PROCESSOR_OUTAGE:
			if ( sl->flags & MF_CONTINUE )
			{
				sl->flags |= MF_NEED_FLUSH;
				sl->flags |= MF_RECV_MSU;
				sl->flags |= MF_SEND_MSU;
				if ( sl->rtb.q_count ) {
					if ( sl->flags & MF_REM_BUSY )
						sl_timer_start(sl, t6);
					else	sl_timer_start(sl, t7);
				}
				sl->flags &= ~MF_LPO;
				sl_is_stats(sl);
				sl->state = MS_IN_SERVICE;
			}
			return(0);

	}
	ptrace(("Received primitive SL_CONTINUE_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}
#endif

static int sl_lsc_status_processor_outage_ended(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_PROCESSOR_OUTAGE:
			if ( sl->flags & MF_RPO ) {
				if ( (err = sl_remote_processor_recovered_ind(sl)) )
					return(err);
				if ( sl->notify.events & SL_EVT_RPO_END )
					if ( (err = lmi_event_ind(sl, SL_EVT_RPO_END, 0, NULL, 0)) )
						return(err);
				sl->flags &= ~MF_RPO;
				ptrace(("RPO Ends\n"));
			}
			sl_rpr_stats(sl);
			switch ( sl->option.pvar )
			{
				default:
				case SS7_PVAR_ITUT_93:
				case SS7_PVAR_ITUT_96:
					/* auto recover */
					if ( !(sl->flags & MF_LPO) )
						sl_lsc_no_processor_outage(sl);
					break;
				case SS7_PVAR_ANSI_92:
					/* leave state latched */
					break;
			}
			return(0);
	}
	ptrace(("Received status PROCESSOR_OUTAGE_ENDED in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_resume(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_OUT_OF_SERVICE:
		case MS_NOT_ALIGNED:
		case MS_ALIGNED:
		case MS_PROVING:
			/* remember for later */
			sl->flags &= ~MF_LPO;
			return(0);
		case MS_ALIGNED_READY :
			fixme(("This is really an error...\n"));
			return(0);
		case MS_ALIGNED_NOT_READY :
			sl->flags &= ~MF_LPO;
			switch (sl->option.pvar )
			{
				case SS7_PVAR_ITUT_96:
					if ( !(sl->flags & MF_RPO) )
						sl_lsc_no_processor_outage(sl);
					sl->flags |= MF_RECV_MSU;	/* ??? */
					break;
				case SS7_PVAR_ANSI_92:
					break;
				default:
					if ( !(sl->flags & MF_RPO) )
						sl_lsc_no_processor_outage(sl);
					break;
			}
			sl_timer_stop(sl, t7);
			sl_timer_stop(sl, t6);
			sl->flags &= ~MF_SEND_MSU;
			sl->state = MS_ALIGNED_READY;
			return(0);
		case MS_PROCESSOR_OUTAGE:
			/*
			 *  This is where the really wierd behavior begins...
			 */
			switch ( sl->option.pvar )
			{
				default:
				case SS7_PVAR_ITUT_93:
				case SS7_PVAR_ITUT_96:
					if ( sl->flags & MF_LPO ) {
						if ( (err = sl_send_status(sl, M2PA_STATUS_PROCESSOR_OUTAGE_ENDED)) )
							return(err);
						sl->flags &= ~MF_LPO;
					}
					if ( !(sl->flags & MF_RPO) )
						sl_lsc_no_processor_outage(sl);
					sl->rack += xchg(&sl->rmsu,0);
					sl->flags &= ~MF_CONG_DISCARD;
					sl->flags &= ~MF_CONG_ACCEPT;
					if ( sl->flags & MF_LOC_BUSY )
						if ( (err = sl_send_status(sl, M2PA_STATUS_BUSY_ENDED)) )
							return(err);
					sl->flags &= ~MF_LOC_BUSY;
					sl_timer_stop(sl, t7);
					sl_timer_stop(sl, t6);
					sl->flags &= ~MF_SEND_MSU;
					return(0);
				case SS7_PVAR_ANSI_92:
					/* XXX do we do this now??? */
					if ( sl->flags & MF_LPO ) {
						if ( (err = sl_send_status(sl, M2PA_STATUS_PROCESSOR_OUTAGE_ENDED)) )
							return(err);
						sl->flags &= ~MF_LPO;
					}
					sl->flags |= MF_RECV_MSU;
					if ( sl->flags & MF_RPO )
					{
						sl_timer_stop(sl, t7);
						sl_timer_stop(sl, t6);
						sl->flags &= ~MF_SEND_MSU;
						fixme(("We should not do this...\n"));
						if ( (err = sl_remote_processor_outage_ind(sl)) )
							return(err);
						return(0);
					}
					sl->flags |= MF_SEND_MSU;
					if ( sl->rtb.q_count ) {
						if ( sl->flags & MF_REM_BUSY )
							sl_timer_start(sl, t6);
						else	sl_timer_start(sl, t7);
					}
					break;
			}
			sl_is_stats(sl);
			sl->state = MS_IN_SERVICE;
			return(0);
	}
	ptrace(("Received primitive SL_RESUME_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_status_out_of_service(sl_t *sl) 
{
	int err;
	switch ( sl->state )
	{
		case MS_ALIGNED_READY:
		case MS_ALIGNED_NOT_READY:
		case MS_IN_SERVICE:
		case MS_PROCESSOR_OUTAGE:
			sl->flags &= ~MF_REM_INS;
			if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_RECEIVED_SIOS)) )
				return(err);
			if ( sl->notify.events & SL_EVT_FAIL_RECEIVED_SIOS )
				if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_RECEIVED_SIOS, 0, NULL, 0)) )
					return(err);
			ptrace(("Link failed: Received SIOS\n"));
			return(0);
		case MS_ALIGNED:
		case MS_PROVING:
			sl->flags &= ~MF_REM_INS;
			if ( (err = sl_lsc_out_of_service(sl, SL_FAIL_ALIGNMENT_NOT_POSSIBLE)) )
				return(err);
			if ( sl->notify.events & SL_EVT_FAIL_ALIGNMENT )
				if ( (err = lmi_event_ind(sl, SL_EVT_FAIL_ALIGNMENT, 0, NULL, 0)) )
					return(err);
			ptrace(("Link failed: Alignment not possible\n"));
			sl->stats.sl_fail_align_or_proving++;
			return(0);
		case MS_POWER_OFF:
		case MS_OUT_OF_SERVICE:
		case MS_NOT_ALIGNED:
			return(0);
	}
	ptrace(("Received status OUT_OF_SERVICE in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_retrieve_bsnt(sl_t *sl)
{
	switch ( sl->state )
	{
		case MS_OUT_OF_SERVICE:
		case MS_PROCESSOR_OUTAGE:
			sl_bsnt_ind(sl, sl->fsnr);
			return(0);
	}
	ptrace(("Received primitive SL_RETRIEVE_BSNT_REQ in unexpected state %u\n",sl->state));
	return(-EPROTO);
}

static int sl_lsc_retrieval_request_and_fsnc(sl_t *sl, ulong fsnc)
{
	int err;
	mblk_t *mp;
	switch ( sl->state )
	{
		case MS_OUT_OF_SERVICE:
		case MS_PROCESSOR_OUTAGE:
			/*
			 *  FIXME: Q.704/5.7.2 states:
			 *
			 *  5.7.2   If a changeover order or acknowledgement
			 *  containing an unreasonable value of the forward
			 *  sequence number is received, no buffer updating or
			 *  retrieval is performed, and new traffic is started
			 *  on the alternative signalling link(s).
			 *
			 *  It will be necessary to check FSNC for
			 *  "reasonableness" here and flush RTB and TB and
			 *  return retrieval-complete indication with a return
			 *  code of "unreasonable FSNC".
			 */
			fixme(("Fix this check...\n"));
			/*
			 *  this will pretty much clear the rtb if there is a
			 *  problem with the FSNC
			 */
			while ( sl->rtb.q_head && sl->fsnt != fsnc )
			{
				freemsg(bufq_dequeue(&sl->rtb));
				sl->fsnt--;
			}
			while ( (mp = bufq_dequeue(&sl->rtb)) )
			{
				if ( (err = sl_retrieved_message_ind(sl, mp)) ) 
				{
					bufq_queue_head(&sl->rtb, mp);
					return(err);
				}
				sl->flags &= ~MF_RTB_FULL;
			}
			while ( (mp = bufq_dequeue(&sl->tb)) )
			{
				if ( (err = sl_retrieved_message_ind(sl, mp)) )
				{
					bufq_queue_head(&sl->tb, mp);
					return(err);
				}
			}
			if ( (err = sl_retrieval_complete_ind(sl)) )
				return(err);
			return(0);
	}
	pt