File /code/strss7/drivers/sigtran/m3ua_msgs.h

#ifndef __M3UA_MSGS_H__
#define __M3UA_MSGS_H__

#include "ua_msgs.h"

#ident "@(#) $RCSfile: m3ua_msgs.h,v $ $Name:  $($Revision: 0.8.2.2 $) $Date: 2002/10/18 03:09:21 $"

/*
 *  =========================================================================
 *
 *  M3UA MESSAGE DEFINITIONS:-
 *
 *  =========================================================================
 *
 *  M3UA-Specific Messages: per draft-ietf-sigtran-m3ua-11.txt
 *  -------------------------------------------------------------------
 */
#define M3UA_XFER_DATA		UA_MHDR(1, 0, UA_CLASS_XFER, 0x01)
#define M3UA_XFER_LAST		0x01

/*
 *  M3UA-Specific Parameters: per draft-ietf-sigtran-m3ua-11.txt
 *  -------------------------------------------------------------------
 */
#define M3UA_PARM_NA		UA_PARM(0x0200,sizeof(uint32_t))
#define M3UA_PARM_RESERVED1	UA_PARM(0x0201,0)
#define M3UA_PARM_RESERVED2	UA_PARM(0x0202,0)
#define M3UA_PARM_RESERVED3	UA_PARM(0x0203,0)
#define M3UA_PARM_USER_CAUSE	UA_PARM(0x0204,sizeof(uint32_t))
#define M3UA_PARM_CONG_IND	UA_PARM(0x0205,sizeof(uint32_t))
#define M3UA_PARM_CONCERN_DEST	UA_PARM(0x0206,sizeof(uint32_t))
#define M3UA_PARM_ROUTING_KEY	UA_PARM(0x0207,0)
#define M3UA_PARM_REG_RESULT	UA_PARM(0x0208,sizeof(uint32_t))
#define M3UA_PARM_DEREG_RESULT	UA_PARM(0x0209,sizeof(uint32_t))
#define M3UA_PARM_LOC_KEY_ID	UA_PARM(0x020a,sizeof(uint32_t))
#define M3UA_PARM_DPC		UA_PARM(0x020b,0)
#define M3UA_PARM_SI		UA_PARM(0x020c,0)
#define M3UA_PARM_SSN		UA_PARM(0x020d,0)
#define M3UA_PARM_OPC		UA_PARM(0x020e,0)
#define M3UA_PARM_CIC		UA_PARM(0x020f,0)
#define M3UA_PARM_PROT_DATA	UA_PARM(0x0210,0)
#define M3UA_PARM_RESERVED4	UA_PARM(0x0211,0)
#define M3UA_PARM_REG_STATUS	UA_PARM(0x0212,sizeof(uint32_t))
#define M3UA_PARM_DEREG_STATUS	UA_PARM(0x0213,sizeof(uint32_t))

#define M3UA_CAUSE_UNKNOWN		(0x00)
#define M3UA_CAUSE_UNEQUIPPED		(0x01)
#define M3UA_CAUSE_INACCESSIBLE		(0x02)

#define M3UA_PARM_BASE 0x0200
typedef struct m3ua_parms {
	uint type;
	uint mlen;
	ua_parms_t common;
	parm_t na;
	parm_t reserved1;
	parm_t reserved2;
	parm_t reserved3;
	parm_t user_cause;
	parm_t cong_ind;
	parm_t concern_dest;
	parm_t routing_key;
	parm_t reg_result;
	parm_t dereg_result;
	parm_t loc_key_id;
	parm_t dpc;
	parm_t si;
	parm_t ssn;
	parm_t opc;
	parm_t cic;
	parm_t prot_data;
	parm_t reserved4;
	parm_t reg_status;
	parm_t dereg_status;
#define M3UA_PARM_MAX 20
} m3ua_parms_t;

static inline int m3ua_decode_it(uint32_t * p, uint32_t * e, m3ua_parms_t * m3ua_results)
{
	int len;
	struct ua_parm *pp = NULL;
	m3ua_results->type = (UA_MSG_CLAS(*p) << 8) | UA_MSG_TYPE(*p++);
	m3ua_results->mlen = ntohl(*p++);
	for (;; p += UA_WORDS(len)) {
		int ttag, tag;
		if (p == e)
			break;
		if (p > e - 1 || (len = UA_LENGTH(*p)) < 4)
			return (UA_ECODE_PROTOCOL_ERROR);
		tag = UA_TAG(*p);
		ttag = tag - UA_PARM_BASE;
		if (0 <= ttag && ttag <= UA_PARM_MAX) {
			pp = ((struct ua_parm *) &m3ua_results->common) + ttag;
			if (!pp->num++) {
				/* only decode first occurence */
				pp->u.wptr = p + 1;
				pp->len = len - 4;
				pp->val = ntohl(p[1]);
			}
			continue;
		}
		ttag = tag - M3UA_PARM_BASE;
		if (0 <= ttag && ttag <= M3UA_PARM_MAX) {
			pp = ((struct ua_parm *) &m3ua_results->na) + ttag;
			if (!pp->num++) {
				/* only decode first occurence */
				pp->u.wptr = p + 1;
				pp->len = len - 4;
				pp->val = ntohl(p[1]);
			}
			continue;
		}
		ptrace(("Unrecognized parameter\n"));
		continue;
	}
	return (0);
}

static inline int m3ua_decode_parms(mblk_t * mp, m3ua_parms_t * m3ua_results)
{
	uint32_t *p = (uint32_t *) mp->b_rptr;
	uint32_t *e = (uint32_t *) mp->b_wptr;
	bzero(m3ua_results, sizeof(*m3ua_results));
	return m3ua_decode_it(p, e, m3ua_results);
}

static inline int m3ua_decode_diag(m3ua_parms_t * msg, m3ua_parms_t * m3ua_results)
{
	bzero(m3ua_results, sizeof(*m3ua_results));
	if (msg->common.diag.u.wptr) {
		int len = msg->common.diag.len & ~0x3;
		if (len) {
			uint32_t *p = (uint32_t *) (msg->common.diag.u.wptr);
			uint32_t *e = (uint32_t *) (msg->common.diag.u.cptr + len);
			/* make sure the diagnostic contains an M3UA message */
			if (msg->common.diag.u.cptr[0] == UA_VERSION
			    && msg->common.diag.u.cptr[1] == 0
			    && msg->common.diag.u.cptr[2] <= UA_CLASS_LAST
			    && msg->common.diag.u.cptr[3] <= 0x6 && len == ntohl(p[1])) {
				/* we have a fully formed message */
				return m3ua_decode_it(p, e, m3ua_results);
			}
		}
	}
	return (UA_ECODE_PROTOCOL_ERROR);
}

static inline int m3ua_decode_next(uint32_t * s, uint32_t * e, parm_t * pp)
{
	int len, tag, ftag;
	uint32_t *p = s;
	ensure(pp, return (-EINVAL));
	if (pp->u.wptr)
		p = pp->u.wptr - 1;
	ensure(p, return (-EINVAL));
	ftag = UA_TAG(*p);
	p += UA_LENGTH(*p);
	tag = UA_TAG(*p);

	for (len = UA_LENGTH(*p), p += UA_WORDS(len);
	     p >= s && p < e; p += UA_WORDS(len), tag = UA_TAG(*p), len = UA_LENGTH(*p)) {
		if (tag == ftag) {
			pp->u.wptr = p + 1;
			pp->len = len - 4;
			pp->val = htonl(p[1]);
			return (0);
		}
	}
	return (-EINVAL);
}

static inline mblk_t *m3ua_convert(mblk_t * dp, int *err)
{
	mblk_t *mp;
	m3ua_parms_t *p;
	if (!dp || dp->b_datap->db_ref > 1) {
		*err = -EFAULT;
		return (NULL);
	}
	if (!pullupmsg(dp, -1)) {
		*err = -ENOBUFS;
		return (NULL);
	}
	if ((mp = allocb(sizeof(*p), BPRI_MED))) {
		mp->b_datap->db_type = M_DATA;
		p = ((typeof(p)) mp->b_wptr)++;
		if ((*err = m3ua_decode_parms(dp, p))) {
			freemsg(mp);
			return NULL;
		}
		mp->b_cont = dp;
		return (mp);
	}
	*err = -ENOBUFS;
	return NULL;
}

/*
 *  ERR
 *  -----------------------------------
 */
static inline int m3ua_reply_err(queue_t * q, queue_t * oq, uint ecode, uint32_t * rc,
				 uint32_t * apc, uint32_t * na, mblk_t * dp)
{
	mblk_t *mp;
	size_t dlen = dp ? min(40, dp->b_wptr - dp->b_rptr) : 0;
	size_t mlen = 16 + rc ? 8 : 0 + apc ? 8 : 0 + na ? 8 : 0 + dlen ? 4 + dlen : 0;
	trace();
	if ((mp = allocb(mlen, BPRI_MED))) {
		mp->b_datap->db_type = M_DATA;
		*((uint32_t *) mp->b_wptr)++ = UA_MGMT_ERR;
		*((uint32_t *) mp->b_wptr)++ = htonl(mlen);
		*((uint32_t *) mp->b_wptr)++ = UA_PARM_ECODE;
		*((uint32_t *) mp->b_wptr)++ = htonl(ecode);
		if (rc) {
			*((uint32_t *) mp->b_wptr)++ = UA_PARM_RC;
			*((uint32_t *) mp->b_wptr)++ = *rc;
		}
		if (apc) {
			*((uint32_t *) mp->b_wptr)++ = UA_PARM_APC;
			*((uint32_t *) mp->b_wptr)++ = *apc;
		}
		if (na) {
			*((uint32_t *) mp->b_wptr)++ = M3UA_PARM_NA;
			*((uint32_t *) mp->b_wptr)++ = *na;
		}
		if (dlen) {
			*((uint32_t *) mp->b_wptr)++ = UA_PHDR(UA_PARM_DIAG, dlen);;
			bcopy(dp->b_rptr, mp->b_wptr, dlen);
			mp->b_wptr += dlen;
		}
		putq(oq, mp);
		return (0);
	}
	rare();
	return ua_bufcall(q, mlen, BPRI_MED);
}

/*
 *  SEND REG REQ
 *  -----------------------------------
 *  Send a REG Request to an SGP.
 */
static inline int m3ua_send_reg_req(queue_t * q, as_t * as)
{
	mblk_t *mp;
	mtp_addr_t *rk = as->rk;
	static const size_t klen = 44;
	static const size_t mlen = 8 + klen;
	trace();
	ensure(rk, return -EFAULT);
	if ((mp = allocb(mlen, BPRI_MED))) {
		mp->b_datap->db_type = M_CTL;
		*((uint32_t *) mp->b_wptr)++ = UA_RKMM_REG_REQ;
		*((uint32_t *) mp->b_wptr)++ = __constant_htonl(mlen);
		*((uint32_t *) mp->b_wptr)++ = UA_PHDR(M3UA_PARM_ROUTING_KEY, klen);
		*((uint32_t *) mp->b_wptr)++ = M3UA_PARM_LOC_KEY_ID;
		*((uint32_t *) mp->b_wptr)++ = (uint32_t) as;
		*((uint32_t *) mp->b_wptr)++ = UA_PARM_TMODE;
		*((uint32_t *) mp->b_wptr)++ = htonl(as->tmode);
		*((uint32_t *) mp->b_wptr)++ = M3UA_PARM_DPC;
		*((uint32_t *) mp->b_wptr)++ = htonl(rk->pc);
		*((uint32_t *) mp->b_wptr)++ = M3UA_PARM_NA;
		*((uint32_t *) mp->b_wptr)++ = htonl(rk->ni);
		*((uint32_t *) mp->b_wptr)++ = UA_PHDR(M3UA_PARM_NA, 1);
		*((uint32_t *) mp->b_wptr)++ = htonl(rk->si << 24);
		putq(q, mp);
		return (0);
	}
	rare();
	return ua_bufcall(q, mlen, BPRI_MED);
}

#endif				/* __M3UA_MSGS_H__ */