sdl_sctp.c

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

	mblk_t *mp;
	sdl_daedr_correct_su_ind_t *p;
	ensure( sp , return(-EFAULT) );
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((sdl_daedr_correct_su_ind_t *)mp->b_wptr)++;
		p->sdl_primitive	= SDL_DAEDR_CORRECT_SU_IND;
		p->sdl_count		= count;
		putnext(sp->rq, mp);
		return(0);
	} rare(); return(-ENOBUFS);
}
/*
 *  SDL_DAEDR_SU_IN_ERROR_IND
 *  ---------------------------------------------
 */
static int
sdl_daedr_su_in_error_ind(sdl_t *sp)
{
	mblk_t *mp;
	sdl_daedr_su_in_error_ind_t *p;
	ensure( sp , return(-EFAULT) );
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((sdl_daedr_su_in_error_ind_t *)mp->b_wptr)++;
		p->sdl_primitive	= SDL_DAEDR_SU_IN_ERROR_IND;
		putnext(sp->rq, mp);
		return(0);
	} rare(); return(-ENOBUFS);
}
/*
 *  SDL_DAEDT_TRANSMISSION_REQUEST_IND
 *  ---------------------------------------------
 */
static int
sdl_daedt_transmission_request_ind(sdl_t *sp)
{
	mblk_t *mp;
	sdl_daedt_transmission_request_ind_t *p;
	ensure( sp , return(-EFAULT) );
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((sdl_daedt_transmission_request_ind_t *)mp->b_wptr)++;
		p->sdl_primitive	= SDL_DAEDT_TRANSMISSION_REQUEST_IND;
		putnext(sp->rq, mp);
		return(0);
	} rare(); return(-ENOBUFS);
}
/*
 *  =========================================================================
 *
 *  NPI User (SDL) -> NPI Provider (SCTP) Primitives
 *
 *  =========================================================================
 */
/*
 *  N_DATA_REQ
 *  ---------------------------------------------
 */
static int
n_data_req(sdl_t *sp, ulong flags, void *qos_ptr, size_t qos_len, mblk_t *dp)
{
	mblk_t *mp;
	N_data_req_t *p;
	ensure( sp , return(-EFAULT) );
	ensure( dp , return(-EFAULT) );
	if ( canputnext(sp->wq) ) {
	if ( (mp = allocb(sizeof(*p)+qos_len, BPRI_MED)) ) {
		mp->b_datap->db_type = M_PROTO;
		p = ((N_data_req_t *)mp->b_wptr)++;
		p->PRIM_type		= N_DATA_REQ;
		p->DATA_xfer_flags	= flags;
		bcopy(qos_ptr, mp->b_wptr, qos_len);
		mp->b_wptr += qos_len;
		mp->b_cont = dp;
		putnext(sp->wq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
	} seldom(); return(-EBUSY);
}
/*
 *  N_EXDATA_REQ
 *  ---------------------------------------------
 */
#if 0
static int
n_exdata_req(sdl_t *sp, void *qos_ptr, size_t qos_len, mblk_t *dp)
{
	mblk_t *mp;
	N_exdata_req_t *p;
	ensure( sp , return(-EFAULT) );
	ensure( dp , return(-EFAULT) );
	if ( bcanputnext(sp->wq, 1) ) {
	if ( (mp = allocb(sizeof(*p)+qos_len, BPRI_MED)) ) {
		mp->b_datap->db_type = M_PROTO;
		p = ((N_exdata_req_t *)mp->b_wptr)++;
		p->PRIM_type		= N_EXDATA_REQ;
		bcopy(qos_ptr, mp->b_wptr, qos_len);
		mp->b_wptr += qos_len;
		mp->b_cont = dp;
		putnext(sp->wq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
	} seldom(); return(-EBUSY);
}
#endif

/*
 *  =========================================================================
 *
 *  SDL PDU Message Functions
 *
 *  =========================================================================
 */

#define SDL_PPI	    10

static int
sdl_write(sdl_t *sp, mblk_t *mp)
{
	int err;
	uint xsn = sp->lmi_conf.popt&SS7_POPT_XSN;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	N_qos_sel_data_sctp_t qos = { N_QOS_SEL_DATA_SCTP, SDL_PPI, 0, 0, 0, 0 };

	if ( (err = n_data_req(sp, 0, &qos, sizeof(qos), mp)) )
		return(err);
	if ( (!xsn && mlen > 5 ) || ( xsn && mlen > 8 ) )
		sdl_daedt_transmission_request_ind(sp);
	return(0);
}

/*
 *  =========================================================================
 *
 *  SDL Provider (SDL) <- SDL User Primitives
 *
 *  =========================================================================
 */
/*
 *  LMI_INFO_REQ
 *  ---------------------------------------------
 */
static int
lmi_info_req(sdl_t *sp, mblk_t *mp)
{
	(void)mp;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	return lmi_info_ack(sp);
}
/*
 *  LMI_ATTACH_REQ
 *  ---------------------------------------------
 */
static int
lmi_attach_req(sdl_t *sp, 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;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( sp->state == LMI_UNATTACHED ) { sp->state = LMI_ATTACH_PENDING;

		lmi_error_ack(sp, 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(sp, LMI_ATTACH_REQ, err);
}
/*
 *  LMI_DETACH_REQ
 *  ---------------------------------------------
 */
static int
lmi_detach_req(sdl_t *sp, 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;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( sp->state == LMI_DISABLED ) { sp->state = LMI_DETACH_PENDING;

		lmi_error_ack(sp, 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(sp, LMI_DETACH_REQ, err);
}
/*
 *  LMI_ENABLE_REQ
 *  ---------------------------------------------
 */
static int
lmi_enable_req(sdl_t *sp, 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;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( sp->state == LMI_DISABLED ) { sp->state = LMI_ENABLE_PENDING;

		return lmi_enable_con(sp);

	} 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(sp, LMI_ENABLE_REQ, err);
}
/*
 *  LMI_DISABLE_REQ
 *  ---------------------------------------------
 */
static int
lmi_disable_req(sdl_t *sp, 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;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( sp->state == LMI_ENABLED || sp->state == LMI_ENABLE_PENDING ) {

		sp->state = LMI_DISABLE_PENDING;

		freemsg(xchg(&sp->rx_buf,NULL)); sp->rx_count = 0;
		freemsg(xchg(&sp->tx_buf,NULL)); sp->tx_count = 0;

		return lmi_disable_con(sp);

	} 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(sp, LMI_DISABLE_REQ, err);
}
/*
 *  LMI_OPTMGMT_REQ
 *  ---------------------------------------------
 */
static int
lmi_optmgmt_req(sdl_t *sp, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	lmi_optmgmt_req_t *p = (lmi_optmgmt_req_t *)mp->b_rptr;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( mlen >= sizeof(*p) ) {

		lmi_error_ack(sp, LMI_OPTMGMT_REQ, LMI_NOTSUPP);

	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short	    */
	} while(0); seldom(); return lmi_error_ack(sp, LMI_OPTMGMT_REQ, err);
}

/*
 *  SDL_DAEDT_TRAMSMISSION_REQ
 *  ---------------------------------------------
 */
#ifndef abs
#define abs(x) ((x)<0?-(x):(x))
#endif
static int
m_error_reply(sdl_t *sp, int err)
{
	mblk_t *mp;
	ensure( sp , return(-EFAULT) );
	switch ( err )
	{
		case -EBUSY:
		case -EAGAIN:
		case -ENOMEM:
		case -ENOBUFS:
			seldom(); return(err);
		case 0:
		case 1:
		case 2:
			never(); return(err);
	}
	if ( (mp = allocb(2, BPRI_HI)) )
	{
		mp->b_datap->db_type = M_ERROR;
		*(mp->b_wptr)++ = abs(err);
		*(mp->b_wptr)++ = abs(err);
		putnext(sp->rq, mp);
		return(0);
	}
	rare(); return(-ENOBUFS);
}
static int
sdl_daedt_xmit_req(sdl_t *sp, mblk_t *mp)
{
	int err;
	mblk_t *dp;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdl_daedt_transmission_req_t *p = (sdl_daedt_transmission_req_t *)mp->b_rptr;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( (dp = mp->b_cont) ) {
	if ( mlen >= sizeof(*p) ) {
	if ( sp->state != LMI_DISABLED ) {
	if ( sp->state == LMI_ENABLED ) {
	if ( sp->flags & SDL_FLAG_TX_ENABLED ) {

		if ( (err = sdl_write(sp, dp)) )
			break;
		mp->b_cont = NULL;  /* absorbed data portion */
		return(0);

	} rare(); return(0);			    /* ignore if not enabled		    */
	} seldom(); err = LMI_OUTSTATE;	    break;  /* would place interface out of state   */
	} seldom(); return(0);		    break;  /* ingore data in DISABLED state	    */
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short		    */
	} rare();   err = -EFAULT;	    break;  /* no M_DATA blocks			    */
	} while(0); rare(); return m_error_reply(sp, err); /* XXX */
}
/*
 *  SDL_DAEDT_START_REQ
 *  ---------------------------------------------
 */
static int
sdl_daedt_start_req(sdl_t *sp, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdl_daedt_start_req_t *p = (sdl_daedt_start_req_t *)mp->b_rptr;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( sp->state == LMI_ENABLED ) {

		/* enable the transmitter section */
		sp->flags |= SDL_FLAG_TX_ENABLED;
		return(0);

	} seldom(); err = LMI_OUTSTATE;	    break;  /* would place interface out of state */
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short	    */
	} while(0); rare(); return m_error_reply(sp, err); /* XXX */
}
/*
 *  SDL_DAEDR_START_REQ
 *  ---------------------------------------------
 */
static int
sdl_daedr_start_req(sdl_t *sp, mblk_t *mp)
{
	int err;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	sdl_daedr_start_req_t *p = (sdl_daedr_start_req_t *)mp->b_rptr;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	do {
	if ( mlen >= sizeof(*p) ) {
	if ( sp->state == LMI_ENABLED ) {

		/* enable the receiver section */
		sp->flags |= SDL_FLAG_RX_ENABLED;
		return(0);

	} seldom(); err = LMI_OUTSTATE;	    break;  /* would place interface out of state */
	} seldom(); err = LMI_PROTOSHORT;   break;  /* M_PROTO block too short	    */
	} while(0); rare(); return m_error_reply(sp, err); /* XXX */
}
/*
 *  =========================================================================
 *
 *  NPI User (SDL) <- NPI Provider (SCTP) Primitives
 *
 *  =========================================================================
 */
/*
 *  N_CONN_IND
 *  ---------------------------------------------
 */
static int
n_conn_ind(sdl_t *sp, mblk_t *mp)
{
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	(void)sp; (void)mp; rare(); return(0);
}
/*
 *  N_CONN_CON
 *  ---------------------------------------------
 */
static int
n_conn_con(sdl_t *sp, mblk_t *mp)
{
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	(void)sp; (void)mp; rare(); return(0);
}
/*
 *  N_DISCON_IND
 *  ---------------------------------------------
 */
static int
n_discon_ind(sdl_t *sp, mblk_t *mp)
{
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	(void)sp; (void)mp; rare(); return(0);
}
/*
 *  N_DATA_IND
 *  ---------------------------------------------
 */
static int
n_data_ind(sdl_t *sp, mblk_t *mp)
{
	int err;
	mblk_t *dp;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	N_data_ind_t *p = (N_data_ind_t *)mp->b_rptr;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	ensure( mlen >= sizeof(*p), return(-EFAULT) );

	if ( mlen <= sp->sdl_conf.m ) {
	if ( (dp = mp->b_cont) ) {
	if ( sp->state == LMI_ENABLED ) {
	if ( sp->flags & SDL_FLAG_RX_ENABLED ) {
	if ( canputnext(sp->rq) ) {

		if ( (err = sdl_read(sp, dp)) )
			return(err);
		mp->b_cont = NULL;  /* absorbed data portion */
		return(0);

	} seldom(); return(-EBUSY);	/* flow controlled */
	} seldom(); return(0);		/* ignore unless enabled */
	} rare(); return(-EPROTO);	/* ignore data in other states	*/
	} rare(); return(-EFAULT);
	} rare(); return(-EMSGSIZE);
}
/*
 *  N_EXDATA_IND
 *  ---------------------------------------------
 */
static int
n_exdata_ind(sdl_t *sp, mblk_t *mp)
{
	int err;
	mblk_t *dp;
	size_t mlen = mp->b_wptr - mp->b_rptr;
	N_exdata_ind_t *p = (N_exdata_ind_t *)mp->b_rptr;
	ensure( sp , return(-EFAULT) );
	ensure( mp , return(-EFAULT) );
	ensure( mlen >= sizeof(*p), return(-EFAULT) );

	if ( mlen <= sp->sdl_conf.m ) {
	if ( (dp = mp->b_cont) ) {
	if ( sp->state == LMI_ENABLED ) {
	if ( sp->flags & SDL_FLAG_RX_ENABLED ) {
	if ( bcanputnext(sp->rq, 1) ) {

		if ( (err = sdl_read(sp, dp)) )
			return(err);
		mp->b_cont = NULL;  /* absorbed data portion */