comments around symbol following #endif

[moira.git] / include / gdb.h

/*
 *	$Header$
 */

/************************************************************************
 *	
 *			gdb.h
 *	
 *	Includes for the global database facility (gdb)
 *	
 *	Author: Noah Mendelsohn
 *	Copyright: 1986 MIT Project Athena
 *	
 ************************************************************************/

/*
 * Note: following include may safely be done redundantly, so it doesn't
 * matter if caller does it too.  We need it for fd_set.
 */
#include <sys/types.h>
#include <sys/time.h>

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

#ifndef max
#define max(a,b) ((a)>(b)?(a):(b))
#endif

#ifndef min
#define min(a,b) ((a)<(b)?(a):(b))
#endif

#ifndef NFDBITS
#define NFDBITS 32
#endif
#ifndef howmany
#define	howmany(x, y)	(((x)+((y)-1))/(y))
#endif
#ifndef FD_SET
#define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
#define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
#define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
#define FD_ZERO(p)      bzero(p, sizeof(*(p)))
#endif 



	/*----------------------------------------------------------*
	 *	
	 *			GDB_GIVEUP
	 *	
	 *	This macro is called with a string argument whenever a
	 *	fatal error is encounterd.  If you re-define this
	 *	macro, you can control the disposition of fatal gdb
	 *	errors.
	 *	
	 *	The gdb library must be recompiled for the change to
	 *	take effect.  That will have to be fixed sometime.
	 *	
	 *----------------------------------------------------------*/

#define GDB_GIVEUP(errormsg) g_givup(errormsg);

	/*----------------------------------------------------------*
	 *	
	 *	                GDB_ROUNDUP
	 *	
	 *	Round a number up to the next specified boundary.
	 *	
	 *----------------------------------------------------------*/

#define GDB_ROUNDUP(n,b) ((((n)+(b)-1)/(b))*(b))

extern int	gdb_Debug;			/* debugging flags are */
						/* stored here */
extern FILE *gdb_log;				/* file descriptor for */
						/* logging gdb output */


/*
 * 			connection failure indicator
 * 
 * This variable is used to communicate between gdb_move_data and
 * g_con_progress without passing an extra parameter through lots
 * of procedure calls.  When set to FALSE, it indicates that the 
 * connection currently being processed has encountered a fatal error
 * and should be severed.
 */
extern int gdb_conok;					
/************************************************************************
 *	
 *			    USER IDENTIFICATION
 *	
 *	gdb_init puts the user's i.d. and hostname as strings here.
 *	
 ************************************************************************/

extern char *gdb_uname;				/* user's string name */
extern char *gdb_host;				/* name of local host */
						/* goes here */


\f
/************************************************************************
 *	
 *	
 *			  TYPE MANAGEMENT
 *	
 *	Declarations used to control the definition and use of 'types'
 *	as supported by the global database system.  Most of the 
 *	declarations for 'System Defined Types' will not be of concern
 *	to typical users, with the exception of the type names like
 *	INTEGER_T which are defined below.
 *	
 *	In this implementation, user defined types are added
 *	dynamically during execution by calling the appropriate
 *	functions.  The define GDB_MAX_TYPES below sets the maximum
 *	total number of types, including both system and user defined,
 *	which the system can support for any one application.  When
 *	GDB_MAX_TYPES is changed, the libary must be re-built.  Space
 *	for a two dimensional array, with one word for each property
 *	of each possible type, is allocated statically in the library.
 *	
 ************************************************************************/


/*
 * Maximum number of types we can support, including both system and
 * user defined.
 */

#define GDB_MAX_TYPES 50

typedef int FIELD_TYPE;				/* data needed to repre- */
						/* sent a system or user */
						/* defined data type */
						/* This is actualy just */
						/* a row index in the type */
						/* definition table */

	/*----------------------------------------------------------
	 *	
	 *		System defined types
	 *	
	 *	WARNING: Any changes to these type definitions must be
	 *	carefully matched with the initializations in the
	 *	gdb_i_stype routine in gdb_stype.c.  Mistakes in these
	 *	tables may be VERY difficult to debug.  Be careful!
	 *	
	 *----------------------------------------------------------*/

/*
 * Primitive types for ingres data
 */

#define INTEGER_T (0)
#define STRING_T (1)
#define REAL_T (2)
#define DATE_T (3)

/*
 * Structured types
 */

#define TUPLE_DESCRIPTOR_T (4)
#define TUPLE_T (5)
#define TUPLE_DATA_T (6)
#define RELATION_T (7)

/*
 * Number of system defined types
 * 
 * This will always be equal to one more than index of last system type
 */

#define SYSTEM_TYPE_COUNT 8

	/*----------------------------------------------------------
	 *	
	 *		Type descriptor tables
	 *	
	 *----------------------------------------------------------*/

/*
 * 			gdb_prop_union
 * 
 * Each entry in the type definition table is a union of this form,
 * which allows us to store a choice of an integer, a function 
 * pointer, or a pointer to a character string.
 */

union gdb_prop_union {
	int i;					/* when we want as an */
						/* integer */
	int (*f)();				/* as a function pointer */
	char *cp;				/* character pointer  */
};

#define TYPE_PROPERTY_COUNT 8			/* number of properties */
						/* for each type*/

/*
 * Uses of the type properties.  Each type has a set of properties.
 * Some are integers, some are functions.  The defines below descrive
 * respectively the 0'th,1'st, 2'nd, etc. properties of EACH type.
 * 
 * Note:  TYPE_PROPERTY_COUNT (above) must be changed when new properties
 * are added.  For system defined types, bindings for the properties
 * are done in gdb_i_stype in the gdb_stype.c source file.
 */

#define LENGTH_PROPERTY 0			/* integer */
#define ALIGNMENT_PROPERTY 1			/* integer */
#define NULL_PROPERTY 2				/* function */
#define CODED_LENGTH_PROPERTY 3			/* function */
#define ENCODE_PROPERTY 4			/* function */
#define DECODE_PROPERTY 5			/* function */
#define FORMAT_PROPERTY 6			/* function */
#define NAME_PROPERTY 7				/* char pointer */

/*
 * 			gdb_type_def
 * 
 * Information to describe a single type
 */

typedef union gdb_prop_union gdb_type_def[TYPE_PROPERTY_COUNT];


/*
 * 			g_type_table
 * 
 * This is the table where the actual definitions for the types are
 * kept.
 */

extern gdb_type_def g_type_table[GDB_MAX_TYPES];
extern int gdb_n_types;				/* number of entries in */
						/* table */

	/*----------------------------------------------------------
	 *	
	 *	    Macros for accessing properties
	 *	
	 *----------------------------------------------------------*/

#define INT_PROPERTY(type, prop) (g_type_table[type][prop].i) 
#define STR_PROPERTY(type, prop) (g_type_table[type][prop].cp) 
#define FCN_PROPERTY(type, prop) (*g_type_table[type][prop].f) 

\f
/************************************************************************
 *	
 *			   STRUCTURED DATA
 *	
 *	Stuff needed to declare and manage TUPLES, TUPLE_DESCRIPTORS
 *	and RELATIONS.
 *	
 ************************************************************************/

	/*----------------------------------------------------------
	 *	
	 *		   TUPLE_DESCRIPTOR
	 *	
	 *----------------------------------------------------------*/

#define GDB_DESC_ID 0x54504400			/* "TPD" */

struct tupld_var {				/* the variable length */
						/* stuff in a tuple */
						/* descriptor*/
	char *name;				/* string name of field */
	FIELD_TYPE type;			/* type of this field */
	int  offset;				/* byte offset of this field */
						/* relative to first byte of */
						/* data (not start of whole */
						/* tuple) */
	int length;				/* Length of the actual data */
						/* for this field. Note that */
						/* alignment requirements of */
						/* following field are NOT */
						/* included in this length */
};
struct tupl_desc {
	long id;				/* this should say TPD\0 */
	int ref_count;				/* when this goes to zero, */
						/* the descriptor may really */
						/* be reclaimed */
	int field_count;			/* number of fields in */
						/* the tuple*/
	int data_len;				/* length of the data in */
						/* the actual tuple */
	int str_len;				/* length of the strings */
						/* stored off the end of */
						/* this descriptor*/
	struct tupld_var var[1];		/* one of these for each */
						/* field, but the C compiler */
						/* won't accept the[] decl, */
						/* because it's afraid of */
						/* uncertain length*/
};

typedef struct tupl_desc *TUPLE_DESCRIPTOR;	/* use this to declare a */
						/* tuple descriptor anchor */

#define gdb_descriptor_length(num_flds) (sizeof(struct tupl_desc) + ((num_flds)-1) * sizeof(struct tupld_var))

	/*----------------------------------------------------------
	 *	
	 *			TUPLE
	 *	
	 *	tuple_dat is allocated by the create_tuple routine.
	 *	
	 *	TUPLE may be used in user code to declare a handle
	 *	on a tuple.
	 *	
	 *----------------------------------------------------------*/

#define GDB_TUP_ID 0x54555000

typedef struct tuple_dat *TUPLE;		/* handle on a tuple */

struct tuple_dat {
	TUPLE next, prev;			/* chain pointers when */
						/* tuples are linked, as in */
						/* a relation.  Convention is*/
						/* double linked, circular.*/
	long id;				/* should say TUP\0  */
	TUPLE_DESCRIPTOR desc;			/* pointer to the descriptor */
	char data[1];				/* data goes here, word */
						/* aligned.  Should be [] */
						/* if compiler would allow */
};


	/*----------------------------------------------------------
	 *	
	 *		      RELATION
	 *	
	 *	rel_dat is allocated by the create_relation
	 *	routine.
	 *	
	 *	RELATION may be used in user code to declare a handle
	 *	on a relation.
	 *	
	 *----------------------------------------------------------*/

#define GDB_REL_ID 0x52454c00

struct rel_dat {
	TUPLE first, last;			/* chain pointers to tuples */
						/* note that first->prev and */
						/* last->next are both == */
						/* &rel-dat.  Maintenance is */
						/* simplified by keeping */
						/* as the first fields in */
						/* both rel_dat and tuple_dat*/
						/* a minor non-portability */
	long id;				/* should contain REL\0  */
	TUPLE_DESCRIPTOR desc;			/* descriptor for the tuples */
						/* in this relation. Should */
						/* == that in each tuple */

};

typedef struct rel_dat *RELATION;		/* handle on a relation */
\f
/************************************************************************
 *	
 *		      transport LAYER DECLARATIONS
 *	
 *	Declares the state maintenance structures for full duplex 
 *	connections with asynchronous transmission capability.  Most
 *	users need only know that the type CONNECTION is defined, and
 *	that it may be treated as a pointer for most purposes (i.e. it
 *	is compact, and copying it does not actually copy the connection
 *	state.)
 *	
 ************************************************************************/

#define GDB_PROTOCOL_VERSION 0x01		/* version of the gdb */
						/* protocols that we're */
						/* observing */
#define GDB_STREAM_BUFFER_SIZE 4096		/* amount to read in */
						/* one chunk from tcp stream*/
#define GDB_PORT htons(9425)			/* temporary until we use */
						/* services properly */
#define GDB_BIND_RETRY_COUNT 5			/* number of times to */
						/* retry a bind before */
						/* giving up.  Used when */
						/* accepting connections */
#define GDB_BIND_RETRY_INTERVAL 10		/* Number of seconds to wait */
						/* between attempts to bind */
						/* the listening socket */
#define GDB_MAX_CONNECTIONS 25			/* maximum number of */
						/* connections that */
						/* any one process can */
						/* control simultaneously */
/*
 * Circumvent bug in ACIS 4.2 socket support
 */
#ifdef ibm032
#define GDB_MAX_SOCK_WRITE 2047			/* rt can't do socket */
						/* writes longer than this */
						/* gives errno 40*/
#else
#define GDB_MAX_SOCK_WRITE 0x00ffffff
#endif

	/*----------------------------------------------------------
	 *	
	 *	     Declarations for HALF_CONNECTIONS
	 *	
	 *	Each full duplex connection has associated with it 
	 *	two simplex half-connections, each of which 
	 *	has its own queue of pending operations.  The
	 *	following describes the state of a half-connection.
	 *	
	 *----------------------------------------------------------*/

struct half_con_data {
       /*
        * these two must be first to match position in OPERATION
        */
	struct oper_data *op_q_first;		/* first item in q of pending*/
						/* operations for this */
						/* half-connection. (chained */
						/* circularly to half con, */
						/* NOT the con. */
	struct oper_data *op_q_last;		/* last item in q of pending*/
						/* operations for this */
						/* half-connection*/
	int status;				/* values are of type */
						/* OPSTATUS. tells whether */
						/* transmit/receive is */
						/* pending.*/
	long flags;				/* bit flags */
#define HCON_PROGRESS 0x00000001		/* used by selection */
						/* routines to detect */
						/* progress */
#define HCON_LISTEN   0x00000002		/* indicates that this is */
						/* a special half connection */
						/* used only for listenting */
						/* to incoming connection */
						/* requests */
#define HCON_UNUSED   0x00000004		/* on a one-way connection, */
						/* this flag marks an unused */
						/* half */
#define HCON_PENDING_LISTEN 0x00000008		/* a queued op on this half */
						/* connection is actually */
						/* trying to listen */
#define HCON_BUSY     0x00000010		/* we are currently making */
						/* progress on this half */
						/* connection.  Used to */
						/* detect re-entrance of */
						/* hcon_progress */
	int fd;					/* main half duplex file */
						/* descriptor for this h_conn*/
	int oob_fd;				/* file descriptor for */
						/* out of band signals*/
	char *next_byte;			/* next byte to send/recv */
	int remaining;				/* number of bytes remaining */
						/* to send/receive */
	char *stream_buffer;			/* points to a buffer */
						/* used to pre-read/write */
						/* the stream to avoid */
						/* window thrashing */
	int stream_buffer_length;		/* length of the stream */
						/* buffer */
	char *stream_buffer_next;		/* next byte to read in */
						/* stream buffer */
	int stream_buffer_remaining;		/* number of bytes currently */
						/* in use in stream buffer*/
	int *accepted_fdp;			/* used only for listening */
						/* connections.  latest */
						/* accepted fd is put where*/
						/* this points */
	int *accepted_len;			/* ptr to length of 'from' */
						/* data on accept  */

};

typedef struct half_con_data *HALF_CONNECTION;


	/*----------------------------------------------------------
	 *	
	 *	     Declarations for CONNECTIONS
	 *	
	 *----------------------------------------------------------*/

#define GDB_CON_ID 0x434f4e00 /*"CON"*/

struct con_data {
	long	id;				/* should contain CON\0  */
	int status;				/* See definitions below. */
						/* Do not confuse with */
						/* the status sub-fields of */
						/* in and out half-cons. */
	int version;				/* the version of the */
						/* protocol being observed */
						/* on this connection */
	int errno;				/* the real errno gets */
						/* copied here if it causes */
						/* the connection to die */
	int (*oob_fcn)();			/* pointer to function to */
						/* call when something */
						/* arrives on the out of */
						/* band channel */
	struct half_con_data in, out;		/* states of the inbound */
						/* and outbound half */
						/* sessions.*/
};

typedef struct con_data *CONNECTION;		/* the only externally */
						/* visible handle on a */
						/* connection*/

/*
 * Definitions of status fields.
 * 
 * WARNING: If you change any of the following, there are coordinated
 * changes to be made in gdb_debug.c
 */

#define CON_STOPPED 1				/* never started, terminated */
#define CON_UP 2				/* ready to use */
#define CON_STARTING 3				/* trying to start */
#define CON_STOPPING 4				/* trying to stop */

/*
 * The following are used as keywords when distinguishing input from output
 * half connections.
 */
#define CON_INPUT 1				/* this is an input half */
						/* session*/
#define CON_OUTPUT 2				/* this is an output half */
						/* session*/


	/*----------------------------------------------------------
	 *	
	 *			gdb_cons
	 *	
	 *	This is the array of connection control data 
	 *	structures for gdb.  Every connection has its 
	 *	structure stored here, but they are in no 
	 *	particular order.  Because the connection data
	 *	itself cannot be moved (due to possible dangling
	 *	pointers), there may be some unused connections 
	 *	in the middle of this array.  gdb_mcons is the
	 *	1 based number of the highest connection which is
	 *	actually in use at this time.  This is a considerable
	 *	optimization for the typical case where very few
	 *	are in use, and turnover is low.
	 *	
	 *	These are externs for globals defined in gdb_lib.h
	 *	and included by gdb.c.
	 *	
	 *----------------------------------------------------------*/

extern int  gdb_mcons;				/* one based number of the */
						/* highest connection */
						/* descriptor we're using */
						/* at the moment */

extern int  gdb_mfd;				/* number of the highest */
						/* file descriptor in use */
						/* for a connection */
extern struct con_data gdb_cons[GDB_MAX_CONNECTIONS];
						/* actual connection data */
						/* is stored here */

extern fd_set gdb_crfds, gdb_cwfds, gdb_cefds;	/* connection related file */
						/* descriptor maps to be */
						/* used in select */
fd_set last_crfds, last_cwfds, last_cefds;	/* these file desc. bit */
						/* masks are set up */
						/* for each select call */
						/* to include the user */
						/* supplied and the */
						/* connection related */
						/* fd's */

	/*----------------------------------------------------------
	 *	
	 *			OPERATIONS
	 *	
	 *----------------------------------------------------------*/

#define GDB_OP_ID 0x4f505200

struct oper_data {
	struct oper_data *next, *prev;		/* forward and back chain */
	long id;				/* should contain OPR\0  */
	int tag;				/* unique identifier for */
						/* this operation */
	int status;				/* current state of this */
						/* oaperation*/
	int flags;
#define OPF_MARKED_COMPLETE 0x00000001		/* operation was already */
						/* complete when opsel was */
						/* called*/
#define OPF_MARKED_CANCELLED 0x00000002		/* operation was already */
						/* cancelled when opsel was */
						/* called*/
	int result;				/* when the operation */
						/* completes, this field is */
						/* set to reflect its dispos-*/
						/* ition. Contents of this */
						/* field will depend on the */
						/* operation being performed */
	HALF_CONNECTION halfcon;		/* the half connection on */
						/* which this operation is */
						/* queued */
						/* May be meaningless if not */
						/* queued..*/
	char *arg;				/* pointer to user data */
	union fcn {
		int (*init)();			/* pointer to routine to */
						/* call to start this */
					
	/* operation*/
		int (*cont)();			/* pointer to function to */
						/* be called when this */
						/* logical operation */
						/* continues*/
	} fcn;

	int (*cancel)();			/* this routine gets called */
						/* to handle a cancel request*/
						/* this field is normally */
						/* set to NULL when the */
						/* operation is queued and */
						/* updated as required by */
						/* the init and cont funcs. */
};

typedef struct oper_data OPERATION_DATA;	/* an actual operation */
						/* descritor, creator is */
						/* responsible for making */
						/* sure that memory is not */
						/* freed while in use */
typedef OPERATION_DATA *OPERATION;		/* a handle on an operation */
						/* this is what most */
						/* applications will use */

	/*----------------------------------------------------------
	 *	
	 *	          STATES OF AN OPERATION
	 *	
	 *	These represent the state of an asynchronous, queued
	 *	operation.  For convenience of the application programmer,
	 *	some of these are folded together when queried through the
	 *	operation_status routine.  In particular, operation status
	 *	returns only one of:
	 *	
	 *	OP_NOT_RUNNING, OP_RUNNING, OP_COMPLETE,  or 
	 *	OP_CANCELLED.
	 *	
	 *	Any other status is reported as OP_RUNNING.  This is
	 *	done on the assumption that it makes correct coding
	 *	of applications less error-prone, as there are fewer
	 *	cases to check, and most of them would not be of 
	 *	interest anyway.
	 *	
	 *	Note that OP_CANCELLED may be generated by the system
	 *	even when no explicit request for cancellation has been
	 *	issued.  For example, this may occur when a connection
	 *	is severed unexpectedly.
	 *	
	 *	WARNING:  If you change any of the following, be sure
	 *	to make the equivalent changes to gdb_debug.c.
	 *	
	 *	We also define here certain standard values of OP_RESULT,
	 *	since some return conventions presume that op_status 
	 *	and op_result values are orthogonal.
	 *	
	 *----------------------------------------------------------*/

#define OP_SUCCESS     0			/* this value is actually */
						/* used only in result */
						/* fields, but it is */
						/* sometimes convenient to */
						/* have status and result */
						/* have orthogonal values */
#define OP_NOT_STARTED 1			/* this operation has been */
						/* initialized but is not on */
						/* any connection's queue */
#define OP_QUEUED 2				/* this operation is on */
						/* some connection's queue */
						/* but it has not yet */
						/* reached the head of the q */
#define OP_RUNNING 3				/* op is at head of q trying */
						/* to progress */
#define OP_COMPLETE 4				/* operation has run to */
						/* completion.  result field */
						/* is now valid */
#define OP_CANCELLING 5				/* we are in the process of */
						/* (trying to) cancel this */
						/* operation */
#define OP_CANCELLED 6				/* operation was prematurely */
						/* terminated.  result field */
						/* is NOT valid. */
#define OP_MARKED 7				/* used by op_select_all */
#define OP_REQUEUED 8				/* returned by an init or */
						/* continuation routine to */
						/* indicate that the */
						/* operation has requeued */
						/* itself */
#define OP_PREEMPTED 9				/* returned by an init or */
						/* continuation routine to */
						/* indicate that the op has */
						/* preempted itself by */
						/* queueing a new operation */
						/* ahead of itself */

	/*----------------------------------------------------------
	 *	
	 *		     LIST_OF_OPERATIONS
	 *	
	 *----------------------------------------------------------*/

struct oper_list {
	int	count;				/* number of operations */
						/* in the list */
	OPERATION op[1];			/* really op[n], but */
						/* structs must have a */
						/* definite length */
};

typedef struct oper_list *LIST_OF_OPERATIONS;	/* handle on a list */

#define size_of_list_of_operations(n)					\
		(sizeof(struct oper_list) + (n-1)*sizeof(OPERATION))

	/*----------------------------------------------------------
	 *	
	 *			gdb_notime
	 *	
	 *	Pass this to select when doing a poll.
	 *	
	 *----------------------------------------------------------*/

extern struct timeval gdb_notime;

\f
/************************************************************************
 *	
 *		CHECKING ROUTINES IMPLEMENTED AS MACROS
 *	
 ************************************************************************/

extern char g_errstr[150];			/* build emsgs here */

#define GDB_INIT_CHECK g_chk_init();		/* make sure gdb_init */
						/* was called */

#define GDB_CHECK_CON(con, where) if ((con)->id != GDB_CON_ID) \
	{ (void) sprintf(g_errstr, "Invalid connection descriptor passed to \"%s\"\n", where); \
	GDB_GIVEUP(g_errstr) }


#define GDB_CHECK_TUP(tup, where) if ((tup)->id != GDB_TUP_ID) \
	{ (void) sprintf(g_errstr, "Invalid tuple passed to \"%s\"\n", where); \
	GDB_GIVEUP(g_errstr) }


#define GDB_CHECK_TPD(tpd, where) if ((tpd)->id != GDB_DESC_ID) \
	{ (void) sprintf(g_errstr, "Invalid tuple descriptor passed to \"%s\"\n", where); \
	GDB_GIVEUP(g_errstr) }


#define GDB_CHECK_REL(rel, where) if ((rel)->id != GDB_REL_ID) \
	{ (void) sprintf(g_errstr, "Invalid relation passed to \"%s\"\n", where); \
	GDB_GIVEUP(g_errstr) }

#define GDB_CHECK_OP(op, where) if ((op)->id != GDB_OP_ID) \
	{ (void) sprintf(g_errstr, "Invalid operation passed to \"%s\"\n", where); \
	GDB_GIVEUP(g_errstr) }

#define GDB_CHECK_DB(db, where) if (db->id != GDB_DB_ID) \
	{ (void) sprintf(g_errstr, "Invalid database handle passed to \"%s\"\n", where); \
	GDB_GIVEUP(g_errstr) }



\f
/************************************************************************
 *	
 *		TRANSPORT ROUTINES IMPLEMENTED AS MACROS
 *	
 ************************************************************************/

	/*----------------------------------------------------------
	 *	
	 *		   connection_status
	 *	
	 *	Returns the status of the indicated connection.
	 *	Possible return values are:
	 *	
	 *		CON_STOPPED	never started or terminated
	 *		CON_UP		currently usable
	 *		CON_STARTING    transient state on way up
	 *		CON_STOPPING    transient state on way down
	 *	
	 *----------------------------------------------------------*/

#define connection_status(con) ((con)->status)

	/*----------------------------------------------------------
	 *	
	 *		   connection_errno
	 *	
	 *	When a connection dies due to an error on a system
	 *	call, the corresponding errno is recorded in the 
	 *	connection descriptor.  This macro returns that value.
	 *	
	 *----------------------------------------------------------*/

#define connection_errno(con) ((con)->errno)


\f
/************************************************************************
 *	
 *		       SERVER/CLIENT MANAGEMENT
 *	
 *	Definitions used in starting and maintaining communication 
 *	between servers and clients (as opposed to peers.)
 *	
 ************************************************************************/

#define GDB_MAX_SERVER_RETRIES 3		/* maximum number of times */
						/* clients will accept */
						/* forwarding requests from */
						/* a given server */


extern TUPLE_DESCRIPTOR gdb_tosrv;		/* descriptor for request */
						/* tuples sent to the */
						/* server during negotiation*/

extern TUPLE_DESCRIPTOR gdb_fmsrv;		/* descriptor for request */
						/* tuples sent from the */
						/* server during negotiation*/

#define GDB_MAX_SERVER_ID_SIZE 255		/* longest name of a server */
						/* that we can handle */
#define GDB_MAX_SERVER_PARMS_SIZE 1023		/* longest parm string we */
						/* can exchange between */
						/* server and client*/

	/*----------------------------------------------------------
	 *	
	 *	The following are values returned in the disposition
	 *	field of the response tuple to indicate what the
	 *	server has decided to do about the connection 
	 *	request.
	 *	
	 *----------------------------------------------------------*/

#define GDB_ACCEPTED 1
#define GDB_REFUSED  2
#define GDB_FORWARDED 3

	/*----------------------------------------------------------
	 *	
	 *	Global variables inherited by a child from a server
	 *	parent.
	 *	
	 *----------------------------------------------------------*/

extern TUPLE gdb_client_tuple;			/* request tuple sent from */
						/* the client */

extern char gdb_sockaddr_of_client[100];	/* this should really be */
						/* sockaddr_in, but I don't */
						/* want everyone to have */
						/* to include all those */
						/* big .h files */
extern int gdb_socklen;				/* length of above */


\f
/************************************************************************
 *	
 *			DATABASE MANAGEMENT
 *	
 *	This layer of GDB provides access to the services of a relational
 *	database from anywhere in a GDB network.
 *	
 ************************************************************************/

	/*----------------------------------------------------------
	 *	
	 *			GDB_DB_SERVICE
	 *	
	 *	The name of the service, as found in /etc/services,
	 *	for GDB database servers.
	 *	
	 *----------------------------------------------------------*/

#define GDB_DB_SERVICE "#9420"

	/*----------------------------------------------------------
	 *	
	 *			DATABASE
	 *	
	 *	Describes a client's active connection to a database.
	 *	
	 *----------------------------------------------------------*/

#define GDB_DB_ID 0x44420000			/* eye catcher */

struct db_struct {
	long id;				/* eye catcher */
	CONNECTION connection;			/* the GDB connection */
						/* used to get at this */
						/* database */
	int status;				/* status of this */
						/* database connection */
#define DB_OPEN 1				/* database opened */
						/* successfully */
#define DB_CLOSED 2				/* not open */
	char *name;				/* pointer to string name */
						/* of the database, for */
						/* debugging */
	char *server;				/* pointer to the i.d. */
						/* of the server, for */
						/* debugging */
};

typedef struct db_struct *DATABASE;

	/*----------------------------------------------------------
	 *	
	 *	Return codes from DB operations
	 *	
	 *----------------------------------------------------------*/

#define DB_NO_SUCH_OP 3

	/*----------------------------------------------------------
	 *	
	 *	Parameters which limit sizes of things
	 *	
	 *----------------------------------------------------------*/

#define GDB_MAX_QUERY_SIZE 2048			/* length of the longest */
						/* substituted query */
						/* string we can make */
#define GDB_MAX_QUERY_FIELDS 100		/* maximum number of fields */
						/* we can retrieve in one */
						/* query */
#define GDB_SIZE_OF_INGRES_TEXT 2001		/* number of chars in */
						/* largest ingres text */
						/* field */
#define GDB_MAX_RETRIEVED_TEXT_FIELDS 60	/* maximum number of text */
						/* type fields we can */
						/* retrieve in a single */
						/* query.  we hold this */
						/* down because stack space */
						/* is taken for max size of */
						/* each during query. */

	/*----------------------------------------------------------
	 *	
	 *	Return codes from database operations
	 *	
	 *----------------------------------------------------------*/

#define DB_PARSE_FAIL (-3)			/* couldn't parse */
						/* the request string*/

\f
/************************************************************************
 *	
 *			DATABASE OPERATIONS IMPLEMENTED
 *			        AS MACROS
 *	
 ************************************************************************/

	/*----------------------------------------------------------
	 *	
	 *			DB_STATUS
	 *	
	 *----------------------------------------------------------*/

#define DB_STATUS(dbhandle) ((dbhandle)->status)



\f
/************************************************************************
 *	
 *			STRING MANAGEMENT
 *	
 *	To allow dynamic manipulation of strings in gdb without
 *	excessive memory re-allocation, we define a string as a
 *	counted byte space.  Though this space will frequently be used
 *	to store a standard null terminated string, that is not
 *	required.
 *	
 *	Current representation for a string is a pointer followed by
 *	an integer length.  A null pointer indicates a null string, in
 *	which case the length is arbitrary.  Any other pointer is to
 *	memory which was allocated by db_alloc in which must be free'd
 *	eventually with db_free.
 *	
 ************************************************************************/

typedef struct str_dat {
	char *ptr;				/* pointer to the data */
	int length;				/* length of the allocated */
						/* memory (not necessarily */
						/* length of null-term'd */
						/* string stored there) */
} STRING;

	/*----------------------------------------------------------
	 *	
	 *	Macros for manipulating strings.  These return
	 *	the actual data from the string and the size of
	 *	the data space respectively.  To get the length of
	 *	the null terminated string which might be stored 
	 *	there, use strlen(STRING_DATA(string)).
	 *	
	 *----------------------------------------------------------*/


#define STRING_DATA(str) ((str).ptr)
#define MAX_STRING_SIZE(str) ((str).length)


/************************************************************************
 *	
 *			MEMORY ALLOCATION
 *	
 *	db_alloc and db_free are the externally visible names of
 *	the memory allocation services.  These actually call the 
 *	routines pointed to by the vectors gdb_amv and gdb_fmv, which
 *	default to the supplied routines gdb_am and gdb_fm.  Users
 *	may supply their own memory allocation by storing over the
 *	vectors.  This may be done prior to calling gdb_init to 
 *	insure that all dynamic memory is controlled by the user.
 *	
 ************************************************************************/

#define db_alloc (*gdb_amv)
#define db_free  (*gdb_fmv)

extern char *gdb_am();
extern int  gdb_fm();

extern char *((*gdb_amv)());
extern int  (*gdb_fmv)();

\f
/************************************************************************
 *	
 *	      STRUCTURED DATA ROUTINES IMPLEMENTED AS MACROS
 *	
 ************************************************************************/

	/*----------------------------------------------------------
	 *	
	 *	             ADD_TUPLE_TO_RELATION
	 *	
	 *----------------------------------------------------------*/

#define ADD_TUPLE_TO_RELATION(relation, tuple) 			\
	{							\
                (tuple)->prev    = (relation)->last;            \
		(tuple)->next    = (TUPLE)(relation);      	\
		(relation)->last = tuple;			\
		(tuple)->prev->next = tuple;                    \
        }

	/*----------------------------------------------------------
	 *	
	 *	             ADD_TUPLE_AFTER_TUPLE
	 *	
	 *----------------------------------------------------------*/

#define ADD_TUPLE_AFTER_TUPLE(relation, tuple, prev_tuple)	\
	{								\
                (tuple)->prev    = (prev_tuple)->next->prev;            \
		(tuple)->next    = (prev_tuple)->next; 			\
		(tuple)->next->prev = tuple;				\
		(prev_tuple)->next = tuple;                    		\
        }

	/*----------------------------------------------------------
	 *	
	 *	          REMOVE_TUPLE_FROM_RELATION
	 *	
	 *----------------------------------------------------------*/

#define REMOVE_TUPLE_FROM_RELATION(relation, tuple) 			\
	{								\
		(tuple)->prev->next = (tuple)->next;			\
		(tuple)->next->prev = (tuple)->prev;			\
        }


	/*----------------------------------------------------------
	 *	
	 *	           DESCRIPTOR_FROM_TUPLE
	 *	
	 *----------------------------------------------------------*/

#define DESCRIPTOR_FROM_TUPLE(tuple) ((tuple)->desc)

	/*----------------------------------------------------------
	 *	
	 *	           DESCRIPTOR_FROM_RELATION
	 *	
	 *----------------------------------------------------------*/

#define DESCRIPTOR_FROM_RELATION(relation) ((relation)->desc)

	/*----------------------------------------------------------
	 *	
	 *		   REFERENCE_TUPLE_DESCRIPTOR
	 *	
	 *	Bumps the reference count for a tuple descriptor.
	 *	Intended only for internal use of GDB.
	 *	
	 *----------------------------------------------------------*/

#define REFERENCE_TUPLE_DESCRIPTOR(tpd) (++((tpd)->ref_count))

	/*----------------------------------------------------------
	 *	
	 *		   UNREFERENCE_TUPLE_DESCRIPTOR
	 *	
	 *	Decrements the reference count for a tuple descriptor.
	 *	Intended only for internal use of GDB.  Warning: it
	 *	is the user's responsibility to use delete_tuple_descriptor
	 *	instead of this macro in any situation in which the
	 *	reference count might go to zero.
	 *	
	 *----------------------------------------------------------*/

#define UNREFERENCE_TUPLE_DESCRIPTOR(tpd) (--((tpd)->ref_count))

	/*----------------------------------------------------------
	 *	
	 *	                 FIELD_FROM_TUPLE
	 *	
	 *----------------------------------------------------------*/

#define FIELD_FROM_TUPLE(tuple, field_index)				\
	(((tuple)->data) + (((tuple)->desc)->var[field_index].offset))

	/*----------------------------------------------------------
	 *	
	 *	                FIELD_OFFSET_IN_TUPLE
	 *	
	 *----------------------------------------------------------*/

#define FIELD_OFFSET_IN_TUPLE(tuple_descriptor, field_index)		\
	((tuple_descriptor)->var[field_index].offset)

	/*----------------------------------------------------------
	 *	
	 *	                FIELD_TYPE_IN_TUPLE
	 *	
	 *----------------------------------------------------------*/

#define FIELD_TYPE_IN_TUPLE(tuple_descriptor, field_index)		\
	((tuple_descriptor)->var[field_index].type)

	/*----------------------------------------------------------
	 *	
	 *	              FIRST_TUPLE_IN_RELATION
	 *	
	 *----------------------------------------------------------*/

#define FIRST_TUPLE_IN_RELATION(relation)				\
	(((relation)->first) == (TUPLE)relation ? NULL : (relation)-> first)

	/*----------------------------------------------------------
	 *	
	 *			NEXT_TUPLE_IN_RELATION
	 *	
	 *----------------------------------------------------------*/

#define NEXT_TUPLE_IN_RELATION(relation, prev)				\
	(((prev)->next) == (TUPLE)relation ? NULL : prev->next )

	/*----------------------------------------------------------
	 *	
	 *			PREV_TUPLE_IN_RELATION
	 *	
	 *----------------------------------------------------------*/

#define PREV_TUPLE_IN_RELATION(relation, next)				\
	(((next)->prev) == (TUPLE) relation ? NULL : next->prev)



\f
/************************************************************************
 *	
 *	TRANSPORT and OPERATION SERVICES IMPLEMENTED AS MACROS
 *	
 ************************************************************************/

	/*----------------------------------------------------------
	 *	
	 *	             OPERATION_FROM_DATA
	 *	
	 *	Given OPERATION_DATA, return the corresponding handle
	 *	of type OPERATION.  Currently, OPERATION is just
	 *	implemented as a pointer to OPERATION_DATA.
	 *	
	 *----------------------------------------------------------*/

#define OPERATION_FROM_DATA(op_data)					\
	((OPERATION)&(op_data))

	/*----------------------------------------------------------
	 *	
	 *	                 OP_TAG
	 *	
	 *	Return the tag for a given operation.
	 *	
	 *----------------------------------------------------------*/

#define OP_TAG(operation) ((operation)->tag)

	/*----------------------------------------------------------
	 *	
	 *		       OP_STATUS
	 *	
	 *	Return the status of a given operation.  Note that
	 *	status describes an operations progress through 
	 *	execution.  It has the same values for all operations.
	 *	Result describes the final outcome of an operation.
	 *	It's values depend on the particular operation which
	 *	was attempted.  
	 *	
	 *----------------------------------------------------------*/

#define OP_STATUS(operation) ((operation)->status)

	/*----------------------------------------------------------
	 *	
	 *			OP_DONE
	 *	
	 *	True iff the operation is either OP_COMPLETE or
	 *	OP_CANCELLED.
	 *	
	 *----------------------------------------------------------*/

#define OP_DONE(op) ((op)->status == OP_COMPLETE || (op)->status == OP_CANCELLED)

	/*----------------------------------------------------------
	 *	
	 *		       OP_RESULT
	 *	
	 *	Return the result of a given operation.  Note that
	 *	status describes an operations progress through 
	 *	execution.  It has the same values for all operations.
	 *	Result describes the final outcome of an operation.
	 *	It's values depend on the particular operation which
	 *	was attempted. The special result value -1 is used 
	 *	to indicate an invalid value for result.  Generally,
	 *	-1 is returned when result is accidently queried at
	 *	a time when OP_STATUS != OPERATION_COMPLETE.
	 *	
	 *----------------------------------------------------------*/

#define OP_RESULT(operation) ((operation)->result)

\f
/************************************************************************
 *	
 *			Debugging Interfaces
 *	
 ************************************************************************/

	/*----------------------------------------------------------
	 *	
	 *	The following operation codes my be passed to 
	 *	gdb_debug to set special debugging modes of operation.
	 *	
	 *	Note that most of these are toggles
	 *	
	 *----------------------------------------------------------*/

#define GDB_LOG 	0x00000001		/* turn on tracing to */
						/* log file */
#define GDB_NOFORK 	0x00000002		/* don't fork forking */
						/* servers */

\f
/************************************************************************
 *	
 *	Things which have to be at the end because they require
 *	the various types to be defined first.
 *	
 ************************************************************************/


#ifdef DUMB_7_CHAR_LOADER
	/*----------------------------------------------------------
	 *	
	 *	          Long Names for Routines
	 *	
	 *	External names in Unix must generally be unique
	 *	within the first 7 characters or so, at least for
	 *	some versions of ld.  To account for this without
	 *	making all our routine names terribly short and
	 *	cryptic, we use the following defines.
	 *	
	 *----------------------------------------------------------*/

#define string_alloc 			gdb_sta
#define string_free 			gdb_stf

#define create_tuple_descriptor 	gdb_ctd
#define delete_tuple_descriptor 	gdb_dtd
#define field_index			gdb_fi
#define create_tuple 			gdb_ctup
#define delete_tuple			gdb_dtup
#define initialize_tuple		gdb_itup
#define null_tuple_strings		gdb_ntps

#define create_relation			gdb_crel
#define delete_relation			gdb_drel
#define tuples_in_relation              gdb_trel


/*
 * Transport layer
 */
#define create_operation		gdb_crop
#define delete_operation		gdb_dop
#define initialize_operation	        gdb_inop
#define reset_operation			gdb_rsop
#define cancel_operation		gdb_cnop

#define create_list_of_operations	gdb_clop
#define delete_list_of_operations	gdb_dlop

#define op_select			gdb_opsel
#define op_select_any			gdb_opsel
#define op_select_all			gdb_aopsel
#define con_select			gdb_cnsel

#define gdb_receive_data 		gdb_rcdat        
#define gdb_send_data 			gdb_sndat        
#define gdb_start_listening		gdb_stl
#define start_accepting_client		gdb_stac


#define gdb_listen			gdb_lis

/*
 * Connection management
 */
#define start_peer_connection		gdb_spconn
#define sever_connection		gdb_svconn
#define start_server_connection		gdb_stsrv
#define create_listening_connection	gdb_clc
#define start_replying_to_client	gdb_strtc
#define create_forking_server		gdb_cfs


/*
 * Asynchronous operations
 */
#define start_sending_object 		gdb_snobj
#define start_receiving_object 		gdb_rcobj
#define preempt_and_start_receiving_object 		gdb_prcobj

#define queue_operation			gdb_qop

#define requeue_operation		g_req_op

#define complete_operation		gdb_cmpo
/*
 * Synchronous operations
 */
#define send_object			gdb_sobj
#define receive_object			gdb_robj
/*
 * Database operations
 */
#define access_db 			gdb_adb
#define start_accessing_db 		gdb_sadb
#define perform_db_operation		gdb_pdbo
#define db_query			gdb_dbq
#define start_performing_db_operation	gdb_spdb
#define   start_db_query			gdb_sdbq
#else
#define op_select_any  op_select
#endif /* DUMB_7_CHAR_LOADER */

extern char *string_alloc();
extern int   string_free();
extern TUPLE_DESCRIPTOR create_tuple_descriptor();
extern int  delete_tuple_descriptor();
extern int  field_index();
extern TUPLE create_tuple();
extern int   delete_tuple();
extern int   initialize_tuple();
extern int   null_tuple_strings();
extern RELATION create_relation();
extern int delete_relation();
extern OPERATION create_operation();
extern LIST_OF_OPERATIONS create_list_of_operations();
extern OPERATION g_op_newhead();
extern CONNECTION start_peer_connection();
extern CONNECTION sever_connection();
extern CONNECTION start_server_connection();
extern CONNECTION create_listening_connection();
extern CONNECTION create_forking_server();
extern int start_sending_object();
extern int start_receiving_object();
extern int preempt_and_start_receiving_object();
extern int queue_operation();
extern int requeue_operation();
extern int complete_operation();
extern int send_object();
extern int receive_object();


	/*----------------------------------------------------------
	 *	
	 *	Other routines requiring extern to avoid forward
	 *	reference to non integer type functions.
	 *	
	 *----------------------------------------------------------*/

extern CONNECTION g_make_con();