/*
 * Copyright (c) 2003-2004
 *	Hartmut Brandt
 *	All rights reserved.
 *
 * Author: Harti Brandt <harti@freebsd.org>
 *
 * Redistribution of this software and documentation and use in source and
 * binary forms, with or without modification, are permitted provided that
 * the following conditions are met:
 *
 * 1. Redistributions of source code or documentation must retain the above
 *    copyright notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE AUTHOR
 * AND ITS CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
 * THE AUTHOR OR ITS CONTRIBUTORS  BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * $Begemot: libunimsg/netnatm/api/ccpriv.h,v 1.2 2005/05/23 11:49:17 brandt_h Exp $
 *
 * ATM API as defined per af-saa-0108
 *
 * Private declarations.
 */
#ifdef _KERNEL
#ifdef __FreeBSD__
#include <netgraph/atm/ccatm/ng_ccatm_cust.h>
#endif
#else	/* !_KERNEL */
#include "cccust.h"
#endif

struct ccuser;
struct ccconn;
struct ccaddr;
struct ccport;
struct ccdata;
struct ccsig;
struct ccparty;

LIST_HEAD(ccuser_list, ccuser);
LIST_HEAD(ccconn_list, ccconn);
TAILQ_HEAD(ccaddr_list, ccaddr);
TAILQ_HEAD(ccport_list, ccport);
TAILQ_HEAD(ccsig_list, ccsig);
LIST_HEAD(ccparty_list, ccparty);

/*
 * Private node data.
 */
struct ccdata {
	struct ccuser_list	user_list;	/* instance list */
	struct ccport_list	port_list;	/* list of ports */
	struct ccconn_list	orphaned_conns;	/* list of connections */
	struct ccsig_list	sigs;		/* current signals */
	struct ccsig_list	def_sigs;	/* deferred signals */
	struct ccsig_list	free_sigs;	/* free signals */

	const struct cc_funcs	*funcs;
	uint32_t		cookie;		/* cookie generator */
	u_int			log;		/* logging flags */
};

/* retrieve info on local ports */
struct atm_port_list *cc_get_local_port_info(struct ccdata *,
    u_int, size_t *);

/* log */
#ifdef CCATM_DEBUG
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_log(CC, FMT, ARGS...) do {					\
	(CC)->funcs->log("%s (data=%p): " FMT, __FUNCTION__,		\
	    (CC) , ## ARGS);						\
    } while (0)
#else
#define	cc_log(CC, FMT, ...) do {					\
	(CC)->funcs->log("%s (data=%p): " FMT, __func__,		\
	    (CC), __VA_ARGS__);						\
    } while (0)
#endif
#else
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_log(CC, FMT, ARGS...) do { } while (0)
#else
#define	cc_log(CC, FMT, ...) do { } while (0)
#endif
#endif

/*
 * structure to remember cookies for outstanding requests
 * we also remember the request itself but don't use it.
 */
struct ccreq {
	TAILQ_ENTRY(ccreq)	link;
	uint32_t		cookie;
	uint32_t		req;
	struct ccconn		*conn;
};
TAILQ_HEAD(ccreq_list, ccreq);

/*
 * Port data. Each port has one UNI stack below.
 * The port number is in param.port. The number is assigned when the
 * hook to the uni is connected. This hook has the name 'uni<port>'.
 */
struct ccport {
	void		*uarg;		/* hook to UNI protocol */
	struct ccdata 	*cc;		/* back pointer to node */
	enum {
		CCPORT_STOPPED,		/* halted */
		CCPORT_RUNNING,		/* ok */
	}		admin;		/* admin status */
	struct ccconn_list conn_list;	/* list of connections */
	struct ccaddr_list addr_list;	/* list of network addresses */
	struct atm_port_info param;	/* parameters */

	/* list of outstanding requests */
	struct ccreq_list	cookies;

	TAILQ_ENTRY(ccport) node_link;
};

#ifdef CCATM_DEBUG
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_port_log(P, FMT, ARGS...) do {				\
	(P)->cc->funcs->log("%s (port=%p/%u): " FMT, __FUNCTION__,	\
	    (P), (P)->param.port , ## ARGS);				\
    } while (0)
#else
#define	cc_port_log(P, FMT, ...) do {					\
	(P)->cc->funcs->log("%s (port=%p/%u): " FMT, __func__,		\
	    (P), (P)->param.port, __VA_ARGS__);				\
    } while (0)
#endif
#else
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_port_log(P, FMT, ARGS...) do { } while (0)
#else
#define	cc_port_log(P, FMT, ...) do { } while (0)
#endif
#endif

#define CONN_STATES					\
	DEF(CONN_NULL)			/*  C0 */	\
	DEF(CONN_OUT_PREPARING)		/*  C1 */	\
	DEF(CONN_OUT_WAIT_CREATE)	/*  C2 */	\
	DEF(CONN_OUT_WAIT_OK)		/*  C3 */	\
	DEF(CONN_OUT_WAIT_CONF)		/*  C4 */	\
							\
	DEF(CONN_ACTIVE)		/*  C5 */	\
							\
	DEF(CONN_IN_PREPARING)		/* C10 */	\
	DEF(CONN_IN_WAITING)		/* C21 */	\
	DEF(CONN_IN_ARRIVED)		/* C11 */	\
	DEF(CONN_IN_WAIT_ACCEPT_OK)	/* C12 */	\
	DEF(CONN_IN_WAIT_COMPL)		/* C13 */	\
							\
	DEF(CONN_REJ_WAIT_OK)		/* C14 */	\
	DEF(CONN_REL_IN_WAIT_OK)	/* C15 */	\
	DEF(CONN_REL_WAIT_OK)		/* C20 */	\
							\
	DEF(CONN_AB_WAIT_REQ_OK)	/* C33 */	\
	DEF(CONN_AB_WAIT_RESP_OK)	/* C34 */	\
	DEF(CONN_AB_FLUSH_IND)		/* C35 */	\
	DEF(CONN_OUT_WAIT_DESTROY)	/* C37 */

enum conn_state {
#define DEF(N) N,
	CONN_STATES
#undef DEF
};

#define	CONN_SIGS							\
	DEF(CONNECT_OUTGOING)	/* U */					\
	DEF(ARRIVAL)		/* U */					\
	DEF(RELEASE)		/* U */					\
	DEF(REJECT)		/* U */					\
	DEF(ACCEPT)		/* U newuser */				\
	DEF(ADD_PARTY)		/* U ident */				\
	DEF(DROP_PARTY)		/* U ident */				\
	DEF(USER_ABORT)		/* U */					\
									\
	DEF(CREATED)		/* P msg */				\
	DEF(DESTROYED)		/* P */					\
	DEF(SETUP_CONFIRM)	/* P msg */				\
	DEF(SETUP_IND)		/* P msg */				\
	DEF(SETUP_COMPL)	/* P msg */				\
	DEF(PROC_IND)		/* P msg */				\
	DEF(ALERTING_IND)	/* P msg */				\
	DEF(REL_CONF)		/* P msg */				\
	DEF(REL_IND)		/* P msg */				\
	DEF(PARTY_CREATED)	/* P msg */				\
	DEF(PARTY_DESTROYED)	/* P msg */				\
	DEF(PARTY_ALERTING_IND)	/* P msg */				\
	DEF(PARTY_ADD_ACK_IND)	/* P msg */				\
	DEF(PARTY_ADD_REJ_IND)	/* P msg */				\
	DEF(DROP_PARTY_IND)	/* P msg */				\
	DEF(DROP_PARTY_ACK_IND)	/* P msg */				\
									\
	DEF(OK)			/* P msg */				\
	DEF(ERROR)		/* P msg */

enum conn_sig {
#define DEF(NAME) CONN_SIG_##NAME,
CONN_SIGS
#undef DEF
};
extern const char *const cc_conn_sigtab[];

/*
 * This describes a connection and must be in sync with the UNI
 * stack.
 */
struct ccconn {
	enum conn_state		state;	/* API state of the connection */
	struct ccdata		*cc;	/* owner node */
	struct ccport		*port;	/* the port we belong to */
	struct ccuser		*user;	/* user instance we belong to */
    	TAILQ_ENTRY(ccconn)	connq_link;	/* queue of the owner */
	LIST_ENTRY(ccconn) 	port_link;	/* link in list of port */
	struct uni_cref		cref;
	uint8_t			reason;
	struct ccuser		*acceptor;

	/* attributes */
	uint32_t		blli_selector;
	struct uni_ie_blli	blli[UNI_NUM_IE_BLLI];

	struct uni_ie_bearer	bearer;
	struct uni_ie_traffic	traffic;
	struct uni_ie_qos	qos;
	struct uni_ie_exqos	exqos;
	struct uni_ie_called	called;
	struct uni_ie_calledsub	calledsub;
	struct uni_ie_aal	aal;
	struct uni_ie_epref	epref;
	struct uni_ie_conned	conned;
	struct uni_ie_connedsub	connedsub;
	struct uni_ie_eetd	eetd;
	struct uni_ie_abrsetup	abrsetup;
	struct uni_ie_abradd	abradd;
	struct uni_ie_mdcr	mdcr;

	struct uni_ie_calling	calling;
	struct uni_ie_callingsub callingsub;
	struct uni_ie_connid	connid;
	struct uni_ie_tns	tns[UNI_NUM_IE_TNS];
	struct uni_ie_atraffic	atraffic;
	struct uni_ie_mintraffic mintraffic;
	struct uni_ie_cscope	cscope;
	struct uni_ie_bhli	bhli;

	/* bit mask of written attributes in A6 */
	u_int			dirty_attr;

	struct uni_ie_cause	cause[2];

	struct ccparty_list	parties;
};

/* dirty attribute mask values */
enum {
	CCDIRTY_AAL		= 0x0001,
	CCDIRTY_BLLI		= 0x0002,
	CCDIRTY_CONNID		= 0x0004,
	CCDIRTY_NOTIFY		= 0x0008,	/* XXX */
	CCDIRTY_EETD		= 0x0010,
	CCDIRTY_GIT		= 0x0020,	/* XXX */
	CCDIRTY_UU		= 0x0040,	/* XXX */
	CCDIRTY_TRAFFIC		= 0x0080,
	CCDIRTY_EXQOS		= 0x0100,
	CCDIRTY_ABRSETUP	= 0x0200,
	CCDIRTY_ABRADD		= 0x0400,
};

/* set conn to new state */
void cc_conn_set_state(struct ccconn *, enum conn_state);

/* return string for state */
const char *cc_conn_state2str(u_int);

/* connect connection to user */
void cc_connect_to_user(struct ccconn *, struct ccuser *);

/* disconnect from the user */
void cc_disconnect_from_user(struct ccconn *);

/* abort the connection */
void cc_conn_abort(struct ccconn *, int);

/* destroy a connection */
void cc_conn_destroy(struct ccconn *);

/* create a connection */
struct ccconn *cc_conn_create(struct ccdata *);

/* assign to port */
void cc_conn_ins_port(struct ccconn *, struct ccport *);

/* remove from port */
void cc_conn_rem_port(struct ccconn *);

/* dispatch a connection to a user or reject it */
void cc_conn_dispatch(struct ccconn *);

/* disconnect from acceptor */
void cc_conn_reset_acceptor(struct ccconn *);

/* log on a connection */
#ifdef CCATM_DEBUG
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_conn_log(C, FMT, ARGS...) do {				\
	(C)->cc->funcs->log("%s (conn=%p): " FMT, __FUNCTION__,		\
	    (C) , ## ARGS);						\
    } while (0)
#else
#define	cc_conn_log(C, FMT, ...) do {					\
	(C)->cc->funcs->log("%s (conn=%p): " FMT, __func__,		\
	    (C), __VA_ARGS__);						\
    } while (0)
#endif
#else
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_conn_log(C, FMT, ARGS...) do { } while (0)
#else
#define	cc_conn_log(C, FMT, ...) do { } while (0)
#endif
#endif

/* handle signal to connection */
void cc_conn_sig_handle(struct ccconn *, enum conn_sig, void *arg, u_int iarg);

/*
 * Mp connection parties
 */
#define	PARTY_STATES							\
	DEF(NULL)		/* 0 created */				\
	DEF(ACTIVE)		/* 1 active */				\
	DEF(ADD_WAIT_CREATE)	/* 2 wait for PARTY_CREATE */		\
	DEF(ADD_WAIT_OK)	/* 3 wait for OK for ADD.request */	\
	DEF(ADD_WAIT_ACK)	/* 4 wait for ADD.ack/rej */		\
	DEF(DROP_WAIT_OK)	/* 5 wait for OK for DROP.request */	\
	DEF(DROP_WAIT_ACK)	/* 6 wait for DROP.ack */		\
	DEF(WAIT_DESTROY)	/* 7 wait for destroy */		\
	DEF(WAIT_SETUP_COMPL)	/* 8 wait for setup.complete */		\
	DEF(WAIT_DROP_ACK_OK)	/* 9 wait for OK for DROP_ACK.request */\
	DEF(WAIT_SETUP_CONF)	/* 10 wait for setup.confirm */		\
	DEF(ADD_DROP_WAIT_OK)	/* 11 wait for ok to DROP.request */	\
	DEF(ADD_DROPACK_WAIT_OK)/* 12 wait for ok to DROP_ACK.req */

enum party_state {
#define	DEF(N)	PARTY_##N,
PARTY_STATES
#undef DEF
};

struct ccparty {
	struct ccconn		*conn;	/* owner */
	LIST_ENTRY(ccparty)	link;
	enum party_state	state;
	struct uni_ie_called	called;
	struct uni_ie_epref	epref;
};

/* set party to new state */
void cc_party_set_state(struct ccparty *, enum party_state);

/* return string for state */
const char *cc_party_state2str(u_int);

/* create new party */
struct ccparty *cc_party_create(struct ccconn *, u_int ident, u_int flag);

/* log on a party */
#ifdef CCATM_DEBUG
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_party_log(P, FMT, ARGS...) do {				\
	(P)->conn->cc->funcs->log("%s (conn=%p, party=%p): " FMT,	\
	    __FUNCTION__, (P)->conn, (P) , ## ARGS);			\
    } while (0)
#else
#define	cc_party_log(P, FMT, ...) do {					\
	(P)->conn->cc->funcs->log("%s (conn=%p, party=%p): " FMT,	\
	__func__, (P)->conn, (P), __VA_ARGS__);				\
    } while (0)
#endif
#else
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_party_log(P, FMT, ARGS...) do { } while (0)
#else
#define	cc_party_log(P, FMT, ...) do { } while (0)
#endif
#endif

/*
 * This is kind of a user socket, i.e. the entity managed towards the
 * upper layer.
 */
#define USER_STATES							\
	DEF(USER_NULL)		/* U0 none */				\
	DEF(USER_OUT_PREPARING)	/* U1 process set/query requests */	\
	DEF(USER_OUT_WAIT_OK)	/* U2 wait for OK to setup */		\
	DEF(USER_OUT_WAIT_CONF)	/* U3 wait for SETUP.confirm */		\
	DEF(USER_ACTIVE)	/* U4 A8-9-10/U10 */			\
	DEF(USER_REL_WAIT)	/* U5 wait for release to compl */	\
	DEF(USER_IN_PREPARING)	/* U6 set SAP */			\
	DEF(USER_IN_WAITING)	/* U7 wait and dispatch */		\
	DEF(USER_IN_ARRIVED)	/* U8 waiting for rej/acc */		\
	DEF(USER_IN_WAIT_REJ)	/* U9 wait for rejecting */		\
	DEF(USER_IN_WAIT_ACC)	/* U10 wait for accepting */		\
	DEF(USER_IN_ACCEPTING)	/* U11 wait for SETUP_complete */	\
	DEF(USER_REL_WAIT_SCOMP)/* U12 wait for SETUP_complete */	\
	DEF(USER_REL_WAIT_SCONF)/* U13 wait for SETUP.confirm */	\
	DEF(USER_REL_WAIT_CONF)	/* U14 wait for confirm */		\
	DEF(USER_REL_WAIT_CONN)	/* U15 wait for CONN_OK */

enum user_state {
#define	DEF(N) N,
USER_STATES
#undef DEF
};

#define	USER_SIGS						\
	DEF(PREPARE_OUTGOING)		/* U */			\
	DEF(CONNECT_OUTGOING)		/* U msg */		\
	DEF(PREPARE_INCOMING)		/* U msg */		\
	DEF(WAIT_ON_INCOMING)		/* U msg */		\
	DEF(REJECT_INCOMING)		/* U msg */		\
	DEF(ACCEPT_INCOMING)		/* U msg */		\
	DEF(CALL_RELEASE)		/* U msg */		\
	DEF(ADD_PARTY)			/* U msg */		\
	DEF(DROP_PARTY)			/* U msg */		\
	DEF(QUERY_ATTR)			/* U msg */		\
	DEF(QUERY_ATTR_X)		/* U msg */		\
	DEF(SET_ATTR)			/* U msg */		\
	DEF(SET_ATTR_X)			/* U msg */		\
	DEF(QUERY_STATE)		/* U */			\
	DEF(GET_LOCAL_PORT_INFO)	/* U msg */		\
	DEF(ABORT_CONNECTION)		/* U msg */		\
								\
	DEF(CONNECT_OUTGOING_OK)	/* */			\
	DEF(CONNECT_OUTGOING_ERR)	/* reason */		\
	DEF(SETUP_CONFIRM)		/* */			\
	DEF(SETUP_IND)			/* */			\
	DEF(REJECT_OK)			/* */			\
	DEF(REJECT_ERR)			/* reason */		\
	DEF(ACCEPT_OK)			/* */			\
	DEF(ACCEPT_ERR)			/* reason */		\
	DEF(ACCEPTING)			/* */			\
	DEF(SETUP_COMPL)		/* */			\
	DEF(RELEASE_CONFIRM)		/* */			\
	DEF(RELEASE_ERR)		/* reason */		\
	DEF(ADD_PARTY_ERR)		/* reason */		\
	DEF(ADD_PARTY_OK)		/* */			\
	DEF(ADD_PARTY_ACK)		/* leaf-ident */	\
	DEF(ADD_PARTY_REJ)		/* leaf-ident */	\
	DEF(DROP_PARTY_ERR)		/* reason */		\
	DEF(DROP_PARTY_OK)		/* */			\
	DEF(DROP_PARTY_IND)		/* leaf-ident */	\


enum user_sig {
#define	DEF(NAME)	USER_SIG_##NAME,
USER_SIGS
#undef DEF
};
extern const char *const cc_user_sigtab[];

struct ccuser {
	LIST_ENTRY(ccuser) 	node_link;	/* link in list of node */
	enum user_state		state;		/* type of this instance */
	struct ccdata		*cc;		/* the node */
	void			*uarg;		/* the hook (if any) */
	char			name[ATM_EPNAMSIZ];
	enum {
		USER_P2P,
		USER_ROOT,
		USER_LEAF
	}			config;		/* configuration */

	struct uni_sap		*sap;		/* listening SAP */
	u_int			queue_max;	/* maximum queue size */
	u_int			queue_act;	/* actual queue size */
	TAILQ_HEAD(,ccconn)	connq;		/* pending connections */
	struct ccconn		*accepted;
	struct uni_ie_cause	cause[2];	/* cause from connection */
	u_int			aborted;
};

/* set user to new state */
void cc_user_set_state(struct ccuser *, enum user_state);

/* return string for state */
const char *cc_user_state2str(u_int);

/* log on a user */
#ifdef CCATM_DEBUG
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_user_log(U, FMT, ARGS...) do {				\
	(U)->cc->funcs->log("%s (user=%p): " FMT, __FUNCTION__,		\
	    (U) , ## ARGS);						\
    } while (0)
#else
#define	cc_user_log(U, FMT, ...) do {					\
	(U)->cc->funcs->log("%s (user=%p): " FMT, __func__,		\
	    (U), __VA_ARGS__);						\
    } while (0)
#endif
#else
#if defined(__GNUC__) && __GNUC__ < 3
#define	cc_user_log(U, FMT, ARGS...) do { } while (0)
#else
#define	cc_user_log(U, FMT, ...) do { } while (0)
#endif
#endif

/* Handle a signal to this user */
void cc_user_sig_handle(struct ccuser *, enum user_sig, void *, u_int);

/*
 * Addresses
 */
struct ccaddr {
	TAILQ_ENTRY(ccaddr) port_link;
	struct uni_addr	addr;
};

/* signal to connection */
int cc_conn_sig(struct ccconn *, enum conn_sig, void *arg);

/* signal with message to connection */
int cc_conn_sig_msg(struct ccconn *, enum conn_sig, struct uni_msg *);
int cc_conn_sig_msg_nodef(struct ccconn *, enum conn_sig, struct uni_msg *);

/* response signal to connection */
int cc_conn_resp(struct ccconn *, enum conn_sig, u_int, u_int, u_int);

/* flush all signals to a given connection */
void cc_conn_sig_flush(struct ccconn *);

/* Queue a signal to this user */
int cc_user_sig(struct ccuser *, enum user_sig, void *, u_int);

/* Queue a signal with message to this user */
int cc_user_sig_msg(struct ccuser *, enum user_sig, struct uni_msg *);

/* Flush all signals to a given user */
void cc_user_sig_flush(struct ccuser *);

/* flush all signals */
void cc_sig_flush_all(struct ccdata *);