#ifndef STRUCTS_H
#define STRUCTS_H

/*****************************************************************************
* (c)1997 Perry Harrington	(perry@apsoft.com)
*
* Main system level object definitions.
*
* The module structures are designed to allow multiple instances of the
* loaded libaries.  
*
* There is record granularity locking within lists.  This way, multiple
* threads can update a list...thank the Linux network model for the 
* inspiration, it's a takeoff of the sk_buffs.
*
*****************************************************************************/

/* each shared object is maintained here */
typedef struct _module_list {
	struct	_module_list	*last;
	struct	_module_list	*next;
	DL_HANDLE		*module_dl_handle;
	MUTEX			entry_lock;
	Module_instances	*module_instances;
	int			module_reference_count;
} Module_list;

/* keep track of instances */
typedef struct _module_instances {
	struct	_module_instances	*last;
	struct	_module_instances	*next;
	MUTEX				entry_lock;
	Module				*module;
	Data_list			*data_list;
	Message_queue			*message_queue;
} Module_instances;
	
/* keep track of resident data */
typedef struct _data_list {
	struct	_data_list	*last;
	struct	_data_list	*next;
	MUTEX			entry_lock;
	Data			*data;
} Data_list;
	
/* keep track of messages delivered to module */
typedef struct _message_queue {
	struct	_message_queue	*last;
	struct	_message_queue	*next;
	MUTEX			entry_lock;
	Message			*message;
} Message_queue;
	
/* any loadable code */
typedef struct _module {
	char		module_version;		/* provision to use older modules in newer servers */
	long		module_id;
	long		module_type;
	long		module_parent;
	long		module_flags1;
	long		module_flags2;
	char		module_meta[255];
	Module_ops	*module_operations;
	void		*module_resources;	/* module specific vars struct */
} Module;

/* Resident or transient data */
typedef struct _data {
	long	data_owner;	/* changes when sent to another module */
	long	data_id;
	long	data_type;
	long	data_size;
	time_t	data_timestamp;
	long	data_checksum;
	char	data_meta_info[64];
	void	*data_payload;
} Data;

/* Intermodule communication protocol */
typdef struct _message {
	long	message_id;
	long	message_from_id;
	long	message_to_id;
	long	message_type;
	long	message_flags;
	long	message_disposition;
	long	message_sequence;
	Data	*message_payload;
} Message;

/* generic module stuff, each modules defines one inside it */
typedef struct _module_symbols {
	long		module_version;
	Module_ops	*module_operations;
} Module_symbols;

/* little, but growing */
typedef struct _module_operations {
	int (*accept_message) (Module *me, Message *message); /* called to queue message */
	int (*module_main) (Module *me);	/* called to start instance */
	int (*shutdown_module) (Module *me);	/* called to stop instance */
	int (*register_module) (Module *me);	/* called for instances */
	int (*init_module) (Module *me);	/* called on load to init globl */
	int (*fini_module) (Module *me);	/* called on unload */
} Module_ops;

#endif