File /code/strss7/drivers/m2ua/m2ua_ss7u.c

#ident "@(#) $RCSfile: m2ua_ss7u.c,v $ $Name:  $($Revision: 0.8.2.1 $) $Date: 2002/10/18 03:28:39 $"

static char const ident[] =
    "$RCSfile: m2ua_ss7u.c,v $ $Name:  $($Revision: 0.8.2.1 $) $Date: 2002/10/18 03:28:39 $";

/*
 *  =========================================================================
 *
 *  SL-User --> M2UA (ASP) Downstream Primitives
 *
 *  =========================================================================
 */
static inline ss7_error_reply(queue_t * q, mblk_t * pdu, int prim, int err)
{
	mblk_t *mp;
	if ((mp = sccp_error_ack(prim, err))) {
		freemsg(pdu);
		qreply(q, mp);
		return (0);
	}
	return (-ENOBUFS);
}
static inline int ss7_uderror_reply(queue_t * q, mblk_t * pdu, int err)
{
	mblk_t *mp;
	N_unitdata_req_t *p = (N_unitdata_req_t *) pdu->b_rptr;
	if ((mp = sccp_uderror_ind(err,
				   p->DEST_length ? (sccp_addr_t *) (pdu->b_rptr +
								     p->DEST_offset) : 0,
				   p->SRC_length ? (sccp_addr_t *) (pdu->b_rptr +
								    p->SRC_offset) : 0,
				   pdu->b_cont))) {
		freeb(pdu);
		qreply(q, mp);
		return (0);
	}
	return (-ENOBUFS);
}

/*
 *  LMI_INFO_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_info_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_ATTACH_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_attach_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_DETACH_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_detach_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_ENABLE_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_enable_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_DISABLE_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_disable_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_OPTMGMT_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_optmgmt_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_NOTIFY_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_notify_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_PDU_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_write(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}
static int ss7_pdu_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_EMERGENCY_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_emergency_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_EMERGENCY_CEASES_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_emergency_ceases_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_START_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_start_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_STOP_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_stop_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_RETRIEVE_BSNT_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_retrieve_bsnt_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_RETRIEVAL_REQUEST_AND_FSNC_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_retrieval_request_and_fsnc_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_RESUME_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_resume_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_CLEAR_BUFFERS_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_clear_buffers_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_CLEAR_RTB_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_clear_rtb_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_LOCAL_PROCESSOR_OUTAGE_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_local_processor_outage_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_CONGESTION_DISCARD_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_congestion_discard_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_CONGESTION_ACCEPT_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_congestion_accept_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_NO_CONGESTION_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_no_congestion_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_POWER_ON_REQ
 *  -------------------------------------------------------------------------
 */
static int ss7_power_on_req(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

static int ss7_w_proto(queue_t * q, mblk_t * pdu)
{
	switch (*((long *) mp->b_rptr)) {
	case LMI_INFO_REQ:
		return ss7_info_req(q, mp);
	case LMI_ATTACH_REQ:
		return ss7_attach_req(q, mp);
	case LMI_DETACH_REQ:
		return ss7_detach_req(q, mp);
	case LMI_ENABLE_REQ:
		return ss7_enable_req(q, mp);
	case LMI_DISABLE_REQ:
		return ss7_disable_req(q, mp);
	case LMI_OPTMGMT_REQ:
		return ss7_optmgmt_req(q, mp);

	case SL_PDU_REQ:
		return ss7_pdu_req(q, mp);
	case SL_EMERGENCY_REQ:
		return ss7_emergency_req(q, mp);
	case SL_EMERGENCY_CEASES_REQ:
		return ss7_emergency_ceases_req(q, mp);
	case SL_START_REQ:
		return ss7_start_req(q, mp);
	case SL_STOP_REQ:
		return ss7_stop_req(q, mp);
	case SL_RETRIEVE_BSNT_REQ:
		return ss7_retrieve_bsnt_req(q, mp);
	case SL_RETRIEVAL_REQUEST_AND_FSNC_REQ:
		return ss7_retrieval_request_and_fsnc_req(q, mp);
	case SL_RESUME_REQ:
		return ss7_resume_req(q, mp);
	case SL_CLEAR_BUFFERS_REQ:
		return ss7_clear_buffers_req(q, mp);
	case SL_CLEAR_RTB_REQ:
		return ss7_clear_rtb_req(q, mp);
	case SL_LOCAL_PROCESSOR_OUTAGE_REQ:
		return ss7_local_processor_outage_req(q, mp);
	case SL_CONGESTION_DISCARD_REQ:
		return ss7_congestion_discard_req(q, mp);
	case SL_CONGESTION_ACCEPT_REQ:
		return ss7_congestion_accept_req(q, mp);
	case SL_NO_CONGESTION_REQ:
		return ss7_no_congestion_req(q, mp);
	case SL_POWER_ON_REQ:
		return ss7_power_on_req(q, mp);
	}
	return (-EOPNOTSUPP);
}
static int ss7_w_data(queue_t * q, mblk_t * pdu)
{
	return ss7_write(q, mp);
}

static int ss7_w_flush(queue_t * q, mblk_t * pdu)
{
	return ua_w_flush(q, pdu);
}

static int ss7_u_r_prim(queue_t * q, mblk_t * mp)
{
	if (mp->b_datap->db_type >= QPCTL || canputnext(q)) {
		putnext(q, mp);
		return (1);
	}
	return (-EBUSY);
}

static int ss7_u_w_prim(queue_t * q, mblk_t * mp)
{
	switch (mp->b_datap->db_type) {
	case M_DATA:
		return ss7_w_data(q, mp);
	case M_PROTO:
	case M_PCPROTO:
		return ss7_w_proto(q, mp);
	case M_FLUSH:
		return ss7_w_flush(q, mp);
	case M_IOCTL:
		return ss7_w_ioctl(q, mp);
	case M_IOCDATA:
		return ss7_w_iocdata(q, mp);
	}
	return (-EOPNOTSUPP);
}

static void ss7_u_create(lp_t * lp)
{
}
static void ss7_u_delete(lp_t * lp)
{
}

struct ops m2ua_ss7_u_ops = {
	&ss7_u_create,			/* create priv struct */
	&ss7_u_delete,			/* delete priv struct */
	&ss7_u_r_prim,			/* read primitives */
	&ss7_u_w_prim			/* write primitives */
};

/*
 *  =========================================================================
 *
 *  SL-Provider --> M2UA (SGP) Upstream Primitives
 *
 *  =========================================================================
 */

/*
 *  LMI_INFO_ACK
 *  -------------------------------------------------------------------------
 */
static int ss7_info_ack(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_OK_ACK
 *  -------------------------------------------------------------------------
 */
static int ss7_ok_ack(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_ERROR_ACK
 *  -------------------------------------------------------------------------
 */
static int ss7_error_ack(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_ENABLE_CON
 *  -------------------------------------------------------------------------
 */
static int ss7_enable_con(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_DISABLE_CON
 *  -------------------------------------------------------------------------
 */
static int ss7_disable_con(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_OPTMGMT_ACK
 *  -------------------------------------------------------------------------
 */
static int ss7_optmgmt_ack(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  LMI_NOTIFY_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_notify_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_PDU_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_read(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}
static int ss7_pdu_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_LINK_CONGESTED_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_link_congested_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_LINK_CONGESTION_CEASED_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_link_congestion_ceased_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_RETRIEVED_MESSAGE_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_retrieved_message_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_RB_CLEARED_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_rb_cleared_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_BSNT_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_bsnt_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_IN_SERVICE_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_in_service_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_OUT_OF_SERVICE_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_out_of_service_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_REMOTE_PROCESSOR_OUTAGE_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_remote_processor_outage_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_REMOTE_PROCESSOR_RECOVERED_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_remote_processor_recovered_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_RTB_CLEARED_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_rtb_cleared_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_RETRIEVAL_NOT_POSSIBLE_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_retrieval_not_possible_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

/*
 *  SL_BSNT_NOT_RETRIEVABLE_IND
 *  -------------------------------------------------------------------------
 */
static int ss7_bsnt_not_retrievable_ind(queue_t * q, mblk_t * pdu)
{
	(void) q;
	(void) pdu;
	return (-EOPNOTSUPP);
}

static int ss7_l_w_pcproto(queue_t * q, mblk_t * mp)
{
	putnext(q, mp);
	return (1);
}
static int ss7_l_w_proto(queue_t * q, mblk_t * mp)
{
	if (canputnext(q)) {
		putnext(q, mp);
		return (1);
	}
	return (-EBUSY);
}
static int ss7_l_r_proto(queue_t * q, mblk_t * mp)
{
	switch (*((long *) mp->b_rptr)) {
	case LMI_INFO_ACK:
		return ss7_info_ack(q, mp);
	case LMI_OK_ACK:
		return ss7_ok_ack(q, mp);
	case LMI_ERROR_ACK:
		return ss7_error_ack(q, mp);
	case LMI_ENABLE_CON:
		return ss7_enable_con(q, mp);
	case LMI_DISABLE_CON:
		return ss7_disable_con(q, mp);
	case LMI_OPTMGMT_ACK:
		return ss7_optmgmt_ack(q, mp);
	case LMI_ERROR_IND:
		return ss7_error_ind(q, mp);
	case LMI_STATS_IND:
		return ss7_stats_ind(q, mp);
	case LMI_EVENT_IND:
		return ss7_event_ind(q, mp);

	case SL_PDU_IND:
		return ss7_pdu_ind(q, mp);
	case SL_LINK_CONGESTED_IND:
		return ss7_link_congested_ind(q, mp);
	case SL_LINK_CONGESTION_CEASED_IND:
		return ss7_link_congestion_ceased_ind(q, mp);
	case SL_RETRIEVED_MESSAGE_IND:
		return ss7_retrieved_messsage_ind(q, mp);
	case SL_RETRIEVAL_COMPLETE_IND:
		return ss7_retrieval_complete_ind(q, mp);
	case SL_RB_CLEARED_IND:
		return ss7_rb_cleared_ind(q, mp);
	case SL_BSNT_IND:
		return ss7_bsnt_ind(q, mp);
	case SL_IN_SERVICE_IND:
		return ss7_in_service_ind(q, mp);
	case SL_OUT_OF_SERVICE_IND:
		return ss7_out_of_service_ind(q, mp);
	case SL_REMOTE_PROCESSOR_OUTAGE_IND:
		return ss7_remote_processor_outage_ind(q, mp);
	case SL_REMOTE_PROCESSOR_RECOVERED_IND:
		return ss7_remote_processor_recovered_ind(q, mp);
	case SL_RTB_CLEARED_IND:
		return ss7_rtb_cleared_ind(q, mp);
	case SL_RETRIEVAL_NOT_POSSIBLE_IND:
		return ss7_retrieval_not_possible_ind(q, mp);
	case SL_BSNT_NOT_RETRIEVABLE_IND:
		return ss7_bsnt_not_retrievable_ind(q, mp);
	}
	return (-EOPNOTSUPP);
}
static int ss7_l_w_data(queue_t * q, mblk_t * mp)
{
	if (canputnext(q)) {
		putnext(q, mp);
		return (1);
	}
	return (-EBUSY);
}
static int ss7_l_r_data(queue_t * q, mblk_t * pdu)
{
	return ss7_read(q, mp);
}
static int ss7_l_r_error(queue_t * q, mblk_t * pdu)
{
	return ua_r_error(q, mp);
}
static int ss7_l_r_hangup(queue_t * q, mblk_t * pdu)
{
	return ua_r_hangup(q, mp);
}
static int ss7_l_r_flush(queue_t * q, mblk_t * pdu)
{
	return ua_r_flush(q, mp);
}
static int ss7_l_w_flush(queue_t * q, mblk_t * mp)
{
	return ua_w_flush(q, mp);
}
static int ss7_l_r_other(queue_t * q, mblk_t * mp)
{
	return (-EOPNOTSUPP);
}
static int ss7_l_w_other(queue_t * q, mblk_t * mp)
{
	if (mp->b_datap->db_type >= QPCTL || canputnext(q)) {
		putnext(q, mp);
		return (1);
	}
	return (-EBUSY);
}
static int ss7_l_r_prim(queue_t * q, mblk_t * mp)
{
	switch (mp->b_datap->db_type) {
	case M_DATA:
		return ss7_l_r_data(q, mp);
	case M_PROTO:
	case M_PCPROTO:
		return ss7_l_r_proto(q, mp);
	case M_ERROR:
		return ss7_l_r_error(q, mp);
	case M_FLUSH:
		return ss7_l_r_flush(q, mp);
	case M_HANGUP:
		return ss7_l_r_hangup(q, mp);
	case M_CTL:
	default:
		return ss7_l_r_other(q, mp);
	}
}

/*
 *  SS7 Lower RPUT
 *  -----------------------------------
 */
static INT ss7_l_rput(queue_t * q, mblk_t * mp)
{
	int rtn;
	ensure(q, return ((INT) (-EFAULT)));
	ensure(mp, return ((INT) (-EFAULT)));
	if (mp->b_datap->db_type < QPCTL && q->q_count) {
		seldom();
		putq(q, mp);
		return ((INT) (0));
	}
	switch ((rtn = ss7_l_r_prim(q, mp))) {
	case 0:
		freemsg(mp);
	case 1:
		break;
	case 2:
		freeb(mp);
		break;
	case 3:
		if (q->q_next) {
			qreply(q, mp);
			break;
		}
	case 4:
		if (q->q_next) {
			putnext(q, mp);
			break;
		}
		rtn = -EOPNOTSUPP;
		/* fall through */
	default:
		ptrace(("Error (dropping) %d\n", rtn));
		freemsg(mp);
		return ((INT) (rtn));
	case -ENOBUFS:		/* caller must schedule bufcall */
	case -EBUSY:		/* caller must have failed canput */
	case -EAGAIN:		/* caller must re-enable queue */
	case -ENOMEM:		/* caller must re-enable queue */
		putq(q, mp);
		return (INT) (0);
	}
	return (INT) (0);
}

/*
 *  SS7 Lower RPUT
 *  -----------------------------------
 */
static INT ss7_l_rsrv(queue_t * q, mblk_t * mp)
{
	int rtn;
	mblk_t *mp;
	while ((mp = getq(q))) {
		switch ((rtn = ss7_l_r_prim(q, mp))) {
		case 0:
			freemsg(mp);
		case 1:
			continue;
		case 2:
			freeb(mp);
			continue;
		case 3:
			if (!q->q_next) {
				qreply(q, mp);
				continue;
			}
		case 4:
			if (q->q_next) {
				putnext(q, mp);
				continue;
			}
			rtn = -EOPNOTSUPP;
		default:
			ptrace(("Error (dropping) = %d\n", rtn));
			freemsg(mp);
			continue;
		case -ENOBUFS:	/* caller must schedule bufcall */
		case -EBUSY:	/* caller must have failed canput */
		case -EAGAIN:	/* caller must re-enable queue */
		case -ENOMEM:	/* caller must re-enable queue */
			if (mp->b_datap->db_type < QPCTL) {
				putbq(q, mp);
				return (INT) (0);
			}
			ptrace(("Error (dropping) = %d\n", rtn));
			freemsg(mp);
			continue;
		}
	}
	return (INT) (0);
}

static int ss7_l_w_prim(queue_t * q, mblk_t * mp)
{
	switch (mp->b_datap->db_type) {
	case M_DATA:
		return ss7_l_w_data(q, mp);
	case M_PROTO:
		return ss7_l_w_proto(q, mp);
	case M_PCPROTO:
		return ss7_l_w_pcproto(q, mp);
	case M_FLUSH:
		return ss7_l_w_flush(q, mp);
	case M_IOCTL:
	case M_IOCDATA:
	default:
		return ss7_l_w_other(q, mp);
	}
}

/*
 *  SS7 Lower WPUT
 *  -----------------------------------
 */
static INT ss7_l_wput(queue_t * q, mblk_t * mp)
{
	int rtn;
	ensure(q, return ((INT) (-EFAULT)));
	ensure(mp, return ((INT) (-EFAULT)));
	if (mp->b_datap->db_type < QPCTL && q->q_count) {
		seldom();
		putq(q, mp);
		return ((INT) (0));
	}
	switch ((rtn = ss7_l_w_prim(q, mp))) {
	case 0:
		freemsg(mp);
	case 1:
		break;
	case 2:
		freeb(mp);
		break;
	case 3:
		if (q->q_next) {
			qreply(q, mp);
			break;
		}
	case 4:
		if (q->q_next) {
			putnext(q, mp);
			break;
		}
		rtn = -EOPNOTSUPP;
		/* fall through */
	default:
		ptrace(("Error (dropping) %d\n", rtn));
		freemsg(mp);
		return ((INT) (rtn));
	case -ENOBUFS:		/* caller must schedule bufcall */
	case -EBUSY:		/* caller must have failed canput */
	case -EAGAIN:		/* caller must re-enable queue */
	case -ENOMEM:		/* caller must re-enable queue */
		putq(q, mp);
		return (INT) (0);
	}
	return (INT) (0);
}

/*
 *  SS7 Lower WSRV
 *  -----------------------------------
 */
static INT ss7_l_wsrv(queue_t * q, mblk_t * mp)
{
	int rtn;
	mblk_t *mp;
	while ((mp = getq(q))) {
		switch ((rtn = ss7_l_w_prim(q, mp))) {
		case 0:
			freemsg(mp);
		case 1:
			continue;
		case 2:
			freeb(mp);
			continue;
		case 3:
			if (!q->q_next) {
				qreply(q, mp);
				continue;
			}
		case 4:
			if (q->q_next) {
				putnext(q, mp);
				continue;
			}
			rtn = -EOPNOTSUPP;
		default:
			ptrace(("Error (dropping) = %d\n", rtn));
			freemsg(mp);
			continue;
		case -ENOBUFS:	/* caller must schedule bufcall */
		case -EBUSY:	/* caller must have failed canput */
		case -EAGAIN:	/* caller must re-enable queue */
		case -ENOMEM:	/* caller must re-enable queue */
			if (mp->b_datap->db_type < QPCTL) {
				putbq(q, mp);
				return (INT) (0);
			}
			ptrace(("Error (dropping) = %d\n", rtn));
			freemsg(mp);
			continue;
		}
	}
	return (INT) (0);
}

static void ss7_l_create(lp_t * lp)
{
}
static void ss7_l_delete(lp_t * lp)
{
}