m2pa_sdt.c

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

	const caddr_t opt_ptr;
	const size_t opt_len;
{
	mblk_t *mp;
	struct T_conn_req *p;

	if ( (mp = allocb(sizeof(*p)+dst_len+opt_len, BPRI_MED)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_conn_req *)mp->b_ptpr;
		p->PRIM_type	= T_CONN_REQ;
		p->DEST_length	= dst_len;
		p->DEST_offset	= dst_len ? sizeof(*p) : 0;
		p->OPT_length	= opt_len;
		p->OPT_offset	= opt_len ? sizeof(*p)+dst_len : 0;
		mp->b_wptr += sizeof(*p);
		bcopy(dst_ptr, mp->b_wptr, dst_len);
		mp->b_wptr += dst_len;
		bcopy(opt_ptr, mp->b_wptr, opt_len);
		mp->b_wptr += opt_len;
	}
	return(mp);
}
/*
 *  T_CONN_RES
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *t_conn_res(aq, opt_ptr, opt_len, seq)
	const queue_t *aq;
	const caddr_t opt_ptr;
	const size_t opt_len;
	const uint seq;
{
	mblk_t *mp;
	struct T_conn_res *p;
	if ( (mp = allocb(sizeof(*p)+opt_len, BPRI_MED)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_conn_res *)mp->b_wptr;
		p->PRIM_type	= T_CONN_RES;
		p->QUEUE_ptr	= q;
		p->OPT_length	= opt_len;
		p->OPT_offset	= sizeof(*p);
		p->SEQ_number	= seq;
		mp->b_wptr += sizeof(*p);
		bopy(opt_ptr, mp->b_wptr, opt_len);
		mp->b-wptr += opt_len;
	}
	return(mp);
}
/*
 *  T_DISCON_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *t_discon_req(seq)
	const uint seq;
{
	mblk_t *mp;
	struct T_discon_req *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_discon_req *)mp->b_wptr;
		p->PRIM_type	= T_DISCON_REQ;
		p->SEQ_number	= seq;
		mp->b_wptr += sizeof(*p);
	}
	return(mp);
}
/*
 *  T_ORDREL_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *t_ordrel_req(void)
{
	mblk_t *mp;
	struct T_ordrel_req *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_ordrel_req *)mp->b_wptr;
		p->PRIM_type	= T_ORDREL_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return(mp);
}
/*
 *  T_DATA_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *t_data_req(void)
{
	mblk_t *mp;
	struct T_data_req *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_data_req *)mp->b_wptr;
		p->PRIM_type	= T_DATA_REQ;
		p->MORE_flag	= 0;
		mp->b_wptr += sizeof(*p);
	}
	return(mp);
}
/*
 *  T_EXDATA_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *t_exdata_req(void)
{
	mblk_t *mp;
	struct T_exdata_ind *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_exdata_req *)mp->b_wptr;
		p->PRIM_type	= T_EXDATA_REQ;
		p->MORE_flag	= 0;
		mp->b_wptr += sizeof(*p);
	}
	return(mp);
}
/*
 *  T_OPTDATA_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *t_optdata_req(uint sid)
{
	mblk_t *mp;
	struct T_optdata_req *p;
	struct t_opthdr *oh;
	const size_t opt_len = PAD4(sizeof(*oh)+sizeof(u16))+PAD4(sizeof(*oh)+sizeof(u32));

	if ( (mp = allocb(sizeof(*p)+opt_len, BPRI_MED)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_optdata_req *)mp->b_wptr;
		p->PRIM_type	= T_OPTDATA_REQ;
		p->DATA_flag	= 0;
		p->OPT_length	= opt_len;
		p->OPT_offset	= sizeof(*p);
		mp->b_wptr += sizeof(*p);

		oh = (struct t_opthdr *)mp->b_wptr;
		oh->level   = T_INET_SCTP;
		oh->name    = SCTP_SID;
		oh->length  = sizeof(*oh)+sizeof(u16);
		*((u16 *)oh->value) = sid;
		mp->b_wptr += PAD4(sizeof(*oh)+sizeof(u16));

		oh = (struct t_opthdr *)mp->b_wptr;
		oh->level   = T_INET_SCTP;
		oh->name    = SCTP_PPI;
		oh->length  = sizeof(*oh)+sizeof(u32);
		*((u32 *)oh->value) = SCTP_PPI_M2PA;
		mp->b_wptr += PAD4(sizeof(*oh)+sizeof(u32));
	}
	return(mp);
}
/*
 *  T_UNITDATA_REQ
 *  -------------------------------------------------------------------------
 */
static inline mblk_t *t_unitdata_req(uint sid)
{
	mblk_t *mp;
	struct T_unitdata_req *p;
	struct t_opthdr *oh;
	const size_t dst_len = sizeof(u16);
	const size_t opt_len = PAD4(sizeof(*oh)+sizeof(u32));
	if ( (mp = allocb(sizeof(*p)+dst_len+opt_len)) )
	{
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_unitdata_req *)mp->b_wptr;
		p->PRIM_type	= T_UNITDATA_REQ;
		p->DEST_length	= dst_len;
		p->DEST_offset	= sizeof(*p);
		p->OPT_length	= 0;
		p->OPT_offset	= 0;
		mp->b_wptr += sizeof(*p);

		oh = (struct t_opthdr *)mp->b_wptr;
		oh->level   = T_INET_SCTP;
		oh->name    = SCTP_PPI;
		oh->length  = sizeof(*oh)+sizeof(u32);
		*((u32 *)oh->value) = SCTP_PPI_M2PA;
		mp->b_wptr += PAD4(sizeof(*oh)+sizeof(u32));
	}
	return(mp);
}

/*
 *  =========================================================================
 *
 *  M2PA --> M2PA Peer Primitives (Send Messages)
 *
 *  =========================================================================
 */
static inline int m2pa_send_status(queue_t *q, uint status)
{
	mblk_t *mp, *pp;
	struct m2pa_status *m;

	if ( (pp = t_optdata_req(0)) )
	{
		if ( (mp = allocb(sizeof(*m), BPRI_MED)) )
		{
			mp->b_datap->db_type = M_DATA;
			m = (struct m2pa_status *)mp->b_wptr;
			m->status   = htonl(status);
			mp->b_wptr += sizeof(*m);
			pp->b_cont = mp;

			putnext(WR(q), pp);
			return(0);
		}
		freemsg(pp);
	}
	return -ENOBUFS;
}

/*
 *  M2PA_STATUS_BUSY
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_send_status_busy(queue_t *q)
{
	return m2pa_send_status(q, M2PA_STATUS_BUSY);
}
/*
 *  M2PA_STATUS_NOT_BUSY
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_send_status_not_busy(queue_t *q)
{
	return m2pa_send_status(q, M2PA_STATUS_NOT_BUSY);
}
/*
 *  M2PA_STATUS_PROCESSOR_OUTAGE
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_send_status_processor_outage(queue_t *q)
{
	return m2pa_send_status(q, M2PA_STATUS_PROCESSOR_OUTAGE);
}
/*
 *  M2PA_STATUS_NOT_PROCESSOR_OUTAGE
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_send_status_not_processor_outage(queue_t *q)
{
	return m2pa_send_status(q, M2PA_STATUS_NOT_PROCESSOR_OUTAGE);
}
/*
 *  M2PA_STATUS_IN_SERVICE
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_send_status_in_service(queue_t *q)
{
	return m2pa_send_status(q, M2PA_STATUS_IN_SERVICE);
}
/*
 *  M2PA_SEND_DATA
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_send_data(queue_t *q, u16 sls, mblk_t *dp)
{
	mblk_t *mp;

	if ( (mp = t_optdata_req(sls+1)) )
	{
		mp->b_cont = dp;
		putnext(WR(q), mp);
		return(0);
	}
	return -ENOBUFS;
}
/*
 *  =========================================================================
 *
 *  M2PA State Machine TIMEOUTS
 *
 *  =========================================================================
 */

/*
 *  =========================================================================
 *
 *  M2PA Peer --> M2PA Primitives (Received Messages)
 *
 *  =========================================================================
 */
static int m2pa_recv_status(q, sdu)
	const queue_t *q;
	const mblk_t *dp;
{
	struct m2pa_status *m;

	m = (struct m2pa_status *)sdu->b_rptr;
	switch ( ntohl(m->status) )
	{
		case M2PA_STATUS_BUSY:
		{
			/*
			 *  TODO:
			 */
			freemsg(sdu);
			return(0);
		}
		case M2PA_STATUS_NOT_BUSY:
		{
			/*
			 *  TODO:
			 */
			freemsg(sdu);
			return(0);
		}
		case M2PA_STATUS_PROCESSOR_OUTAGE:
		{
			/*
			 *  TODO:
			 */
			freemsg(sdu);
			return(0);
		}
		case M2PA_STATUS_NOT_PROCESSOR_OUTAGE:
		{
			/*
			 *  TODO:
			 */
			freemsg(sdu);
			return(0);
		}
		case M2PA_STATUS_IN_SERVICE:
		{
			/*
			 *  TODO:
			 */
			freemsg(sdu);
			return(0);
		}
	}
	return -EPROTO;
}
static int m2pa_recv_data(q, sid, sdu)
	const queue_t *q;
	const uint sid;
	const mblk_t *dp;
{
	mblk_t *mp;

	if ( !sid )
		return m2pa_recv_status(q, sdu);

	if ( (mp = sl_pdu_ind()) )
	{
		linkb(mp, sdu);
		putnext(RD(q), mp);
		return(0);
	}
	return -ENOBUFS;
}

/*
 *  =========================================================================
 *
 *  T-Provider (SCTP) --> T-User (M2PA) Primitives (M_PROTO, M_PCPROTO)
 *
 *  =========================================================================
 */

/*
 *  T_INFO_ACK
 */
static int t_info_ack(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_ADDR_ACK
 */
static int t_addr_ack(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_OK_ACK
 */
static int t_ok_ack(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_ERROR_ACK
 */
static int t_error_ack(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_BIND_ACK
 */
static int t_bind_ack(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_OPTMGMT_ACK
 */
static int t_optmgmt_ack(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_CONN_IND
 */
static int t_conn_ind(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_CONN_CON
 */
static int t_conn_con(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_DATA_IND
 */
static int t_data_ind(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_EXDATA_IND
 */
static int t_exdata_ind(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_OPTDATA_IND
 */
static int t_optdata_ind(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_UNITDATA_IND
 */
static int t_unitdata_ind(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_UDERROR_IND
 */
static int t_uderror_ind(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_DISCON_IND
 */
static int t_discon_ind(queue_t *q, mblk_t *pdu)
{
}

/*
 *  T_ORDREL_IND
 */
static int t_ordrel_ind(queue_t *q, mblk_t *pdu)
{
}

static int (*t_prim[])(queue_t *, mblk_t *) =
{
	NULL,			/*  T_CONN_REQ	    0	*/
	NULL,			/*  T_CONN_RES	    1	*/
	NULL,			/*  T_DISCON_REQ    2	*/
	NULL,			/*  T_DATA_REQ	    3	*/
	NULL,			/*  T_EXDATA_REQ    4	*/
	NULL,			/*  T_INFO_REQ	    5	*/
	NULL,			/*  T_BIND_REQ	    6	*/
	NULL,			/*  T_UNBIND_REQ    7	*/
	NULL,			/*  T_UNITDATA_REQ  8	*/
	NULL,			/*  T_OPTMGMT_REQ   9	*/
	NULL,			/*  T_ORDREL_REQ    10	*/
	&t_conn_ind,		/*  T_CONN_IND	    11	*/
	&t_conn_con,		/*  T_CONN_CON	    12	*/
	&t_discon_ind,		/*  T_DISCON_IND    13	*/
	&t_data_ind,		/*  T_DATA_IND	    14	*/
	&t_exdata_ind,		/*  T_EXDATA_IND    15	*/
	&t_info_ack,		/*  T_INFO_ACK	    16	*/
	&t_bind_ack,		/*  T_BIND_ACK	    17	*/
	&t_error_ack,		/*  T_ERROR_ACK	    18	*/
	&t_ok_ack,		/*  T_OK_ACK	    19	*/
	&t_unitdata_ind,	/*  T_UNITDATA_IND  20	*/
	&t_uderror_ind,		/*  T_UDERROR_IND   21	*/
	&t_optmgmt_ack,		/*  T_OPTMGMT_ACK   22	*/
	&t_ordrel_ind,		/*  T_ORDREL_IND    23	*/
	NULL,			/*  T_OPTDATA_REQ   24	*/
	NULL,			/*  T_ADDR_REQ	    25	*/
	&t_optdata_ind,		/*  T_OPTDATA_IND   26	*/
	&t_addr_ack		/*  T_ADDR_ACK	    27	*/
};

/*
 *  =========================================================================
 *
 *  SL-User --> SL-Provider (M2PA) Primitives (M_CTL, M_PROTO, M_PCPROTO)
 *
 *  =========================================================================
 */
static int sdt_daedt_transmission_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_daedt_start_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_daedr_start_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_aerm_start_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_aerm_stop_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_aerm_set_ti_to_tin_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_aerm_set_ti_to_tie_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_suerm_start_req(queue_t *q, mblk_t *pdu)
{
}
static int sdt_suerm_stop_req(queue_t *q, mblk_t *pdu)
{
}

static int (*sdt_prim[])(queue_t *, mblk_t *) =
{
	&sdt_daedt_transmission_req,	/* SDT_OAEDT_TRANSMISSION_REQ		*/
	&sdt_daedt_start_req,		/* SDT_DAEDT_START_REQ			*/
	&sdt_daedr_start_req,		/* SDT_DAEDR_START_REQ			*/
	&sdt_aerm_start_req,		/* SDT_AERM_START_REQ			*/
	&sdt_aerm_stop_req,		/* SDT_AERM_STOP_REQ			*/
	&sdt_aerm_set_ti_to_tin_req,	/* SDT_AERM_SET_TI_TO_TIN_REQ		*/
	&sdt_aerm_set_ti_to_tie_req,	/* SDT_AERM_SET_TI_TO_TIE_REQ		*/
	&sdt_suerm_start_req,		/* SDT_SUERM_START_REQ			*/
	&sdt_suerm_stop_req		/* SDT_SUERM_STOP_REQ			*/
};

/*
 *  =========================================================================
 *
 *  M2PA IOCTLs
 *
 *  =========================================================================
 */

static int (*m2pa_ioctl[])(queue_t *, uint, void *) =
{
};

/*
 *  =========================================================================
 *
 *  M2PA STREAMS Message Handling
 *
 *  =========================================================================
 *
 *  M_DATA Handling
 *
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_w_data(queue_t *q, mblk_t *mp)
{
	return m2pa_send_data(q, 0, mp);
}
static inline int m2pa_r_data(queue_t *q, mblk_t *mp)
{
	m2pa_t *m2 = (m2pa_t *)q->q_ptr;
	return m2pa_recv_data(q, m2->sid, mp);
}
/*
 *  -------------------------------------------------------------------------
 *
 *  M_PROTO, M_PCPROTO Handling
 *
 *  -------------------------------------------------------------------------
 */
static inline int m2pa_w_proto(queue_t *q, mblk_t *mp)
{
	int prim = ((union SDT_primitives *)(mp->b_rptr))->sdt_primitive - SDT_DSTR_FIRST;
	if ( 0 <= prim && prim <= SDT_DSTR_LAST - SDT_DSTR_FIRST )
		if ( sdt_prim[prim] )
			return (*sdt_prim[prim])(q, mp);
	return(-EOPNOTSUPP);
}
static inline int m2pa_r_proto(queue_t *q, mblk_t *mp)
{
	int prim = ((union T_primitives *)(mp->b_rptr))->type;
	if ( 0 <= prim && prim < sizeof(n_prim)/sizeof(void *) )
		if ( t_prim[prim] )
			return (*t_prim[prim])(q, mp);
	return(-EOPNOTSUPP);
}
static inline int m2pa_w_pcproto(queue_t *q, mblk_t *mp)
{