m2pa_sdl.c

No7信令,我需要交换类似的代码, 请店长审核,谢谢了,急着交换,谢谢

/*****************************************************************************

 @(#) m2pa_sdl.c,v 0.7.8.1 2001/12/11 13:15:14 brian Exp

 -----------------------------------------------------------------------------

 Copyright (C) 2001  OpenSS7 Corporation <http://www.openss7.com>

 All Rights Reserved.

 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
 Foundation; either version 2 of the License, or (at your option) any later
 version.

 This program is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 details.

 You should have received a copy of the GNU General Public License along with
 this program; if not, write to the Free Software Foundation, Inc., 675 Mass
 Ave, Cambridge, MA 02139, USA.

 -----------------------------------------------------------------------------

 Last Modified 2001/12/11 13:15:14 by brian

 *****************************************************************************/

#ident "@(#) m2pa_sdl.c,v 0.7.8.1 2001/12/11 13:15:14 brian Exp"

static char const ident[] = "SS7AlphaRelease(0.7.8.1) 2001/12/11 13:15:14";

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

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

#include <sys/npi.h>
#include <sys/npi_sctp.h>

#include <ss7/lmi.h>
#include <ss7/lmi_ioctl.h>
#include <ss7/devi.h>
#include <ss7/devi_ioctl.h>
#include <ss7/sdli.h>
#include <ss7/sdli_ioctl.h>

#include "../debug.h"
#include "../bufq.h"

#define M2PA_DESCRIP	"M2PA/SCTP SIGNALLING DATA LINK (SDL) STREAMS MODULE."
#define M2PA_COPYRIGHT	"Copyright (c) 2001 OpenSS7 Corp.  All Rights Reserved."
#define M2PA_DEVICE	"Part of the OpenSS7 Stack for LiS STREAMS."
#define M2PA_CONTACT	"Brian Bidulock <[e-mail]>"
#define M2PA_BANNER	M2PA_DESCRIP	"\n" \
			M2PA_COPYRIGHT	"\n" \
			M2PA_DEVICE	"\n" \
			M2PA_CONTACT	"\n"

MODULE_AUTHOR(M2PA_CONTACT);
MODULE_DESCRIPTION(M2PA_DESCRIP);
MODULE_SUPPORTED_DEVICE(M2PA_DEVICE);

#ifndef INT
#define INT void
#endif

//#define M2PA_RX_COMPRESSION
#define M2PA_TX_COMPRESSION

typedef void (*bufcall_fnc_t)(long);

/*
 *  =========================================================================
 *
 *  STREAMS Definitions
 *
 *  =========================================================================
 */
static struct module_info m2pa_minfo =
{
	0,		/* Module ID number		*/
	"m2pa-sdl",	/* Module name			*/
	0,		/* Min packet size accepted	*/  /* FIXME */
	INFPSZ,		/* Max packet size accepted	*/  /* FIXME */
	1<<15,		/* Hi water mark		*/  /* FIXME */
	1<<10		/* Lo water mark		*/  /* FIXME */
};

static int m2pa_open (queue_t *, dev_t *, int, int, cred_t *);
static int m2pa_close(queue_t *, int, cred_t *);

static INT m2pa_rput (queue_t *, mblk_t *);
static INT m2pa_rsrv (queue_t *);

static struct qinit m2pa_rinit =
{
	m2pa_rput,	/* Read put (msg from below)	*/
	m2pa_rsrv,	/* Read queue service		*/
	m2pa_open,	/* Each open			*/
	m2pa_close,	/* Last close			*/
	NULL,		/* Admin (not used)		*/
	&m2pa_minfo,	/* Information			*/
	NULL		/* Statistics			*/
};

static INT m2pa_wput (queue_t *, mblk_t *);
static INT m2pa_wsrv (queue_t *);

static struct qinit m2pa_winit =
{
	m2pa_wput,	/* Write put (msg from above)	*/
	m2pa_wsrv,	/* Write queue service		*/
	NULL,		/* Each open			*/
	NULL,		/* Last close			*/
	NULL,		/* Admin (not used)		*/
	&m2pa_minfo,	/* Information			*/
	NULL		/* Statistics			*/
};

static struct streamtab m2pa_info =
{
	&m2pa_rinit,	/* Upper read  queue		*/
	&m2pa_winit,	/* Upper write queue		*/
	NULL,		/* Lower read  queue		*/
	NULL		/* Lower write queue		*/
};

/*
 *  =========================================================================
 *
 *  M2PA Private Structure
 *
 *  =========================================================================
 */
typedef struct m2pa {
	struct m2pa	*next;
	queue_t		*rq;
	queue_t		*wq;
	uint		state;		/* SDL interface state		*/
	uint		version;	/* version executing		*/
	uint		flags;		/* interface flags		*/
	ulong		token;		/* my bind token		*/

	uint		rx_status;	/* status of the receiver	*/
	uint		fsnr;		/* FSN for the receiver		*/
	uint		bsnr;		/* BSN for the receiver		*/
	uint		timer_rx_sib;	/* SIB timer for the receiver	*/

	uint		tx_status;	/* status of the transmitter	*/
	uint		fsnt;		/* FSN for the transmitter	*/
	uint		bsnt;		/* BSN for the transmitter	*/
	uint		bsna;		/* BSN acked for the transmitter*/
	uint		timer_tx_sib;	/* SIB timer for the xmitter	*/

	size_t		count;		/* count of SIE/SINs		*/

	size_t		dacks;		/* data acks outstanding	*/
	size_t		sacks;		/* skipped acks outstanding	*/

	lmi_option_t	options;	/* protocol and variant options	*/
	sdl_config_t	config;		/* SDL configuration options	*/
	ulong		ifclock;	/* device clock mode		*/
} m2pa_t;

#define M2PA_VERSION_DRAFT3	3
#define M2PA_VERSION_DRAFT4	4
#define M2PA_VERSION_DEFAULT	M2PA_VERSION_DRAFT4

#define M2PA_LSSU_SIO	    0
#define M2PA_LSSU_SIN	    1
#define M2PA_LSSU_SIE	    2
#define M2PA_LSSU_SIOS	    3
#define M2PA_LSSU_SIPO	    4
#define M2PA_LSSU_SIB	    5
#define M2PA_FISU	    6
#define M2PA_MSU	    7

#define M2PA_FLAG_RX_ENABLED	0x01
#define M2PA_FLAG_TX_ENABLED	0x02
#define M2PA_FLAG_RX_BUSY	0x04
#define M2PA_FLAG_TX_BUSY	0x08

#define M2PA_RX_SIB_TIME    5
#define M2PA_TX_SIB_TIME    20

#define M2PA_EVENT_TX_SIB_TIMEOUT   1
#define M2PA_EVENT_RX_SIB_TIMEOUT   2

/*
 *  =========================================================================
 *
 *  SDL Provider (M2PA) -> SDL User Primitives
 *
 *  =========================================================================
 */
/*
 *  LMI_INFO_ACK
 *  ---------------------------------------------
 */
static int
lmi_info_ack(m2pa_t *m2)
{
	mblk_t *mp;
	lmi_info_ack_t *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((lmi_info_ack_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_INFO_ACK;
		p->lmi_version		= 1;
		p->lmi_state		= m2->state;
		p->lmi_max_sdu		= -1;
		p->lmi_min_sdu		= 0;
		p->lmi_header_len	= 0;
		p->lmi_ppa_style	= LMI_STYLE1;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
}
/*
 *  LMI_OK_ACK
 *  ---------------------------------------------
 */
#if 0
static int
lmi_ok_ack(m2pa_t *m2, long prim)
{
	mblk_t *mp;
	lmi_ok_ack_t *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((lmi_ok_ack_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_OK_ACK;
		p->lmi_correct_primitive= prim;
		switch ( m2->state )
		{
			case LMI_ATTACH_PENDING: m2->state = LMI_DISABLED;  break;
			case LMI_DETACH_PENDING: m2->state = LMI_UNATTACHED; break;
			/* default is don't change state */
		}
		p->lmi_state		= m2->state;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
}
#endif
/*
 *  LMI_ERROR_ACK
 *  ---------------------------------------------
 */
static int
lmi_error_ack(m2pa_t *m2, long prim, long err)
{
	mblk_t *mp;
	lmi_error_ack_t *p;
	switch ( err )
	{
		case -EBUSY:
		case -EAGAIN:
		case -ENOMEM:
		case -ENOBUFS:
			seldom(); return(err);
	}
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((lmi_error_ack_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_ERROR_ACK;
		p->lmi_errno		= err<0 ? -err       : 0;
		p->lmi_reason		= err<0 ? LMI_SYSERR : err;
		p->lmi_error_primitive	= prim;
		switch ( m2->state )
		{
			case LMI_ATTACH_PENDING:    m2->state = LMI_UNATTACHED;   break;
			case LMI_DETACH_PENDING:    m2->state = LMI_DISABLED;	    break;
			case LMI_ENABLE_PENDING:    m2->state = LMI_DISABLED;	    break;
			case LMI_DISABLE_PENDING:   m2->state = LMI_ENABLED;	    break;
			/*
			 *  Default is not to change state.
			 */
		}
		p->lmi_state		= m2->state;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
}
/*
 *  LMI_ENABLE_CON
 *  ---------------------------------------------
 */
static int
lmi_enable_con(m2pa_t *m2)
{
	mblk_t *mp;
	lmi_enable_con_t *p;
	ensure( m2->state == LMI_ENABLE_PENDING, return(-EFAULT) );
	if ( canputnext(m2->rq) ) {
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PROTO;
		p = ((lmi_enable_con_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_ENABLE_CON;
		p->lmi_state		= m2->state = LMI_ENABLED;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
	} rare();   return(-EBUSY);
}
/*
 *  LMI_DISABLE_CON
 *  ---------------------------------------------
 */
static int
lmi_disable_con(m2pa_t *m2)
{
	mblk_t *mp;
	lmi_disable_con_t *p;
	ensure( m2->state == LMI_DISABLE_PENDING, return(-EFAULT) );
	if ( canputnext(m2->rq) ) {
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PROTO;
		p = ((lmi_disable_con_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_DISABLE_CON;
		p->lmi_state		= m2->state = LMI_DISABLED;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
	} rare();   return(-EBUSY);
}
#if 0
/*
 *  LMI_OPTMGMT_ACK
 *  ---------------------------------------------
 */
static int
lmi_optmgmt_ack(m2pa_t *m2, ulong flags, void *opt_ptr, size_t opt_len)
{
	mblk_t *mp;
	lmi_optmgmt_ack_t *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((lmi_optmgmt_ack_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_OPTMGMT_ACK;
		p->lmi_opt_length	= opt_len;
		p->lmi_opt_offset	= opt_len?sizeof(*p):0;
		p->lmi_mgmt_flags	= flags;
		bcopy(opt_ptr, mp->b_wptr, opt_len);
		mp->b_wptr += opt_len;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
}
#endif
/*
 *  LMI_ERROR_IND
 *  ---------------------------------------------
 */
static int
lmi_error_ind(m2pa_t *m2, long err)
{
	mblk_t *mp;
	lmi_error_ind_t *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((lmi_error_ind_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_ERROR_IND;
		p->lmi_errno		= err<0 ? -err       : 0;
		p->lmi_reason		= err<0 ? LMI_SYSERR : err;
		p->lmi_state		= m2->state;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
}
/*
 *  LMI_STATS_IND
 *  ---------------------------------------------
 */
#if 0
static int
lmi_stats_ind(m2pa_t *m2, ulong interval, ulong timestamp)
{
	mblk_t *mp;
	lmi_stats_ind_t *p;
	if ( bcanputnext(m2->rq, mp->b_band) ) {
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PROTO;
		p = ((lmi_stats_ind_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_STATS_IND;
		p->lmi_interval		= interval;
		p->lmi_timestamp	= timestamp;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
	} seldom(); return(-EBUSY);
}
#endif
/*
 *  LMI_EVENT_IND
 *  ---------------------------------------------
 */
#if 0
static int
lmi_event_ind(m2pa_t *m2, ulong oid, ulong severity, ulong timestamp)
{
	mblk_t *mp;
	lmi_event_ind_t *p;
	if ( bcanputnext(m2->rq, mp->b_band) ) {
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PROTO;
		p = ((lmi_event_ind_t *)mp->b_wptr)++;
		p->lmi_primitive	= LMI_EVENT_IND;
		p->lmi_objectid		= oid;
		p->lmi_timestamp	= timestamp;
		p->lmi_severity		= severity;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
	} seldom(); return(-EBUSY);
}
#endif
/*
 *  SDL_DAEDR_RECEIVED_BITS_IND
 *  ---------------------------------------------
 */
static int
sdl_read(m2pa_t *m2, mblk_t *dp)
{
	if ( canputnext(m2->rq) ) {
		putnext(m2->rq, dp);
		return(0);
	} seldom(); return(-EBUSY);
}
#if 0
static int
sdl_daedr_received_bits_ind(m2pa_t *m2, ulong count, mblk_t *dp)
{
	mblk_t *mp;
	sdl_daedr_received_bits_ind_t *p;
	if ( canputnext(m2->rq) ) {
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PROTO;
		p = ((sdl_daedr_received_bits_ind_t *)mp->b_wptr)++;
		p->sdl_primitive	= SDL_DAEDR_RECEIVED_BITS_IND;
		p->sdl_count		= count;
		putnext(m2->rq, mp);
		return(0);
	} rare();   return(-ENOBUFS);
	} seldom(); return(-EBUSY);
}
#endif
/*
 *  SDL_DAEDR_CORRECT_SU_IND
 *  ---------------------------------------------
 */
#if 0
static int
sdl_daedr_correct_su_ind(m2pa_t *m2, ulong count)
{
	mblk_t *mp;
	sdl_daedr_correct_su_ind_t *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((sdl_daedr_correct_su_ind_t *)mp->b_wptr)++;
		p->sdl_primitive	= SDL_DAEDR_CORRECT_SU_IND;
		p->sdl_count		= count;
		putnext(m2->rq, mp);
		return(0);
	} rare(); return(-ENOBUFS);
}
#endif
/*
 *  SDL_DAEDR_SU_IN_ERROR_IND
 *  ---------------------------------------------
 */
#if 0
static int
sdl_daedr_su_in_error_ind(m2pa_t *m2)
{
	mblk_t *mp;
	sdl_daedr_su_in_error_ind_t *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((sdl_daedr_su_in_error_ind_t *)mp->b_wptr)++;
		p->sdl_primitive	= SDL_DAEDR_SU_IN_ERROR_IND;
		putnext(m2->rq, mp);
		return(0);
	} rare(); return(-ENOBUFS);
}
#endif
/*
 *  SDL_DAEDT_TRANSMISSION_REQUEST_IND
 *  ---------------------------------------------
 */
#if 0
static int
sdl_daedt_transmission_request_ind(m2pa_t *m2)
{
	mblk_t *mp;
	sdl_daedt_transmission_request_ind_t *p;
	if ( (mp = allocb(sizeof(*p), BPRI_MED)) ) {
		mp->b_datap->db_type = M_PCPROTO;
		p = ((sdl_daedt_transmission_request_ind_t *)mp->b_wptr)++;
		p->sdl_primitive	= SDL_DAEDT_TRANSMISSION_REQUEST_IND;
		putnext(m2->rq, mp);
		return(0);
	} rare(); return(-ENOBUFS);
}