mtp_tpi.c

OpenSS7 This the fourth public release of the OpenSS7 Master Package. See README in the release for

		case TS_WACK_DREQ7:
			/* FIXME: need to handle sequence numbers */
		case TS_WACK_DREQ9:
		case TS_WACK_DREQ10:
		case TS_WACK_DREQ11:
			mtp_disconnect(mtp);
			mtp_set_state(mtp, TS_IDLE);
			break;
		default:
			/* Note: if we are not in a WACK state we simply do not change state.  This 
			   occurs normally when we are responding to a T_OPTMGMT_REQ in other than
			   the TS_IDLE state. */
			break;
		}
		mi_strlog(q, STRLOGRX, SL_TRACE, "<- T_OK_ACK");
		putnext(mtp->rq, mp);
		return (0);
	}
	return (-ENOBUFS);
}

/**
 * t_unitdata_ind: - issue a T_UNITDATA_IND primitive
 * @mtp: MTP private data
 * @q: active queue
 * @bp: message block to free upon success
 * @src: source address (or NULL)
 * @opt: options (or NULL)
 * @dp: user data
 */
static inline fastcall __unlikely int
t_unitdata_ind(struct mtp *mtp, queue_t *q, mblk_t *bp,
	       struct mtp_addr *src, struct mtp_opts *opt, mblk_t *dp)
{
	struct T_unitdata_ind *p;
	mblk_t *mp;
	size_t src_len = t_addr_size(src);
	size_t opt_len = t_opts_size(opt);
	size_t msg_len = sizeof(*p) + src_len + opt_len;

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		if (likely(bcanputnext(mtp->rq, dp->b_band))) {
			DB_TYPE(mp) = M_PROTO;
			p = (typeof(p)) mp->b_wptr;
			p->PRIM_type = T_UNITDATA_IND;
			p->SRC_length = src_len;
			p->SRC_offset = sizeof(*p);
			p->OPT_length = opt_len;
			p->OPT_offset = sizeof(*p) + src_len;
			mp->b_wptr += sizeof(*p);
			t_build_addr(src, mp->b_wptr);
			mp->b_wptr += src_len;
			t_build_opts(opt, mp->b_wptr);
			mp->b_wptr += opt_len;
			mp->b_cont = dp;
			if (bp)
				freeb(bp);
			mi_strlog(q, STRLOGDA, SL_TRACE, "<- T_UNITDATA_IND");
			putnext(mtp->rq, mp);
			return (0);
		}
		freeb(mp);
		return (-EBUSY);
	}
	return (-ENOBUFS);
}

/**
 * t_uderror_ind: - issue a T_UDERROR_IND primitive
 * @mtp: MTP private data
 * @q: active queue
 * @bp: message block to free upon success
 * @dst: destination address (or NULL)
 * @opt: options (or NULL)
 * @dp: user data
 * @etype: error type
 */
static inline fastcall __unlikely int
t_uderror_ind(struct mtp *mtp, queue_t *q, mblk_t *bp,
	      struct mtp_addr *dst, struct mtp_opts *opt, mblk_t *dp, t_scalar_t etype)
{
	struct T_uderror_ind *p;
	mblk_t *mp;
	size_t dst_len = t_addr_size(dst);
	size_t opt_len = t_opts_size(opt);
	size_t msg_len = sizeof(*p) + dst_len + opt_len;

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		if (likely(bcanputnext(mtp->rq, 2))) {
			DB_TYPE(mp) = M_PROTO;
			mp->b_band = 2;	/* XXX move ahead of data indications */
			p = (typeof(p)) mp->b_wptr;
			p->PRIM_type = T_UDERROR_IND;
			p->DEST_length = dst_len;
			p->DEST_offset = sizeof(*p);
			p->OPT_length = opt_len;
			p->OPT_offset = sizeof(*p) + dst_len;
			p->ERROR_type = etype;
			mp->b_wptr += sizeof(*p);
			t_build_addr(dst, mp->b_wptr);
			mp->b_wptr += dst_len;
			t_build_opts(opt, mp->b_wptr);
			mp->b_wptr += opt_len;
			mp->b_cont = dp;
			if (bp)
				freeb(bp);
			mi_strlog(q, STRLOGRX, SL_TRACE, "<- T_UDERROR_IND");
			putnext(mtp->rq, mp);
			return (0);
		}
		freeb(mp);
		return (-EBUSY);
	}
	return (-ENOBUFS);
}

/**
 * t_optmgmt_ack: - issue a T_OPTMGMT_ACK primitive
 * @mtp: MTP private data
 * @q: active queue
 * @msg: message to free upon success
 * @flags: management flags
 * @opt: options
 */
static inline fastcall __unlikely int
t_optmgmt_ack(struct mtp *mtp, queue_t *q, mblk_t *msg, t_scalar_t flags, struct mtp_opts *opt)
{
	struct T_optmgmt_ack *p;
	mblk_t *mp;
	size_t opt_len = t_opts_size(opt);
	size_t msg_len = sizeof(*p) + opt_len;

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		DB_TYPE(mp) = M_PCPROTO;
		p = (typeof(p)) mp->b_wptr;
		p->PRIM_type = T_OPTMGMT_ACK;
		p->OPT_length = opt_len;
		p->OPT_offset = sizeof(*p);
		p->MGMT_flags = flags;
		mp->b_wptr += sizeof(*p);
		t_build_opts(opt, mp->b_wptr);
		mp->b_wptr += opt_len;
#ifdef TS_WACK_OPTREQ
		if (mtp_get_state(mtp) == TS_WACK_OPTREQ)
			mtp_set_state(mtp, TS_IDLE);
#endif
		freemsg(msg);
		mi_strlog(q, STRLOGRX, SL_TRACE, "<- T_OPTMGMT_ACK");
		putnext(mtp->rq, mp);
		return (0);
	}
	return (-ENOBUFS);
}

/**
 * t_ordrel_ind: - issue a T_ORDREL_IND primitive
 * @mtp: MTP private data
 * @q: active queue
 * @msg: message to free upon success
 */
static inline fastcall __unlikely int
t_ordrel_ind(struct mtp *mtp, queue_t *q, mblk_t *msg)
{
	mi_strlog(q, 0, SL_ERROR, "unsupported primitive");
	freemsg(msg);
	return (0);
}

/**
 * t_optdata_ind: - issue a T_OPTDATA_IND primitive upstream
 * @mtp: MTP private structure
 * @q: active queue
 * @bp: message block to free upon success
 * @flags: data flags
 * @opt: options (or NULL)
 * @dp: user data
 */
static inline fastcall __unlikely int
t_optdata_ind(struct mtp *mtp, queue_t *q, mblk_t *bp,
	      t_scalar_t flags, struct mtp_opts *opt, mblk_t *dp)
{
	struct T_optdata_ind *p;
	mblk_t *mp;
	size_t opt_len = t_opts_size(opt);
	size_t msg_len = sizeof(*p) + opt_len;

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		if (likely(bcanputnext(mtp->rq, dp->b_band))) {
			DB_TYPE(mp) = M_PROTO;
			p = (typeof(p)) mp->b_wptr;
			p->PRIM_type = T_OPTDATA_IND;
			p->DATA_flag = flags;
			p->OPT_length = opt_len;
			p->OPT_offset = sizeof(*p);
			mp->b_wptr += sizeof(*p);
			t_build_opts(opt, mp->b_wptr);
			mp->b_wptr += opt_len;
			mp->b_cont = dp;
			if (bp)
				freeb(bp);
			mi_strlog(q, STRLOGDA, SL_TRACE, "<- T_OPTDATA_IND");
			putnext(mtp->rq, mp);
			return (0);
		}
		freeb(mp);
		return (-EBUSY);
	}
	return (-ENOBUFS);
}

#ifdef T_ADDR_ACK
/**
 * t_addr_ack: - issue a T_ADDR_ACK primtive upstream
 * @mtp: MTP private structure
 * @q: active queue
 * @msg: message to free upon success
 * @loc: local address (or NULL)
 * @rem: remote address (or NULL)
 */
static inline fastcall __unlikely int
t_addr_ack(struct mtp *mtp, queue_t *q, mblk_t *msg, struct mtp_addr *loc, struct mtp_addr *rem)
{
	struct T_addr_ack *p;
	mblk_t *mp;
	size_t loc_len = t_addr_size(loc);
	size_t rem_len = t_addr_size(rem);
	size_t msg_len = sizeof(*p) + loc_len + rem_len;

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		DB_TYPE(mp) = M_PCPROTO;
		p = (typeof(p)) mp->b_wptr;
		p->PRIM_type = T_ADDR_ACK;
		p->LOCADDR_length = loc_len;
		p->LOCADDR_offset = sizeof(*p);
		p->REMADDR_length = rem_len;
		p->REMADDR_offset = sizeof(*p) + loc_len;
		mp->b_wptr += sizeof(*p);
		t_build_addr(loc, mp->b_wptr);
		mp->b_wptr += loc_len;
		t_build_addr(rem, mp->b_wptr);
		mp->b_wptr += rem_len;
		freemsg(msg);
		mi_strlog(q, STRLOGRX, SL_TRACE, "<- T_ADDR_ACK");
		putnext(mtp->rq, mp);
		return (0);
	}
	return (-ENOBUFS);
}
#endif

#ifdef T_CAPABILITY_ACK
/**
 * t_capability_ack: - issue a T_CAPABILITY_ACK upstream
 * @mtp: MTP private structure
 * @q: active queue
 * @msg: message to free upon success
 * @caps: capability bits
 */
static inline fastcall __unlikely int
t_capability_ack(struct mtp *mtp, queue_t *q, mblk_t *msg, t_scalar_t caps)
{
	struct T_capability_ack *p;
	mblk_t *mp;
	size_t msg_len = sizeof(*p);

	if (unlikely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		DB_TYPE(mp) = M_PCPROTO;
		p = (typeof(p)) mp->b_wptr;
		p->PRIM_type = T_CAPABILITY_ACK;
		p->CAP_bits1 = TC1_INFO;
		p->ACCEPTOR_id = (caps & TC1_ACCEPTOR_ID) ? (t_scalar_t) (ulong) mtp->rq : 0;
		mp->b_wptr += sizeof(*p);
		if (caps & TC1_INFO)
			p->INFO_ack = mtp->prot;
		else
			bzero(&p->INFO_ack, sizeof(p->INFO_ack));
		freemsg(msg);
		mi_strlog(q, STRLOGRX, SL_TRACE, "<- T_CAPABILITY_ACK");
		putnext(mtp->rq, mp);
		return (0);
	}
	return (-ENOBUFS);
}
#endif

/**
 * t_reset_ind: issue a T_RESET_IND upstream
 * @mtp: MTP private structure
 * @q: active queue
 * @msg: message to free upon success
 * @reason: reason for reset
 */
static inline fastcall __unlikely int
t_reset_ind(struct mtp *mtp, queue_t *q, mblk_t *msg, t_scalar_t reason)
{
	mi_strlog(q, 0, SL_ERROR, "fix congestion resets");
	freemsg(msg);
	return (0);
}

/*
 *  -------------------------------------------------------------------------
 *
 *  Primitives sent downstream.
 *
 *  -------------------------------------------------------------------------
 */
/**
 * mtp_bind_req: - issue a MTP_BIND_REQ primitive
 * @mtp: MTP private data
 * @q: active queue
 * @msg: message to free upon success
 * @add: address to which to bind (or NULL)
 * @flags: bind flags
 */
static inline fastcall __unlikely int
mtp_bind_req(struct mtp *mtp, queue_t *q, mblk_t *msg, struct mtp_addr *add, mtp_ulong flags)
{
	struct MTP_bind_req *p;
	mblk_t *mp;
	size_t add_len = add ? sizeof(*add) : 0;
	size_t msg_len = sizeof(*p) + add_len;

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		DB_TYPE(mp) = M_PCPROTO;
		p = (typeof(p)) mp->b_wptr;
		p->mtp_primitive = MTP_BIND_REQ;
		p->mtp_addr_length = add_len;
		p->mtp_addr_offset = sizeof(*p);
		p->mtp_bind_flags = flags;
		mp->b_wptr += sizeof(*p);
		bcopy(add, mp->b_wptr, add_len);
		mp->b_wptr += add_len;
		freemsg(msg);
		mi_strlog(q, STRLOGTX, SL_TRACE, "MTP_BIND_REQ ->");
		putnext(mtp->wq, mp);
		return (0);
	}
	return (-ENOBUFS);
}

/**
 * mtp_unbind_req: - issue a MTP_UNBIND_REQ primitive
 * @mtp: MTP private data
 * @q: active queue
 * @msg: message to free upon success
 */
static inline fastcall __unlikely int
mtp_unbind_req(struct mtp *mtp, queue_t *q, mblk_t *msg)
{
	struct MTP_unbind_req *p;
	mblk_t *mp;
	size_t msg_len = sizeof(*p);

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		DB_TYPE(mp) = M_PCPROTO;
		p = (typeof(p)) mp->b_wptr;
		p->mtp_primitive = MTP_UNBIND_REQ;
		mp->b_wptr += sizeof(*p);
		freemsg(msg);
		mi_strlog(q, STRLOGTX, SL_TRACE, "MTP_UNBIND_REQ ->");
		putnext(mtp->wq, mp);
		return (0);
	}
	return (-ENOBUFS);
}

/**
 * mtp_conn_req: - issue a MTP_CONN_REQ primitive
 * @mtp: MTP private data
 * @q: active queue
 * @bp: message block to free upon success
 * @add: address to which to connect (or NULL)
 * @flags: connect flags
 * @dp: user data
 */
static inline fastcall __unlikely int
mtp_conn_req(struct mtp *mtp, queue_t *q, mblk_t *bp,
	     struct mtp_addr *add, mtp_ulong flags, mblk_t *dp)
{
	struct MTP_conn_req *p;
	mblk_t *mp;
	size_t add_len = add ? sizeof(*add) : 0;
	size_t msg_len = sizeof(*p) + add_len;

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		if (likely(canputnext(mtp->wq))) {
			DB_TYPE(mp) = M_PROTO;
			p = (typeof(p)) mp->b_wptr;
			p->mtp_primitive = MTP_CONN_REQ;
			p->mtp_addr_length = add_len;
			p->mtp_addr_offset = add_len ? sizeof(*p) : 0;
			p->mtp_conn_flags = flags;
			mp->b_wptr += sizeof(*p);
			bcopy(add, mp->b_wptr, add_len);
			mp->b_wptr += add_len;
			mp->b_cont = dp;
			if (bp)
				freeb(bp);
			mi_strlog(q, STRLOGTX, SL_TRACE, "MTP_CONN_REQ ->");
			putnext(mtp->wq, mp);
			return (0);
		}
		freeb(mp);
		return (-EBUSY);
	}
	return (-ENOBUFS);
}

/**
 * mtp_discon_req: - issue an MTP_DISCON_REQ primitive
 * @mtp: MTP private data
 * @q: active queue
 * @bp: message block to free upon success
 * @dp: user data
 */
static inline fastcall __unlikely int
mtp_discon_req(struct mtp *mtp, queue_t *q, mblk_t *bp, mblk_t *dp)
{
	struct MTP_discon_req *p;
	mblk_t *mp;
	size_t msg_len = sizeof(*p);

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		if (likely(canputnext(mtp->wq))) {
			DB_TYPE(mp) = M_PROTO;
			p = (typeof(p)) mp->b_wptr;
			p->mtp_primitive = MTP_DISCON_REQ;
			mp->b_wptr += sizeof(*p);
			mp->b_cont = dp;
			if (bp)
				freeb(bp);
			mi_strlog(q, STRLOGTX, SL_TRACE, "MTP_DISCON_REQ ->");
			putnext(mtp->wq, mp);
			return (0);
		}
		freeb(mp);
		return (-EBUSY);
	}
	return (-ENOBUFS);
}

/**
 * mtp_addr_request: - issue an MTP_ADDR_REQ primitive
 * @mtp: MTP private data
 * @q: active queue
 * @msg: message to free upon success
 */
static inline fastcall __unlikely int
mtp_addr_req(struct mtp *mtp, queue_t *q, mblk_t *msg)
{
	struct MTP_addr_req *p;
	mblk_t *mp;
	size_t msg_len = sizeof(*p);

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		DB_TYPE(mp) = M_PCPROTO;
		p = (typeof(p)) mp->b_wptr;
		p->mtp_primitive = MTP_ADDR_REQ;
		mp->b_wptr += sizeof(*p);
		freemsg(msg);
		mi_strlog(q, STRLOGTX, SL_TRACE, "MTP_ADDR_REQ ->");
		putnext(mtp->wq, mp);
		return (0);
	}
	return (-ENOBUFS);
}

/**
 * mtp_info_req: - issue an MTP_INFO_REQ primitive
 * @mtp: MTP private data
 * @q: active queue
 * @msg: message to free upon success
 */
static inline fastcall __unlikely int
mtp_info_req(struct mtp *mtp, queue_t *q, mblk_t *msg)
{
	struct MTP_info_req *p;
	mblk_t *mp;
	size_t msg_len = sizeof(*p);

	if (likely((mp = mi_allocb(q, msg_len, BPRI_MED)) != NULL)) {
		DB_TYPE(mp) = M_PCPROTO;
		p = (typeof(p)) mp->b_wptr;
		p->mtp_primitive = MTP_INFO_REQ;
		mp->b_wptr += sizeof(*p);
		freemsg(msg);
		mi_strlog(q, STRLOGTX, SL_TRACE, "MTP_INFO_REQ ->");
		putnext(mtp->wq, mp);
		return (0);
	}
	return (-ENOBUFS);
}

/**
 * mtp_optmgmt_req: - issue an MTP_OPTMGMT_REQ primitive
 * @mtp: MTP private data
 * @q: active queue
 * @msg: message to free upon success
 * @opt: options (or NULL)
 * @flags: management flags
 */