[apple/xnu.git] / bsd / netat / atp.h

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 *
 * ORIGINS: 82
 *
 * (C) COPYRIGHT Apple Computer, Inc. 1992-1996
 * All Rights Reserved
 *
 */                                                                   

/* Definitions for ATP protocol and streams module, per 
 * AppleTalk Transaction Protocol documentation from
 * `Inside AppleTalk', July 14, 1986.
 */

/*
 *	Copyright (c) 1988, 1989 Apple Computer, Inc. 
 *
 *	The information contained herein is subject to change without
 *	notice and  should not be  construed as a commitment by Apple
 *	Computer, Inc. Apple Computer, Inc. assumes no responsibility
 *	for any errors that may appear.
 *
 *	Confidential and Proprietary to Apple Computer, Inc.
 */

#ifndef _NETAT_ATP_H_
#define _NETAT_ATP_H_
#include <sys/appleapiopts.h>

#ifdef __APPLE_API_OBSOLETE

/* ATP function codes */

#define ATP_CMD_TREQ		0x01	/* TRequest packet  */
#define ATP_CMD_TRESP		0x02	/* TResponse packet */
#define ATP_CMD_TREL		0x03	/* TRelease packet  */

/* Miscellaneous definitions */

#define	ATP_DEF_RETRIES     8	/* Default for maximum retry count */
#define	ATP_DEF_INTERVAL    2	/* Default for retry interval in seconds */

#define ATP_TRESP_MAX       8	/* Maximum number of Tresp pkts */

#define ATP_HDR_SIZE        8  	/* Size of the ATP header */
#define ATP_DATA_SIZE       578  	/* Maximum size of the ATP data area */

/* Consts for asynch support */
#define	ATP_ASYNCH_REQ	1
#define	ATP_ASYNCH_RESP	2

/* Timer values for XO release timers */
#define	ATP_XO_DEF_REL_TIME	0
#define	ATP_XO_30SEC		0
#define	ATP_XO_1MIN		1
#define	ATP_XO_2MIN		2
#define	ATP_XO_4MIN		3
#define	ATP_XO_8MIN		4

typedef struct {
#if BYTE_ORDER == BIG_ENDIAN
        unsigned       cmd : 2,
                       xo : 1,
                       eom : 1,
                       sts : 1,
                       xo_relt : 3;
#endif
#if BYTE_ORDER == LITTLE_ENDIAN
		unsigned		xo_relt : 3,
						sts : 1,
						eom : 1,
						xo : 1,
						cmd : 2;
#endif
        u_char         bitmap;
		ua_short       tid;
        ua_long        user_bytes;
        u_char         data[ATP_DATA_SIZE];
} at_atp_t;

#define ATP_ATP_HDR(c) ((at_atp_t *)(&((at_ddp_t *)(c))->data[0]))

#define TOTAL_ATP_HDR_SIZE    (ATP_HDR_SIZE+DDP_X_HDR_SIZE)
#define ATP_CLEAR_CONTROL(c)  (*(char *)(c) = 0)

/* ATP ioctl interface */

/* Structure for the atp_set_default call */

#define	ATP_INFINITE_RETRIES	0xffffffff	/* means retry forever
						 * in the def_retries field
					 	 */

struct atp_set_default {
	u_int	def_retries;		/* number of retries for a request */
	u_int	def_rate;		/* retry rate (in seconds/100) NB: the
					 * system may not be able to resolve
					 * delays of 100th of a second but will
					 * instead make a 'best effort'
					 */
	struct atpBDS *def_bdsp; /*  BDS structure associated with this req */
	u_int	def_BDSlen;	/* size of BDS structure */
};


/* Return header from requests */

struct atp_result {
	u_short		count;		/* the number of packets */
	u_short		hdr;		/* offset to header in buffer */
	u_short 	offset[8];	/* offset to the Nth packet in the buffer */
	u_short		len[8];		/* length of the Nth packet */
};

struct atpBDS {
	ua_short	bdsBuffSz;
	ua_long		bdsBuffAddr;
	ua_short	bdsDataSz;
	unsigned char	bdsUserData[4];
};


typedef struct {
        u_short        at_atpreq_type;
        at_inet_t      at_atpreq_to;
        u_char         at_atpreq_treq_user_bytes[4];
        u_char         *at_atpreq_treq_data;
        u_short        at_atpreq_treq_length;
        u_char         at_atpreq_treq_bitmap;
        u_char         at_atpreq_xo;
        u_char         at_atpreq_xo_relt;
        u_short        at_atpreq_retry_timeout;
        u_short        at_atpreq_maximum_retries;
        u_char         at_atpreq_tresp_user_bytes[ATP_TRESP_MAX][4];
        u_char         *at_atpreq_tresp_data[ATP_TRESP_MAX];
        u_short        at_atpreq_tresp_lengths[ATP_TRESP_MAX];
        u_long         at_atpreq_debug[4];
        u_short        at_atpreq_tid;
        u_char         at_atpreq_tresp_bitmap;
        u_char         at_atpreq_tresp_eom_seqno;
        u_char         at_atpreq_got_trel;
} at_atpreq;


/* The ATP module ioctl commands */

#define AT_ATP_CANCEL_REQUEST		(('|'<<8)|1)
#define AT_ATP_ISSUE_REQUEST		(('|'<<8)|2) /* ALO */
#define AT_ATP_ISSUE_REQUEST_DEF	(('|'<<8)|3) /* XO */
#define AT_ATP_ISSUE_REQUEST_DEF_NOTE	(('|'<<8)|4) /* XO & nowait -- not needed*/
#define AT_ATP_ISSUE_REQUEST_NOTE	(('|'<<8)|5) /* ALO & nowait */
#define AT_ATP_GET_POLL			(('|'<<8)|6)
#define AT_ATP_RELEASE_RESPONSE		(('|'<<8)|7)
#define AT_ATP_REQUEST_COMPLETE		(('|'<<8)|8)
#define AT_ATP_SEND_FULL_RESPONSE	(('|'<<8)|9) /* not used */
#define AT_ATP_BIND_REQ			(('|'<<8)|10)
#define AT_ATP_GET_CHANID		(('|'<<8)|11)
#define AT_ATP_PEEK			(('|'<<8)|12)
#define AT_ATP_ISSUE_REQUEST_TICKLE 	(('|'<<8)|13) /* ALO & nowait */

/* These macros don't really depend here, but since they're used only by the
 * old ATP and old PAP, they're put here.  Unisoft PAP includes this file.
 */
#define	R16(x)		UAS_VALUE(x)
#define	W16(x,v)	UAS_ASSIGN(x, v)
#define	C16(x,v)	UAS_UAS(x, v)

/*
 * these are the dispatch codes for
 * the new atp_control system call
 */
#define ATP_SENDREQUEST  0
#define ATP_GETRESPONSE  1
#define ATP_SENDRESPONSE 2
#define ATP_GETREQUEST   3

#ifdef KERNEL_PRIVATE


/*
 *	Stuff for accessing protocol headers 
 */
#define AT_DDP_HDR(m) ((at_ddp_t *)(gbuf_rptr(m)))
#define AT_ATP_HDR(m) ((at_atp_t *)(&((at_ddp_t *)(gbuf_rptr(m)))->data[0]))

/*
 *	Masks for accessing/manipulating the bitmap field in atp headers
 */

#ifdef ATP_DECLARE
unsigned char atp_mask [] = {
	0x01, 0x02, 0x04, 0x08, 
	0x10, 0x20, 0x40, 0x80, 
};

unsigned char atp_lomask [] = {
	0x00, 0x01, 0x03, 0x07, 
	0x0f, 0x1f, 0x3f, 0x7f, 
	0xff
};
#else
extern unsigned char atp_mask [];
extern unsigned char atp_lomask [];
#endif /* ATP_DECLARE */

/*
 *	doubly linked queue types and primitives
 */

#define ATP_Q_ENTER(hdr, object, entry) {					\
		if ((hdr).head) {						\
			(hdr).head->entry.prev = (object);			\
			(object)->entry.next = (hdr).head;			\
		} else {							\
			(hdr).tail = (object);					\
			(object)->entry.next = NULL;				\
		}								\
		(object)->entry.prev = NULL;					\
		(hdr).head = (object);						\
	}

#define ATP_Q_APPEND(hdr, object, entry) {					\
		if ((hdr).head) {						\
			(hdr).tail->entry.next = (object);			\
			(object)->entry.prev = (hdr).tail;			\
		} else {							\
			(hdr).head = (object);					\
			(object)->entry.prev = NULL;				\
		}								\
		(object)->entry.next = NULL;					\
		(hdr).tail = (object);						\
	}

#define ATP_Q_REMOVE(hdr, object, entry) {					\
		if ((object)->entry.prev) {					\
			(object)->entry.prev->entry.next = (object)->entry.next;\
		} else {							\
			(hdr).head = (object)->entry.next;			\
		}								\
		if ((object)->entry.next) {					\
			(object)->entry.next->entry.prev = (object)->entry.prev;\
		} else {							\
			(hdr).tail = (object)->entry.prev;			\
		}								\
	}

struct atp_rcb_qhead {
	struct atp_rcb 	*head;
	struct atp_rcb 	*tail;
};

struct atp_rcb_q {
	struct atp_rcb *prev;
	struct atp_rcb *next;
};

struct atp_trans_qhead {
	struct atp_trans *head;
	struct atp_trans *tail;
};

struct atp_trans_q {
	struct atp_trans *prev;
	struct atp_trans *next;
};

/*
 *	Locally saved remote node address
 */

struct atp_socket {
	u_short		net;
	at_node		node;
	at_socket	socket;
};

/*
 *	transaction control block (local context at requester end)
 */

struct atp_trans {
	struct atp_trans_q	tr_list;		/* trans list */
	struct atp_state	*tr_queue;		/* state data structure */
	gbuf_t			*tr_xmt;		/* message being sent */
	gbuf_t			*tr_rcv[8];		/* message being rcvd */
	unsigned int		tr_retry;		/* # retries left */
	unsigned int		tr_timeout;		/* timer interval */
	char			tr_state;		/* current state */
	char			tr_rsp_wait;		/* waiting for transaction response */
	char 			filler[2];
	unsigned char		tr_xo;			/* execute once transaction */
	unsigned char		tr_bitmap;		/* requested bitmask */
	unsigned short		tr_tid;			/* transaction id */
	struct atp_socket	tr_socket;		/* the remote socket id */
	struct atp_trans_q	tr_snd_wait;		/* list of transactions waiting
							   for space to send a msg */
	at_socket		tr_local_socket;
	at_node			tr_local_node;
	at_net			tr_local_net;
	gbuf_t                  *tr_bdsp;               /* bds structure pointer */
	unsigned int		tr_tmo_delta;
	void 				(*tr_tmo_func)();
	struct atp_trans	*tr_tmo_next;
	struct atp_trans	*tr_tmo_prev;
	atlock_t tr_lock;
	atevent_t tr_event;
};

#define	TRANS_TIMEOUT		0	/* waiting for a reply */
#define	TRANS_REQUEST		1	/* waiting to send a request */
#define	TRANS_RELEASE		2	/* waiting to send a release */
#define	TRANS_DONE			3	/* done - waiting for poll to complete */
#define	TRANS_FAILED		4	/* done - waiting for poll to report failure */
#define TRANS_ABORTING		5	/* waiting on atp_trans_abort list for thread to wakeup */

/*
 *	reply control block (local context at repling end)
 */

struct atp_rcb {
	struct atp_rcb_q	rc_list;		/* rcb list */
	struct atp_rcb_q        rc_tlist;
	struct atp_state	*rc_queue;		/* state data structure */
	gbuf_t			*rc_xmt;		/* replys being sent */
	gbuf_t			*rc_ioctl;		/* waiting ioctl */
	char			rc_snd[8];		/* replys actually to be sent */
	int                     rc_pktcnt;              /* no of pkts in this trans */
	short			rc_state;		/* current state */
	unsigned char		rc_xo;			/* execute once transaction */
	at_node			rc_local_node;
	at_net			rc_local_net;
	short			rc_rep_waiting;		/* in the reply wait list */
	int			rc_timestamp;		/* reply timer */
	unsigned char		rc_bitmap;		/* replied bitmask */
	unsigned char		rc_not_sent_bitmap;	/* replied bitmask */
	unsigned short		rc_tid;			/* transaction id */
	struct atp_socket	rc_socket;		/* the remote socket id */
};

#define RCB_UNQUEUED		0 	/* newly allocated, not q'd */
#define RCB_RESPONDING		2	/* waiting all of response from process*/
#define RCB_RESPONSE_FULL	3	/* got all of response */
#define RCB_RELEASED		4	/* got our release */
#define RCB_PENDING		5	/* a no wait rcb is full */
#define RCB_NOTIFIED		6
#define RCB_SENDING		7	/* we're currently xmitting this trans */

/*
 *	socket state (per module data structure)
 */

struct atp_state {
	gref_t		*atp_gref;	/* must be the first entry */
	int		atp_pid; 	/* process id, must be the second entry */
	gbuf_t 		*atp_msgq;	/* data msg, must be the third entry */
	unsigned char	dflag; 		/* structure flag, must be the fourth entry */
	unsigned char	filler;
	short	atp_socket_no;
	short	atp_flags;	        /* general flags */
	struct atp_trans_qhead	atp_trans_wait;		/* pending transaction list */
	struct atp_state	*atp_trans_waiting;	/* list of atps waiting for a
							   free transaction */
	unsigned int		atp_retry;		/* retry count */
	unsigned int		atp_timeout;		/* retry timeout */
	struct atp_state	*atp_rcb_waiting;
	struct atp_rcb_qhead	atp_rcb;		/* active rcbs */
	struct atp_rcb_qhead	atp_attached;		/* rcb's waiting to be read */
	atlock_t atp_lock;
	atevent_t atp_event;
	atlock_t atp_delay_lock;
	atevent_t atp_delay_event;
};


/*
 *     atp_state flag definitions
 */
#define ATP_CLOSING  0x08        /* atp stream in process of closing */


/*
 *	tcb/rcb/state allocation queues
 */

/*
 * Size defines; must be outside following #ifdef to permit
 *  debugging code to reference independent of ATP_DECLARE
 */
#define	NATP_RCB	512	/* the number of ATP RCBs at once */
#define NATP_STATE	192	/* the number of ATP sockets open at once */
				/* note: I made NATP_STATE == NSOCKETS */

#ifdef ATP_DECLARE
struct atp_trans *atp_trans_free_list = NULL;	/* free transactions */
struct atp_rcb *atp_rcb_free_list = NULL;		/* free rcbs */
struct atp_state *atp_free_list = NULL;         	/* free atp states */
struct atp_trans_qhead	atp_trans_abort;		/* aborted trans list */
struct atp_rcb* atp_rcb_data = NULL;
struct atp_state* atp_state_data=NULL;


#else
extern struct atp_trans *atp_trans_free_list;		/* free transactions */
extern struct atp_rcb *atp_rcb_free_list;			/* free rcbs */
extern struct atp_state *atp_free_list;				/* free atp states */
extern struct atp_rcb* atp_rcb_data;
extern struct atp_state* atp_state_data;
extern struct atp_trans_qhead atp_trans_abort;		/* aborting trans list */

extern void atp_req_timeout();
extern void atp_rcb_timer();
extern void atp_x_done();
extern struct atp_rcb *atp_rcb_alloc();
extern struct atp_trans *atp_trans_alloc();
#endif /* ATP_DECLARE */

/* prototypes */
void atp_send_req(gref_t *, gbuf_t *);
void atp_drop_req(gref_t *, gbuf_t *);
void atp_send_rsp(gref_t *, gbuf_t *, int);
void atp_wput(gref_t *, gbuf_t *);
void atp_rput(gref_t *, gbuf_t *);
void atp_retry_req(void *);
void atp_stop(gbuf_t *, int);
void atp_cancel_req(gref_t *, unsigned short);
int atp_open(gref_t *, int);
int atp_bind(gref_t *, unsigned int, unsigned char *);
int atp_close(gref_t *, int);
gbuf_t *atp_build_release(struct atp_trans *);
void atp_req_timeout(struct atp_trans *);
void atp_free(struct atp_trans *);
void atp_x_done(struct atp_trans *);
void atp_send(struct atp_trans *);
void atp_rsp_ind(struct atp_trans *, gbuf_t *);
void atp_trans_free(struct atp_trans *);
void atp_reply(struct atp_rcb *);
void atp_rcb_free(struct atp_rcb *);
void atp_send_replies(struct atp_state *, struct atp_rcb *);
void atp_dequeue_atp(struct atp_state *);
int atp_iocack(struct atp_state *, gbuf_t *);
void atp_req_ind(struct atp_state *, gbuf_t *);
int atp_iocnak(struct atp_state *, gbuf_t *, int);
void atp_trp_timer(void *, int);
void atp_timout(void (*func)(), struct atp_trans *, int);
void atp_untimout(void (*func)(), struct atp_trans *);
int atp_tid(struct atp_state *);

#endif /* KERNEL_PRIVATE */
#endif /* __APPLE_API_OBSOLETE */
#endif /* _NETAT_ATP_H_ */
Commit	Line	Data
1c79356b	1	/*
5d5c5d0d A	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
5d5c5d0d A	3	*
8f6c56a5	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
1c79356b	5	*
8f6c56a5 A	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
8ad349bb	24	* limitations under the License.
8f6c56a5 A	25	*
8f6c56a5 A	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
1c79356b A	27	*/
	28	/*
	29	*
	30	* ORIGINS: 82
	31	*
	32	* (C) COPYRIGHT Apple Computer, Inc. 1992-1996
	33	* All Rights Reserved
	34	*
	35	*/
	36
	37	/* Definitions for ATP protocol and streams module, per
	38	* AppleTalk Transaction Protocol documentation from
	39	* `Inside AppleTalk', July 14, 1986.
	40	*/
	41
	42	/*
	43	* Copyright (c) 1988, 1989 Apple Computer, Inc.
	44	*
	45	* The information contained herein is subject to change without
	46	* notice and should not be construed as a commitment by Apple
	47	* Computer, Inc. Apple Computer, Inc. assumes no responsibility
	48	* for any errors that may appear.
	49	*
	50	* Confidential and Proprietary to Apple Computer, Inc.
	51	*/
	52
	53	#ifndef _NETAT_ATP_H_
	54	#define _NETAT_ATP_H_
9bccf70c	55	#include <sys/appleapiopts.h>
1c79356b	56
91447636 A	57	#ifdef __APPLE_API_OBSOLETE
91447636 A	58
1c79356b A	59	/* ATP function codes */
	60
	61	#define ATP_CMD_TREQ 0x01 /* TRequest packet */
	62	#define ATP_CMD_TRESP 0x02 /* TResponse packet */
	63	#define ATP_CMD_TREL 0x03 /* TRelease packet */
	64
	65	/* Miscellaneous definitions */
	66
	67	#define ATP_DEF_RETRIES 8 /* Default for maximum retry count */
	68	#define ATP_DEF_INTERVAL 2 /* Default for retry interval in seconds */
	69
	70	#define ATP_TRESP_MAX 8 /* Maximum number of Tresp pkts */
	71
	72	#define ATP_HDR_SIZE 8 /* Size of the ATP header */
	73	#define ATP_DATA_SIZE 578 /* Maximum size of the ATP data area */
	74
	75	/* Consts for asynch support */
	76	#define ATP_ASYNCH_REQ 1
	77	#define ATP_ASYNCH_RESP 2
	78
	79	/* Timer values for XO release timers */
	80	#define ATP_XO_DEF_REL_TIME 0
	81	#define ATP_XO_30SEC 0
	82	#define ATP_XO_1MIN 1
	83	#define ATP_XO_2MIN 2
	84	#define ATP_XO_4MIN 3
	85	#define ATP_XO_8MIN 4
	86
	87	typedef struct {
89b3af67	88	#if BYTE_ORDER == BIG_ENDIAN
1c79356b A	89	unsigned cmd : 2,
	90	xo : 1,
	91	eom : 1,
	92	sts : 1,
	93	xo_relt : 3;
89b3af67 A	94	#endif
	95	#if BYTE_ORDER == LITTLE_ENDIAN
	96	unsigned xo_relt : 3,
	97	sts : 1,
	98	eom : 1,
	99	xo : 1,
	100	cmd : 2;
	101	#endif
1c79356b	102	u_char bitmap;
89b3af67	103	ua_short tid;
1c79356b A	104	ua_long user_bytes;
	105	u_char data[ATP_DATA_SIZE];
	106	} at_atp_t;
	107
	108	#define ATP_ATP_HDR(c) ((at_atp_t )(&((at_ddp_t )(c))->data[0]))
	109
	110	#define TOTAL_ATP_HDR_SIZE (ATP_HDR_SIZE+DDP_X_HDR_SIZE)
	111	#define ATP_CLEAR_CONTROL(c) ((char )(c) = 0)
	112
	113	/* ATP ioctl interface */
	114
	115	/* Structure for the atp_set_default call */
	116
	117	#define ATP_INFINITE_RETRIES 0xffffffff /* means retry forever
	118	* in the def_retries field
	119	*/
	120
	121	struct atp_set_default {
	122	u_int def_retries; /* number of retries for a request */
	123	u_int def_rate; /* retry rate (in seconds/100) NB: the
	124	* system may not be able to resolve
	125	* delays of 100th of a second but will
	126	* instead make a 'best effort'
	127	*/
	128	struct atpBDS def_bdsp; / BDS structure associated with this req */
	129	u_int def_BDSlen; /* size of BDS structure */
	130	};
	131
	132
	133	/* Return header from requests */
	134
	135	struct atp_result {
	136	u_short count; /* the number of packets */
	137	u_short hdr; /* offset to header in buffer */
	138	u_short offset[8]; /* offset to the Nth packet in the buffer */
	139	u_short len[8]; /* length of the Nth packet */
	140	};
	141
	142	struct atpBDS {
	143	ua_short bdsBuffSz;
	144	ua_long bdsBuffAddr;
	145	ua_short bdsDataSz;
	146	unsigned char bdsUserData[4];
	147	};
	148
	149
	150	typedef struct {
	151	u_short at_atpreq_type;
	152	at_inet_t at_atpreq_to;
	153	u_char at_atpreq_treq_user_bytes[4];
	154	u_char *at_atpreq_treq_data;
	155	u_short at_atpreq_treq_length;
	156	u_char at_atpreq_treq_bitmap;
	157	u_char at_atpreq_xo;
	158	u_char at_atpreq_xo_relt;
	159	u_short at_atpreq_retry_timeout;
	160	u_short at_atpreq_maximum_retries;
	161	u_char at_atpreq_tresp_user_bytes[ATP_TRESP_MAX][4];
	162	u_char *at_atpreq_tresp_data[ATP_TRESP_MAX];
	163	u_short at_atpreq_tresp_lengths[ATP_TRESP_MAX];
	164	u_long at_atpreq_debug[4];
	165	u_short at_atpreq_tid;
	166	u_char at_atpreq_tresp_bitmap;
	167	u_char at_atpreq_tresp_eom_seqno;
168	u_char at_atpreq_got_trel;
169	} at_atpreq;
170
171
172	/* The ATP module ioctl commands */
173
174	#define AT_ATP_CANCEL_REQUEST (('\|'<<8)\|1)
175	#define AT_ATP_ISSUE_REQUEST (('\|'<<8)\|2) /* ALO */
176	#define AT_ATP_ISSUE_REQUEST_DEF (('\|'<<8)\|3) /* XO */
177	#define AT_ATP_ISSUE_REQUEST_DEF_NOTE (('\|'<<8)\|4) /* XO & nowait -- not needed*/
178	#define AT_ATP_ISSUE_REQUEST_NOTE (('\|'<<8)\|5) /* ALO & nowait */
179	#define AT_ATP_GET_POLL (('\|'<<8)\|6)
180	#define AT_ATP_RELEASE_RESPONSE (('\|'<<8)\|7)
181	#define AT_ATP_REQUEST_COMPLETE (('\|'<<8)\|8)
182	#define AT_ATP_SEND_FULL_RESPONSE (('\|'<<8)\|9) /* not used */
183	#define AT_ATP_BIND_REQ (('\|'<<8)\|10)
184	#define AT_ATP_GET_CHANID (('\|'<<8)\|11)
185	#define AT_ATP_PEEK (('\|'<<8)\|12)
186	#define AT_ATP_ISSUE_REQUEST_TICKLE (('\|'<<8)\|13) /* ALO & nowait */
187
188	/* These macros don't really depend here, but since they're used only by the
189	* old ATP and old PAP, they're put here. Unisoft PAP includes this file.
190	*/
191	#define R16(x) UAS_VALUE(x)
192	#define W16(x,v) UAS_ASSIGN(x, v)
193	#define C16(x,v) UAS_UAS(x, v)
194
195	/*
196	* these are the dispatch codes for
197	* the new atp_control system call
198	*/
199	#define ATP_SENDREQUEST 0
200	#define ATP_GETRESPONSE 1
201	#define ATP_SENDRESPONSE 2
202	#define ATP_GETREQUEST 3
203
91447636	204	#ifdef KERNEL_PRIVATE
1c79356b A	205
	206
	207	/*
	208	* Stuff for accessing protocol headers
	209	*/
	210	#define AT_DDP_HDR(m) ((at_ddp_t *)(gbuf_rptr(m)))
	211	#define AT_ATP_HDR(m) ((at_atp_t )(&((at_ddp_t )(gbuf_rptr(m)))->data[0]))
	212
	213	/*
	214	* Masks for accessing/manipulating the bitmap field in atp headers
	215	*/
	216
	217	#ifdef ATP_DECLARE
	218	unsigned char atp_mask [] = {
	219	0x01, 0x02, 0x04, 0x08,
	220	0x10, 0x20, 0x40, 0x80,
	221	};
	222
	223	unsigned char atp_lomask [] = {
	224	0x00, 0x01, 0x03, 0x07,
	225	0x0f, 0x1f, 0x3f, 0x7f,
	226	0xff
	227	};
	228	#else
	229	extern unsigned char atp_mask [];
	230	extern unsigned char atp_lomask [];
	231	#endif /* ATP_DECLARE */
	232
	233	/*
	234	* doubly linked queue types and primitives
	235	*/
	236
	237	#define ATP_Q_ENTER(hdr, object, entry) { \
	238	if ((hdr).head) { \
	239	(hdr).head->entry.prev = (object); \
	240	(object)->entry.next = (hdr).head; \
	241	} else { \
	242	(hdr).tail = (object); \
	243	(object)->entry.next = NULL; \
	244	} \
	245	(object)->entry.prev = NULL; \
	246	(hdr).head = (object); \
	247	}
	248
	249	#define ATP_Q_APPEND(hdr, object, entry) { \
	250	if ((hdr).head) { \
	251	(hdr).tail->entry.next = (object); \
	252	(object)->entry.prev = (hdr).tail; \
	253	} else { \
	254	(hdr).head = (object); \
	255	(object)->entry.prev = NULL; \
	256	} \
	257	(object)->entry.next = NULL; \
	258	(hdr).tail = (object); \
	259	}
	260
	261	#define ATP_Q_REMOVE(hdr, object, entry) { \
	262	if ((object)->entry.prev) { \
	263	(object)->entry.prev->entry.next = (object)->entry.next;\
	264	} else { \
	265	(hdr).head = (object)->entry.next; \
	266	} \
	267	if ((object)->entry.next) { \
	268	(object)->entry.next->entry.prev = (object)->entry.prev;\
269	} else { \
270	(hdr).tail = (object)->entry.prev; \
271	} \
272	}
273
274	struct atp_rcb_qhead {
275	struct atp_rcb *head;
276	struct atp_rcb *tail;
277	};
278
279	struct atp_rcb_q {
280	struct atp_rcb *prev;
281	struct atp_rcb *next;
282	};
283
284	struct atp_trans_qhead {
285	struct atp_trans *head;
286	struct atp_trans *tail;
287	};
288
289	struct atp_trans_q {
290	struct atp_trans *prev;
291	struct atp_trans *next;
292	};
293
294	/*
295	* Locally saved remote node address
296	*/
297
298	struct atp_socket {
299	u_short net;
300	at_node node;
301	at_socket socket;
302	};
303
304	/*
305	* transaction control block (local context at requester end)
306	*/
307
308	struct atp_trans {
309	struct atp_trans_q tr_list; /* trans list */
310	struct atp_state tr_queue; / state data structure */
311	gbuf_t tr_xmt; / message being sent */
312	gbuf_t tr_rcv[8]; / message being rcvd */
313	unsigned int tr_retry; /* # retries left */
314	unsigned int tr_timeout; /* timer interval */
315	char tr_state; /* current state */
316	char tr_rsp_wait; /* waiting for transaction response */
317	char filler[2];
318	unsigned char tr_xo; /* execute once transaction */
319	unsigned char tr_bitmap; /* requested bitmask */
320	unsigned short tr_tid; /* transaction id */
321	struct atp_socket tr_socket; /* the remote socket id */
322	struct atp_trans_q tr_snd_wait; /* list of transactions waiting
323	for space to send a msg */
324	at_socket tr_local_socket;
325	at_node tr_local_node;
326	at_net tr_local_net;
327	gbuf_t tr_bdsp; / bds structure pointer */
328	unsigned int tr_tmo_delta;
329	void (*tr_tmo_func)();
330	struct atp_trans *tr_tmo_next;
331	struct atp_trans *tr_tmo_prev;
332	atlock_t tr_lock;
333	atevent_t tr_event;
334	};
335
336	#define TRANS_TIMEOUT 0 /* waiting for a reply */
337	#define TRANS_REQUEST 1 /* waiting to send a request */
338	#define TRANS_RELEASE 2 /* waiting to send a release */
0b4e3aa0	339	#define TRANS_DONE 3 /* done - waiting for poll to complete */
1c79356b	340	#define TRANS_FAILED 4 /* done - waiting for poll to report failure */
0b4e3aa0	341	#define TRANS_ABORTING 5 /* waiting on atp_trans_abort list for thread to wakeup */
1c79356b A	342
	343	/*
	344	* reply control block (local context at repling end)
	345	*/
	346
	347	struct atp_rcb {
	348	struct atp_rcb_q rc_list; /* rcb list */
	349	struct atp_rcb_q rc_tlist;
	350	struct atp_state rc_queue; / state data structure */
	351	gbuf_t rc_xmt; / replys being sent */
	352	gbuf_t rc_ioctl; / waiting ioctl */
	353	char rc_snd[8]; /* replys actually to be sent */
	354	int rc_pktcnt; /* no of pkts in this trans */
	355	short rc_state; /* current state */
	356	unsigned char rc_xo; /* execute once transaction */
	357	at_node rc_local_node;
	358	at_net rc_local_net;
	359	short rc_rep_waiting; /* in the reply wait list */
	360	int rc_timestamp; /* reply timer */
	361	unsigned char rc_bitmap; /* replied bitmask */
	362	unsigned char rc_not_sent_bitmap; /* replied bitmask */
	363	unsigned short rc_tid; /* transaction id */
	364	struct atp_socket rc_socket; /* the remote socket id */
	365	};
	366
	367	#define RCB_UNQUEUED 0 /* newly allocated, not q'd */
	368	#define RCB_RESPONDING 2 /* waiting all of response from process*/
	369	#define RCB_RESPONSE_FULL 3 /* got all of response */
	370	#define RCB_RELEASED 4 /* got our release */
	371	#define RCB_PENDING 5 /* a no wait rcb is full */
	372	#define RCB_NOTIFIED 6
	373	#define RCB_SENDING 7 /* we're currently xmitting this trans */
	374
	375	/*
	376	* socket state (per module data structure)
	377	*/
	378
	379	struct atp_state {
	380	gref_t atp_gref; / must be the first entry */
	381	int atp_pid; /* process id, must be the second entry */
	382	gbuf_t atp_msgq; / data msg, must be the third entry */
	383	unsigned char dflag; /* structure flag, must be the fourth entry */
	384	unsigned char filler;
	385	short atp_socket_no;
	386	short atp_flags; /* general flags */
	387	struct atp_trans_qhead atp_trans_wait; /* pending transaction list */
	388	struct atp_state atp_trans_waiting; / list of atps waiting for a
	389	free transaction */
	390	unsigned int atp_retry; /* retry count */
	391	unsigned int atp_timeout; /* retry timeout */
	392	struct atp_state *atp_rcb_waiting;
	393	struct atp_rcb_qhead atp_rcb; /* active rcbs */
	394	struct atp_rcb_qhead atp_attached; /* rcb's waiting to be read */
	395	atlock_t atp_lock;
	396	atevent_t atp_event;
	397	atlock_t atp_delay_lock;
	398	atevent_t atp_delay_event;
	399	};
	400
	401
	402	/*
	403	* atp_state flag definitions
	404	*/
	405	#define ATP_CLOSING 0x08 /* atp stream in process of closing */
406
407
408	/*
409	* tcb/rcb/state allocation queues
410	*/
411
412	/*
413	* Size defines; must be outside following #ifdef to permit
414	* debugging code to reference independent of ATP_DECLARE
415	*/
416	#define NATP_RCB 512 /* the number of ATP RCBs at once */
417	#define NATP_STATE 192 /* the number of ATP sockets open at once */
418	/* note: I made NATP_STATE == NSOCKETS */
419
420	#ifdef ATP_DECLARE
421	struct atp_trans atp_trans_free_list = NULL; / free transactions */
0b4e3aa0	422	struct atp_rcb atp_rcb_free_list = NULL; / free rcbs */
9bccf70c	423	struct atp_state atp_free_list = NULL; / free atp states */
0b4e3aa0	424	struct atp_trans_qhead atp_trans_abort; /* aborted trans list */
9bccf70c A	425	struct atp_rcb* atp_rcb_data = NULL;
9bccf70c A	426	struct atp_state* atp_state_data=NULL;
0b4e3aa0 A	427
0b4e3aa0 A	428
1c79356b A	429	#else
1c79356b A	430	extern struct atp_trans atp_trans_free_list; / free transactions */
0b4e3aa0 A	431	extern struct atp_rcb atp_rcb_free_list; / free rcbs */
0b4e3aa0 A	432	extern struct atp_state atp_free_list; / free atp states */
9bccf70c A	433	extern struct atp_rcb* atp_rcb_data;
9bccf70c A	434	extern struct atp_state* atp_state_data;
0b4e3aa0	435	extern struct atp_trans_qhead atp_trans_abort; /* aborting trans list */
1c79356b A	436
	437	extern void atp_req_timeout();
	438	extern void atp_rcb_timer();
	439	extern void atp_x_done();
	440	extern struct atp_rcb *atp_rcb_alloc();
	441	extern struct atp_trans *atp_trans_alloc();
	442	#endif /* ATP_DECLARE */
	443
	444	/* prototypes */
	445	void atp_send_req(gref_t , gbuf_t );
	446	void atp_drop_req(gref_t , gbuf_t );
	447	void atp_send_rsp(gref_t , gbuf_t , int);
	448	void atp_wput(gref_t , gbuf_t );
	449	void atp_rput(gref_t , gbuf_t );
55e303ae	450	void atp_retry_req(void *);
1c79356b A	451	void atp_stop(gbuf_t *, int);
	452	void atp_cancel_req(gref_t *, unsigned short);
	453	int atp_open(gref_t *, int);
	454	int atp_bind(gref_t , unsigned int, unsigned char );
	455	int atp_close(gref_t *, int);
	456	gbuf_t atp_build_release(struct atp_trans );
	457	void atp_req_timeout(struct atp_trans *);
	458	void atp_free(struct atp_trans *);
	459	void atp_x_done(struct atp_trans *);
	460	void atp_send(struct atp_trans *);
	461	void atp_rsp_ind(struct atp_trans , gbuf_t );
	462	void atp_trans_free(struct atp_trans *);
	463	void atp_reply(struct atp_rcb *);
	464	void atp_rcb_free(struct atp_rcb *);
	465	void atp_send_replies(struct atp_state , struct atp_rcb );
	466	void atp_dequeue_atp(struct atp_state *);
	467	int atp_iocack(struct atp_state , gbuf_t );
	468	void atp_req_ind(struct atp_state , gbuf_t );
	469	int atp_iocnak(struct atp_state , gbuf_t , int);
	470	void atp_trp_timer(void *, int);
	471	void atp_timout(void (func)(), struct atp_trans , int);
	472	void atp_untimout(void (func)(), struct atp_trans );
	473	int atp_tid(struct atp_state *);
	474
91447636 A	475	#endif /* KERNEL_PRIVATE */
91447636 A	476	#endif /* __APPLE_API_OBSOLETE */
1c79356b	477	#endif /* _NETAT_ATP_H_ */