File /code/strss7/drivers/m3ua/m3ua_nsp.h

#ifndef __M3UA_NSP_H__
#define __M3UA_NSP_H__

#include "../../include/npi.h"

/*
 *  =========================================================================
 *
 *  M3UA --> NSP (Network Service Provider)
 *
 *  =========================================================================
 *
 *  M3UA state machine and layer management use these inlines to generate
 *  primitives to be sent to the Network Service Provider (NSP) for
 *  underlying transports to the ASP based on the NPI.
 */
/*
 *  N_CONN_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_CONN_RES
 *  -------------------------------------------------------------------------
 */
/*
 *  N_DISCON_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_DATA_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_EXDATA_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_INFO_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_BIND_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_UNBIND_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_UNITDATA_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_OPTMGMT_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_DATACK_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_RESET_REQ
 *  -------------------------------------------------------------------------
 */
/*
 *  N_RESET_RES
 *  -------------------------------------------------------------------------
 */

/*
 *  T_INFO_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_info_req(void)
{
	mblk_t *mp;
	struct T_info_req *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (struct T_info_req *) mp->b_wptr;
		p->PRIM_type = T_INFO_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  T_ADDR_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_addr_req(void)
{
	mblk_t *mp;
	struct T_addr_req *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (struct T_addr_req *) mp->b_wptr;
		p->PRIM_type = T_ADDR_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  T_OPTMGMT_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_optmgmt_req(opt_ptr, opt_len, flags)
	const caddr_t opt_ptr;
	const size_t opt_len;
	const uint flags;
{
	mblk_t *mp;
	struct T_optmgmt_req *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (struct T_optmgmt_req_t *) mp->b_wptr;
		p->PRIM_type = T_OPTMGMT_REQ;
		p->OPT_length = opt_len;
		p->OPT_offset = opt_len ? sizeof(*p) : 0;
		p->MGMT_flags = flags;
		mp->b_wptr += sizeof(*p);
		bcopy(opt_ptr, mp->b_wptr, opt_len);
		mp->b_wptr += opt_len;
	}
	return (mp);
}

/*
 *  T_BIND_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_bind_req(add_ptr, add_len, cons)
	const caddr_t add_ptr;
	const size_t add_len;
	const uint cons;
{
	mblk_t *mp;
	struct T_bind_req *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (struct T_bind_req *) mp->b_wptr;
		p->PRIM_type = T_BIND_REQ;
		p->ADDR_length = add_len;
		p->ADDR_offset = add_len ? sizeof(*p) : 0;
		p->CONIND_number = cons;
		mp->b_wptr += sizeof(*p);
		bcopy(add_ptr, mp->b_wptr, add_len);
		mp->b_wptr += add_len;
	}
	return (mp);
}

/*
 *  T_UNBIND_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_unbind_req(void)
{
	mblk_t *mp;
	struct T_unbind_req *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PCPROTO;
		p = (struct T_unbind_req *) mp->b_wptr;
		p->PRIM_type = T_UNBIND_REQ;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  T_CONN_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_conn_req(dst_ptr, dst_len, opt_ptr, opt_len)
	const caddr_t dst_ptr;
	const size_t dst_len;
	const caddr_t opt_ptr;
	const caddr_t opt_len;
{
	mblk_t *mp;
	struct T_conn_req *p;
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_conn_req *) mp->b_wptr;
		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), BPRI_MED))) {
		mp->b_datap->db_type = M_PROTO;
		p = (struct T_conn_res *) mp->b_wptr;
		p->PRIM_type = T_CONN_RES;
		p->ACCEPTOR_id = (t_scalar_t) aq;
		p->OPT_length = opt_len;
		p->OPT_offset = opt_len ? sizeof(*p) : 0;
		p->SEQ_number = seq;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  T_DATA_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_data_req(flag)
	const uint flag;
{
	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 = flag;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  T_EXDATA_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_exdata_req(flag)
	const uint flag;
{
	mblk_t *mp;
	struct T_exdata_req *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 = flag;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

/*
 *  T_OPTDATA_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_optdata_req(flag, opt_ptr, opt_len)
	const uint flag;
	const caddr_t opt_ptr;
	const size_t opt_len;
{
	mblk_t *mp;
	struct T_optdata_req *p;
	if ((mp = allocb(sizeof(*p), 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 = flag;
		p->OPT_length = opt_len;
		p->OPT_offset = opt_len ? sizeof(*p) : 0;
		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_DISCON_REQ
 *  -------------------------------------------------------------------------
 */
static __inline__ mblk_t *t_discon_req(void)
{
	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;
		mp->b_wptr += sizeof(*p);
	}
	return (mp);
}

#endif				/* __M3UA_NSP_H__ */