sdt2.c

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

sdt_timer_stop_t8(sdt_t *s)
{
	if ( s->timers.t8 ) untimeout(s->timers.t8);
}
static void
sdt_timer_start_t8(sdt_t *s)
{
	sdt_timer_stop_t8(s);
	s->timers.t8 = timeout(
			(timo_fcn_t *)sdt_t8_timeout,
			(caddr_t)s, s->config.t8);
}
static void
sdt_t8_timeout(sdt_t *s)
{
	if ( s->statem.eim_state == SDT_STATE_MONITORING )
	{
		sdt_timer_start_t8(s);
#if 0   /* probably just limit compress count */
		if ( s->option.popt & SS7_POPT_PING )
		{
			int psw;            /* force frame once per t8 */
			SPLSTR(psw);
			s->device->ifflags &= ~SDT_IF_SU_REPEAT;
			SPLX(psw);
		}
#endif
		if (s->statem.su_received)
		{
			s->statem.su_received = 0;
			if ( !s->statem.interval_error )
			{
				if ( (s->statem.Ce -= s->config.De) < 0 )
					s->statem.Ce = 0;
				return;
			}
		}
		s->statem.Ce += s->config.Ue;
		s->statem.interval_error = 0;
		if ( s->statem.Ce > s->config.Te )
		{
			sdt_lsc_link_failure_ind(s); /*-upstream-*/
			s->statem.eim_state = SDT_STATE_IDLE;
		}
	}
}
static void
sdt_eim_start(sdt_t *s)
{
	s->statem.Ce = 0;
	s->statem.interval_error = 0;
	s->statem.su_received = 0;
	sdt_timer_start_t8(s);
	s->statem.eim_state = SDT_STATE_MONITORING;
}
static void
sdt_eim_stop(sdt_t *s)
{
	s->statem.eim_state = SDT_STATE_IDLE;
	sdt_timer_stop_t8(s);
}
static int
sdt_daedr_correct_su(sdt_t *s, int count)
{
	int i;
	for ( i=0; i<count; i++)
	{
		sdt_eim_correct_su(s);
		sdt_suerm_correct_su(s);
		sdt_aerm_correct_su(s);
	}
	return(0);
}
static int
sdt_daedr_su_in_error(sdt_t *s)
{
	sdt_suerm_su_in_error(s);
	sdt_aerm_su_in_error(s);
	return(0);
}
static int
sdt_daedr_received_bits(sdt_t *s, mblk_t *mp)
{
	sdt_rc_signal_unit_ind(s, mp);   /*-upstream-*/
	sdt_daedr_correct_su(s, 1);
	return(1);
}
static int
sdt_daedt_transmission_request(sdt_t *s)
{
	sdt_txc_transmission_request_ind(s); /*-upstream-*/
	return(0);
}
static int
sdt_aerm_set_ti_to_tin(sdt_t *s)
{
	if ( s->statem.aerm_state == SDT_STATE_IDLE )
		s->statem.Ti = s->config.Tin;
	return(0);
}
static int
sdt_aerm_set_ti_to_tie(sdt_t *s)
{
	if ( s->statem.aerm_state == SDT_STATE_IDLE )
		s->statem.Ti = s->config.Tie;
	return(0);
}
static int
sdt_aerm_start(sdt_t *s)
{
	s->statem.Ca = 0;
	s->statem.aborted_proving = 0;
	s->statem.aerm_state = SDT_STATE_MONITORING;
	return(0);
}
static int
sdt_aerm_stop(sdt_t *s)
{
	s->statem.aerm_state = SDT_STATE_IDLE;
	s->statem.Ti = s->config.Tin;
	return(0);
}
static int
sdt_daedt_start(sdt_t *s)
{
	if ( s->statem.daedt_state == SDT_STATE_IDLE )
	{
		sdl_daedt_start_req(s);
		s->statem.daedt_state = SDT_STATE_IN_SERVICE;
	}
	return(0);
}
static int
sdt_daedr_start(sdt_t *s)
{
	if ( s->statem.daedr_state == SDT_STATE_IDLE )
	{
		sdl_daedr_start_req(s);
		s->statem.daedr_state = SDT_STATE_IN_SERVICE;
	}
	return(0);
}
static int
sdt_daedt_transmission(sdt_t *s, mblk_t *mp)
{
	if ( s->statem.daedt_state != SDT_STATE_IDLE )
	{
		putnext(s->wq, mp);
		return(1);
	}
	return(0);
}
static int
sdt_suerm_eim_start(sdt_t *s)
{
	if ( s->option.popt & SS7_POPT_HSL )
		sdt_eim_start(s);
	else	sdt_suerm_start(s);
	return(0);
}
static int
sdt_suerm_eim_stop(sdt_t *s)
{
	sdt_eim_stop(s);
	sdt_suerm_stop(s);
	return(0);
}

/*
 *  =========================================================================
 *
 *  INPUT Events
 *
 *  =========================================================================
 */
/*
 *  -------------------------------------------------------------------------
 *
 *  SDT User -> SDT Provider Primtives
 *
 *  -------------------------------------------------------------------------
 */
/*
 *  LMI_INFO_REQ
 *  -----------------------------------
 */
static int
lmi_info_req(sdt_t *s, mblk_t *mp)
{
	(void)mp;
	return lmi_info_ack(s);
}
/*
 *  LMI_ATTACH_REQ
 *  -----------------------------------
 */
static int
lmi_attach_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	lmi_attach_req_t *p = (lmi_attach_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( s->i_state == LMI_UNATTACHED ) { s->i_state == LMI_ATTACH_PENDING;
		lmi_error_ack(s, LMI_ATTACH_REQ, LMI_NOTSUPP);
	} seldom(); err = LMI_OUTSTATE;	    break;  /* would place interface out of state   */
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short		    */
	} while(0); seldom(); return lmi_error_ack(s, LMI_ATTACH_REQ, err);
}
/*
 *  LMI_DETACH_REQ
 *  -----------------------------------
 */
static int
lmi_detach_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	lmi_detach_req_t *p = (lmi_detach_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( s->i_state == LMI_DISABLE ) { s->i_state = LMI_DETACH_PENDING;
		lmi_error_ack(s, LMI_DETACH_REQ, LMI_NOTSUPP);
	} seldom(); err = LMI_OUTSTATE;	    break;  /* would place interface out of state   */
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short		    */
	} while(0); seldom(); return lmi_error_ack(s, LMI_DETACH_REQ, err);
/*
 *  LMI_ENABLE_REQ
 *  -----------------------------------
 */
static int
lmi_enable_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	lmi_enable_req_t *p = (lmi_enable_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( s->i_state == LMI_DISABLED ) { s->i_state = LMI_ENABLE_PENDING;
		return lmi_enable_con(s);
	} seldom(); err = LMI_OUTSTATE;	    break;  /* would place interface out of state   */
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short		    */
	} while(0); seldom(); return lmi_error_ack(s, LMI_ENABLE_REQ, err);
}
/*
 *  LMI_DISABLE_REQ
 *  -----------------------------------
 */
static int
lmi_disable_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	lmi_disable_req_t *p = (lmi_disable_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( s->i_state == LMI_ENABLED || s->i_state == LMI_ENABLE_PENDING ) {
		if ( (err = sdt_stop(s)) )
			return(err);
		s->i_state = LMI_DISABLE_PENDING;
		return lmi_disable_con(s);
	} seldom(); err = LMI_OUTSTATE;	    break;  /* would place interface out of state   */
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short		    */
	} while(0); seldom(); return lmi_error_ack(s, LMI_DISABLE_REQ, err);
}
/*
 *  LMI_OPTMGMT_REQ	
 *  -----------------------------------
 */
static int
lmi_optmgmt_req	(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	lmi_optmgmt_ack_t *p = (lmi_optmgmt_ack_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		lmi_error_ack(s, LMI_OPTMGMT_REQ, LMI_NOSUPP);
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short		    */
	} while(0); seldom(); return lmi_error_ack(s, LMI_OPTMGMT_REQ, err);
}
/*
 *  SDT_DAEDT_TRANSMISSION_REQ
 *  -----------------------------------
 */
static int
sdt_daedt_transmission_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_daedt_transmission_req_t *p = (sdt_daedt_transmission_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		if ( !sdt_daedt_transmission(s, mp->b_cont) )
			mp->b_cont = NULL;
		return(0);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_DAEDT_TRANSMISSION_REQ, err);
}
/*
 *  SDT_DAEDT_START_REQ
 *  -----------------------------------
 */
static int
sdt_daedt_start_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_daedt_start_req_t *p = (sdt_daedt_start_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_daedt_start(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_DAEDT_START_REQ, err);
}
/*
 *  SDT_DAEDR_START_REQ
 *  -----------------------------------
 */
static int
sdt_daedr_start_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_daedr_start_req_t *p = (sdt_daedr_start_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_daedr_start(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_DAEDR_START_REQ, err);
}
/*
 *  SDT_AERM_START_REQ
 *  -----------------------------------
 */
static int
sdt_aerm_start_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_aerm_start_req_t *p = (sdt_aerm_start_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_aerm_start(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_AERM_START_REQ, err);
}
/*
 *  SDT_AERM_STOP_REQ
 *  -----------------------------------
 */
static int
sdt_aerm_stop_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_aerm_stop_req_t *p = (sdt_aerm_stop_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_aerm_stop(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_AERM_STOP_REQ, err);
}
/*
 *  SDT_AERM_SET_TI_TO_TIN_REQ
 *  -----------------------------------
 */
static int
sdt_aerm_set_ti_to_tin_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_aerm_set_ti_to_tin_req_t *p = (sdt_aerm_set_ti_to_tin_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_aerm_set_ti_to_tin(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_AERM_SET_TI_TO_TIN_REQ, err);
}
/*
 *  SDT_AERM_SET_TI_TO_TIE_REQ
 *  -----------------------------------
 */
static int
sdt_aerm_set_ti_to_tie_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_aerm_set_ti_to_tie_req_t *p = (sdt_aerm_set_ti_to_tie_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_aerm_set_ti_to_tie(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_AERM_SET_TI_TO_TIE_REQ, err);
}
/*
 *  SDT_SUERM_START_REQ
 *  -----------------------------------
 */
static int
sdt_suerm_start_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_suerm_start_req_t *p = (sdt_suerm_start_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_suerm_eim_start(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_SUERM_START_REQ, err);
}
/*
 *  SDT_SUERM_STOP_REQ
 *  -----------------------------------
 */
static int
sdt_suerm_stop_req(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdt_suer_stop_req_t *p = (sdt_suer_stop_req_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_suerm_eim_stop(s);
	} seldom(); err = LMI_PROTOSHORT;   break;
	} while(0); seldom(); return lmi_error_ack(s, SDT_SUERM_STOP_REQ, err);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  SDL Provider -> SDL User Primtives
 *
 *  -------------------------------------------------------------------------
 */
/*
 *  SDL_DAEDR_RECEIVED_BITS_IND
 *  -----------------------------------
 */
static int
sdl_daedr_received_bits_ind(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdl_daedr_received_bits_ind_t *p = (sdl_daedr_received_bits_ind_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_daedr_received_bits(s, mp->b_cont);
	} seldom(); err = -EMSGSIZE;	    break;
	} while(0); seldom(); return(err);
}
/*
 *  SDL_DAEDR_CORRECT_SU_IND
 *  -----------------------------------
 */
static int
sdl_daedr_correct_su_ind(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdl_daedr_correct_su_ind_t *p = (sdl_daedr_correct_su_ind_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_daedr_correct_su(s, p->sdl_count);
	} seldom(); err = -EMSGSIZE;	    break;
	} while(0); seldom(); return(err);
}
/*
 *  SDL_DAEDR_SU_IN_ERROR_IND
 *  -----------------------------------
 */
static int
sdl_daedr_su_in_error_ind(sdt_t *s, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdl_daedr_su_in_serror_ind_t *p = (sdl_daedr_su_in_serror_ind_t *)mp->b_rptr;
	do {
	if ( mlen >= sizeof(*p) ) {
		return sdt_daedr_su_in_error(s);
	} seldom(); err = -EMSGSIZE;	    break;