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

#ident "@(#) $RCSfile: m2ua_ss7p.c,v $ $Name:  $($Revision: 0.8.2.2 $) $Date: 2003/04/03 19:50:20 $"

static char const ident[] =
    "$RCSfile: m2ua_ss7p.c,v $ $Name:  $($Revision: 0.8.2.2 $) $Date: 2003/04/03 19:50:20 $";

#define __NO_VERSION__

#include <linux/config.h>
#include <linux/version.h>
#ifdef MODVERSIONS
#include <linux/modversions.h>
#endif
#include <linux/module.h>

#include <sys/stream.h>
#include <sys/stropts.h>
#include <sys/cmn_err.h>
#include <sys/dki.h>

static struct module_info

/*
 *  =========================================================================
 *
 *  SL-User --> M2UA (ASP) Downstream Primitives
 *
 *  =========================================================================
 */
static inline ss7p_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 ss7p_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);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int ss7p_w_pcproto(queue_t * q, mblk_t * mp)
{
	putnext(q, mp);
	return (1);
}
static int ss7p_w_proto(queue_t * q, mblk_t * mp)
{
	if (canputnext(q)) {
		putnext(q, mp);
		return (1);
	}
	return (-EBUSY);
}
static int ss7p_r_proto(queue_t * q, mblk_t * mp)
{
	switch (*((long *) mp->b_rptr)) {
	case LMI_INFO_ACK:
		return ss7p_info_ack(q, mp);
	case LMI_OK_ACK:
		return ss7p_ok_ack(q, mp);
	case LMI_ERROR_ACK:
		return ss7p_error_ack(q, mp);
	case LMI_ENABLE_CON:
		return ss7p_enable_con(q, mp);
	case LMI_DISABLE_CON:
		return ss7p_disable_con(q, mp);
	case LMI_OPTMGMT_ACK:
		return ss7p_optmgmt_ack(q, mp);
	case LMI_ERROR_IND:
		return ss7p_error_ind(q, mp);
	case LMI_STATS_IND:
		return ss7p_stats_ind(q, mp);
	case LMI_EVENT_IND:
		return ss7p_event_ind(q, mp);

	case SL_PDU_IND:
		return ss7p_pdu_ind(q, mp);
	case SL_LINK_CONGESTED_IND:
		return ss7p_link_congested_ind(q, mp);
	case SL_LINK_CONGESTION_CEASED_IND:
		return ss7p_link_congestion_ceased_ind(q, mp);
	case SL_RETRIEVED_MESSAGE_IND:
		return ss7p_retrieved_messsage_ind(q, mp);
	case SL_RETRIEVAL_COMPLETE_IND:
		return ss7p_retrieval_complete_ind(q, mp);
	case SL_RB_CLEARED_IND:
		return ss7p_rb_cleared_ind(q, mp);
	case SL_BSNT_IND:
		return ss7p_bsnt_ind(q, mp);
	case SL_IN_SERVICE_IND:
		return ss7p_in_service_ind(q, mp);
	case SL_OUT_OF_SERVICE_IND:
		return ss7p_out_of_service_ind(q, mp);
	case SL_REMOTE_PROCESSOR_OUTAGE_IND:
		return ss7p_remote_processor_outage_ind(q, mp);
	case SL_REMOTE_PROCESSOR_RECOVERED_IND:
		return ss7p_remote_processor_recovered_ind(q, mp);
	case SL_RTB_CLEARED_IND:
		return ss7p_rtb_cleared_ind(q, mp);
	case SL_RETRIEVAL_NOT_POSSIBLE_IND:
		return ss7p_retrieval_not_possible_ind(q, mp);
	case SL_BSNT_NOT_RETRIEVABLE_IND:
		return ss7p_bsnt_not_retrievable_ind(q, mp);
	}
	return (-EOPNOTSUPP);
}
static int ss7p_w_data(queue_t * q, mblk_t * mp)
{
	if (canputnext(q)) {
		putnext(q, mp);
		return (1);
	}
	return (-EBUSY);
}
static int ss7p_r_data(queue_t * q, mblk_t * pdu)
{
	return ss7p_read(q, mp);
}
static int ss7p_r_error(queue_t * q, mblk_t * pdu)
{
	return ua_r_error(q, mp);
}
static int ss7p_r_hangup(queue_t * q, mblk_t * pdu)
{
	return ua_r_hangup(q, mp);
}
static int ss7p_r_flush(queue_t * q, mblk_t * pdu)
{
	return ua_r_flush(q, mp);
}
static int ss7p_w_flush(queue_t * q, mblk_t * mp)
{
	return ua_w_flush(q, mp);
}
static int ss7p_r_other(queue_t * q, mblk_t * mp)
{
	return (-EOPNOTSUPP);
}
static int ss7p_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 ss7p_r_prim(queue_t * q, mblk_t * mp)
{
	switch (mp->b_datap->db_type) {
	case M_DATA:
		return ss7p_r_data(q, mp);
	case M_PROTO:
	case M_PCPROTO:
		return ss7p_r_proto(q, mp);
	case M_ERROR:
		return ss7p_r_error(q, mp);
	case M_FLUSH:
		return ss7p_r_flush(q, mp);
	case M_HANGUP:
		return ss7p_r_hangup(q, mp);
	case M_CTL:
	default:
		return ss7p_r_other(q, mp);
	}
}

/*
 *  SS7 Lower RPUT
 *  -----------------------------------
 */
static INT ss7p_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 = ss7p_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 ss7p_rsrv(queue_t * q, mblk_t * mp)
{
	int rtn;
	mblk_t *mp;
	while ((mp = getq(q))) {
		switch ((rtn = ss7p_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 ss7p_w_prim(queue_t * q, mblk_t * mp)
{
	switch (mp->b_datap->db_type) {
	case M_DATA:
		return ss7p_w_data(q, mp);
	case M_PROTO:
		return ss7p_w_proto(q, mp);
	case M_PCPROTO:
		return ss7p_w_pcproto(q, mp);
	case M_FLUSH:
		return ss7p_w_flush(q, mp);
	case M_IOCTL:
	case M_IOCDATA:
	default:
		return ss7p_w_other(q, mp);
	}
}

/*
 *  SS7 Lower WPUT
 *  -----------------------------------
 */
static INT ss7p_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 = ss7p_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 ss7p_wsrv(queue_t * q, mblk_t * mp)
{
	int rtn;
	mblk_t *mp;
	while ((mp = getq(q))) {
		switch ((rtn = ss7p_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 ss7p_create(lp_t * lp)
{
}
static void ss7p_delete(lp_t * lp)
{
}