///
///	@file 	mpr.h
/// @brief 	Header for the Mbedthis Portable Runtime (MPR)
//	@copy	default
//	
//	Copyright (c) Mbedthis Software LLC, 2003-2005. All Rights Reserved.
//	
//	This software is distributed under commercial and open source licenses.
//	You may use the GPL open source license described below or you may acquire 
//	a commercial license from Mbedthis Software. You agree to be fully bound 
//	by the terms of either license. Consult the LICENSE.TXT distributed with 
//	this software for full details.
//	
//	This software is open source; you can redistribute it and/or modify it 
//	under the terms of the GNU General Public License as published by the 
//	Free Software Foundation; either version 2 of the License, or (at your 
//	option) any later version. See the GNU General Public License for more 
//	details at: http://www.mbedthis.com/downloads/gplLicense.html
//	
//	This program is distributed WITHOUT ANY WARRANTY; without even the 
//	implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
//	
//	This GPL license does NOT permit incorporating this software into 
//	proprietary programs. If you are unable to comply with the GPL, you must
//	acquire a commercial license to use this software. Commercial licenses 
//	for this software and support services are available from Mbedthis 
//	Software at http://www.mbedthis.com 
//	
//	@end
//////////////////////////////// Documentation /////////////////////////////////
//
//	See mpr.dox for additional documentation.
//
////////////////////////////////////////////////////////////////////////////////

#error foo

#ifndef _h_MPR
#define _h_MPR 1
/////////////////////////////////// Includes ///////////////////////////////////

#include "web_server/ejs/config.h"
#include "web_server/ejs/mprOs.h"

////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////// C API ////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
extern "C" {
#else
typedef int bool;
#endif

extern void mprBreakpoint(const char *file, int line, const char *msg);

#if BLD_FEATURE_ASSERT
#define mprAssert(C)  \
	if (C) ; else mprError(MPR_L, MPR_TRAP, "%s", #C)
#define inlineAssert(C) \
	if (C) ; else mprBreakpoint(MPR_L, #C)
#else
	#define mprAssert(C)		if (1) ; else
	#define inlineAssert(C)		if (1) ; else
#endif

/////////////////////////////////// Constants //////////////////////////////////

#if BLD_FEATURE_SQUEEZE
///
///	Maximum length of a file path name. Reduced from the system maximum to 
///	save memory space.
///
#define MPR_MAX_PATH			256 		///< Reasonable max path name
#else
#define MPR_MAX_PATH			1024
#endif

#if BLD_FEATURE_SQUEEZE
///
///	Reasonable length of a file name used by the product. Use where you know
///	the expected file name and it is certain to be less than this limit.
///
#define MPR_MAX_FNAME			128			///< Reasonable size of a file name
#define MPR_DEFAULT_ALLOC		64			// Default small alloc size 
#define MPR_DEFAULT_HASH_SIZE	23			// Default size of hash table index 
#define MPR_DEFAULT_STACK		(32 * 1024)	// Default stack size
#else
#define MPR_MAX_FNAME			256
#define MPR_DEFAULT_ALLOC		128			// Default small alloc size 
#define MPR_DEFAULT_HASH_SIZE	43			// Default size of hash table index 
#define MPR_DEFAULT_STACK		(64 * 1024)	// Default stack size
#endif

#if BLD_FEATURE_SQUEEZE
#define MPR_MAX_ARGC			32			// Reasonable max of args
#define MPR_MAX_STRING			512			// Maximum string size 
#define MPR_MAX_LOG_STRING		512			// Maximum log message
#define MPR_MAX_URL				256			///< Reasonable size of a URL
#define MPR_BUFSIZE				512			///< Reasonable size for buffers
//	FUTURE -- could be named better
#define MPR_MAX_HEAP_SIZE		(32 * 1024)	// Maximum heap allocation size
#else
#define MPR_MAX_ARGC			128			// Reasonable max of args
#define MPR_MAX_STRING			4096		///< Maximum string size 
#define MPR_MAX_LOG_STRING		8192		// Maximum log message
#define MPR_MAX_URL				1024		///< Reasonable size of a URL
#define MPR_BUFSIZE				1024		// Reasonable size for buffers
#define MPR_MAX_HEAP_SIZE		(64 * 1024)	// Maximum heap allocation size
#endif

#define MPR_DEFAULT_BREAK_PORT	9473
#define MPR_TIMEOUT_LOG_STAMP	3600000		// Time between log time stamps
#define MPR_TIMEOUT_PRUNER		60000		// Time between pruner runs
#define MPR_TIMEOUT_STOP_TASK	10000		// Timeout to stop running tasks
#define MPR_TIMEOUT_STOP_THREAD	10000		// Timeout to stop running threads
#define MPR_TIMEOUT_CMD_WAIT	50			// Poll for cmd processes
#define MPR_TIMEOUT_STOP		5000		// Wait when stopping resources
#define MPR_NUM_DIALOG			5			// Maximum number of user dialogs 
#define MPR_MAX_LOG_SIZE		5			// Default size of a log file (MB)
#define MPR_MAX_IP_NAME			128			// Max size of an IP name
#define MPR_MAX_IP_ADDR			16			// Max size of an IP string addr
#define MPR_MAX_IP_ADDR_PORT	32			// Max size of IP with port

#define	MPR_TEST_TIMEOUT		10000		// Ten seconds 
#define MPR_TEST_LONG_TIMEOUT	300000		// 5 minutes 
#define MPR_TEST_SHORT_TIMEOUT	200			// 1/5 sec
#define	MPR_TEST_NAP			50			// When we must not block 

#if BLD_FEATURE_MULTITHREAD
#define MPR_DEFAULT_MIN_THREADS	0			// Default min threads (0)
#define MPR_DEFAULT_MAX_THREADS	10			// Default max threads (10)
#else
#define MPR_DEFAULT_MIN_THREADS	0			// Default min threads
#define MPR_DEFAULT_MAX_THREADS	0			// Default max threads 
#endif

//
//	MPR priorities (0 to 99)
//
#define MPR_BACKGROUND_PRIORITY	15			// May only get CPU if idle
#define MPR_LOW_PRIORITY		25
#define MPR_NORMAL_PRIORITY		50
#define MPR_HIGH_PRIORITY		75
#define MPR_CRITICAL_PRIORITY	99			// May not yield

#define MPR_SELECT_PRIORITY		75			// Run select at higher priority
#define MPR_POOL_PRIORITY		50			// Normal

//
//	Debug control
//
#define MPR_MAX_BLOCKED_LOCKS	100			// Max threads blocked on lock 
#define MPR_MAX_RECURSION		15			// Max recursion with one thread 
#define MPR_MAX_LOCKS			512			// Total lock count max 
#define MPR_MAX_LOCK_TIME		(60 * 1000)	// Time in millisecs to hold a lock 

//
//	Service / daemon control
//
#define MPR_INSTALL_SERVICE		1
#define MPR_UNINSTALL_SERVICE	2
#define MPR_GO_SERVICE			3
#define MPR_STOP_SERVICE		4

//
//	Parameter values for serviceEvents(loopOnce)
//
#define MPR_LOOP_ONCE			1
#define MPR_LOOP_FOREVER		0

//
//	Select service flags
//
#define MPR_ASYNC_SELECT		0x1		// Using async select in windows
#define MPR_BREAK_REQUESTED		0x2		// Breakout of a select wait
#define MPR_WAITING_FOR_SELECT	0x4		// Waiting for select to complete

///////////////////////////////// Error Codes //////////////////////////////////

//
//	Standard MPR return and error codes 
//

///	Base error code
#define MPR_ERR_BASE					(-200) 				
///	General error
#define MPR_ERR_GENERAL					(MPR_ERR_BASE - 1)	
///	Action aborted
#define MPR_ERR_ABORTED					(MPR_ERR_BASE - 2)	
///	Item already exists
#define MPR_ERR_ALREADY_EXISTS			(MPR_ERR_BASE - 3)	
///	Bad arguments or paramaeters
#define MPR_ERR_BAD_ARGS				(MPR_ERR_BASE - 4)	
///	Bad input format
#define MPR_ERR_BAD_FORMAT				(MPR_ERR_BASE - 5)	
#define MPR_ERR_BAD_HANDLE				(MPR_ERR_BASE - 6)	
///	Module is in a bad state
#define MPR_ERR_BAD_STATE				(MPR_ERR_BASE - 7)	
///	Input has bad syntax
#define MPR_ERR_BAD_SYNTAX				(MPR_ERR_BASE - 8)	
#define MPR_ERR_BAD_TYPE				(MPR_ERR_BASE - 9)	
#define MPR_ERR_BAD_VALUE				(MPR_ERR_BASE - 10)	
#define MPR_ERR_BUSY					(MPR_ERR_BASE - 11)	
///	Cant access the file or resource
#define MPR_ERR_CANT_ACCESS				(MPR_ERR_BASE - 12)	
#define MPR_ERR_CANT_COMPLETE			(MPR_ERR_BASE - 13)	
///	Cant create the file or resource
#define MPR_ERR_CANT_CREATE				(MPR_ERR_BASE - 14)	
#define MPR_ERR_CANT_INITIALIZE			(MPR_ERR_BASE - 15)	
///	Cant open the file or resource
#define MPR_ERR_CANT_OPEN				(MPR_ERR_BASE - 16)	
///	Cant read from the file or resource
#define MPR_ERR_CANT_READ				(MPR_ERR_BASE - 17)	
///	Cant write to the file or resource
#define MPR_ERR_CANT_WRITE				(MPR_ERR_BASE - 18)	
#define MPR_ERR_DELETED					(MPR_ERR_BASE - 19)	
#define MPR_ERR_NETWORK					(MPR_ERR_BASE - 20)	
#define MPR_ERR_NOT_FOUND				(MPR_ERR_BASE - 21)	
///	Module or resource is not initialized
#define MPR_ERR_NOT_INITIALIZED			(MPR_ERR_BASE - 22)	
#define MPR_ERR_NOT_READY				(MPR_ERR_BASE - 23)	
#define MPR_ERR_READ_ONLY				(MPR_ERR_BASE - 24)	
///	The operation timed out
#define MPR_ERR_NOT_INITIALIZED			(MPR_ERR_BASE - 22)	
#define MPR_ERR_TIMEOUT					(MPR_ERR_BASE - 25)	
#define MPR_ERR_TOO_MANY				(MPR_ERR_BASE - 26)	
#define MPR_ERR_WONT_FIT				(MPR_ERR_BASE - 27)	
#define MPR_ERR_WOULD_BLOCK				(MPR_ERR_BASE - 28)	
#define MPR_ERR_CANT_ALLOCATE			(MPR_ERR_BASE - 29)	
#define MPR_ERR_MAX						(MPR_ERR_BASE - 30)	

//
//	Standard error severity and trace levels. These are ored with the error 
//	severities below. The MPR_LOG_MASK is used to extract the trace level 
//	from a flags word. We expect most apps to run with level 2 trace.
//
#define	MPR_FATAL		0		///< Fatal error trace level. Cant continue.
#define	MPR_ERROR		1		///< Hard error trace level
#define MPR_WARN		2		///< Soft warning trace level
#define	MPR_CONFIG		2		///< Configuration settings trace level.
#define MPR_INFO		3		///< Informational trace only 
#define MPR_DEBUG		4		///< Debug information trace level
#define MPR_VERBOSE		9		///< Highest level of trace 
#define MPR_LOG_MASK	0xf		///< Level mask 

//
//	Error flags. Specify where the error should be sent to. Note that the 
//	product.xml setting "headless" will modify how errors are reported.
//	Assert errors are trapped when in DEV mode. Otherwise ignored.
//
#define	MPR_TRAP		0x10	// Assert mprError flags -- trap in debugger 
#define	MPR_LOG			0x20	///< Log to the O/S event log mprError flag
#define	MPR_USER		0x40	///< Display to the user mprError flag
#define	MPR_ALERT		0x80	// Send a management alert 
#define	MPR_TRACE		0x100	// Trace

//
//	Error format flags
//
#define MPR_RAW			0x200			// Raw trace output

//
//	Error line number information
//
#define MPR_L		__FILE__, __LINE__

////////////////////////////////////////////////////////////////////////////////
/////////////////////////////// Function Remappings ////////////////////////////
////////////////////////////////////////////////////////////////////////////////
//
//	Unsafe functions that should not be used. Define UNSAFE_STRINGS_OK before
//	including mpr.h if you really want to use these functions. A better approach
//	is to undefine them just prior to using them in your C/C++ source file.
//
#if BLD_FEATURE_SAFE_STRINGS

#if BLD_FEATURE_PHP4_MODULE || BLD_FEATURE_PHP5_MODULE
#ifndef UNSAFE_FUNCTIONS_OK
#define UNSAFE_FUNCTIONS_OK 1
#endif
#endif

#ifndef UNSAFE_FUNCTIONS_OK
#define sprintf			UseMprSprintfInstead
#define printf			UseMprPrintfInstead
#define fprintf			UseMprFprintfInstead
#define vsprintf		UseMprVsprintfInstead
#define strtok			UseMprStrTokInstead
#define gethostbyname	UseMprGetHostByNameInstead
#define ctime			UseMprCtimeInstead
#define asctime			UseMprAsctimeInstead
#define localtime		UseMprLocaltimeInstead
#define gmtime			UseMprGmtimeInstead
#define malloc			UseMprMallocInstead
#define free			UseMprFreeInstead
#define realloc			UseMprReallocInstead
#define calloc			UseMprCallocInstead
#define strncpy			UseMprStrcpyInstead
#define inet_ntoa		UseMprInetNtoaInstead

//
//	FUTURE -- to the whole way
//
//#define strlen		UseMprStrlenInstead
//#define strcpy		UseMprStrcpyInstead

#endif	// UNSAFE_FUNCTIONS_OK
#endif	// BLD_FEATURE_SAFE_STRINGS

//
//	File information structure
//
struct MprFileInfo {
	uint			size;					// File length 
	uint			mtime;					// Modified time 
	uint			inode;					// Inode number
	bool			isDir;					// Set if directory 
	bool			isReg;					// Set if a regular file 
};

//
//	Mpr time structure. Used for mprGetTime(). Matches requirements of select().
//
struct MprTime {
	long			sec;					// Seconds 
	long			usec;					// Microseconds (NOT milliseconds)
};
typedef struct MprTime MprTime;

#ifdef __cplusplus
} // extern "C"
#endif

////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////// C++ APIs ///////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#if __cplusplus

class	MprBuf;
class	MprFile;
class	MprFileSystem;
class	MprHashTable;
class	MprLink;
class	MprList;
class	MprPoolService;
class	MprPoolThread;
class	MprSelectService;
class	MprSelectHandler;
class	MprSocket;
class	MprSocketService;
class	MprStringData;
class	MprStringList;
class	MprTask;
class	MprTimerService;
class	MprTimer;

#if BLD_FEATURE_LOG
class	MprLogModule;
class	MprLogService;
class	MprLogListener;
class	MprLogToFile;
class	MprLogToWindow;
#endif

#if BLD_FEATURE_CGI_MODULE
class	MprCmd;
class	MprCmdFiles;
class	MprCmdService;
#endif

#if BLD_FEATURE_MULTITHREAD
class	MprCond;
class	MprMutex;
class	MprThreadService;
class	MprThread;
#else
typedef void *MprMutex;
#endif

#if BLD_FEATURE_RUN_AS_SERVICE && WIN
class	MprWinService;
#endif

/////////////////////////////////// MprLink ////////////////////////////////////

//
//	This define is used by classes that include a Link field member, to get
//	the base class pointer
//
#define MPR_GET_BASE(type, ptr, field) \
	((type) ((int) ptr - ((int) &(((type) 1)->field) - (int) ((type) 1))))

//
//	The MprLink class enables subclassed objects to be inserted in a MprList. It
//	provides forward and back links for fast insertion, removal and iteration.
//	To use MprLink, subclasses must inherit MprLink as a base class. Use 
//	MprList for the dummy list header and MprLink for the list members.
//	This class is NOT thread-safe. Callers must do their own thread
//	synchronization. It is designed to be "inline", very fast and no-frills.
//

class MprLink {
  // FUTURE -- revert to protected
  public:
	MprLink			*next;						// Ptr to next member in list
	MprLink			*prev;						// Ptr to prev member in list
	MprList			*head;						// Ptr to the list head

  public:
					MprLink() { 				///< Constructor
						next = prev = this; 
						head = 0;
					};
					~MprLink() {};				///< Destructor
	MprList			*getList() { return head; };///< Return the owning list

	inline void		insertAfter(MprLink *item);	///< Insert after this member
	inline void		insertPrior(MprLink *item);	///< Insert prior to this member
};

/////////////////////////////////// MprList ////////////////////////////////////
//
//	The MprList class defines the list (dummy) header for doubly linked objects.
//	It provides forward and back links for fast insertion, removal and 
//	iteration. To use MprLink, subclasses must inherit MprLink as a base class. 
//	Use MprList for the dummy list header and MprLink for the list members.
//	This class is NOT thread-safe. Callers must do their own thread
//	synchronization. It is designed to be "inline", very fast and no-frills.
//

class MprList : public MprLink {
  protected:
	int				numItems;					// Number of items in the list

  public:
					MprList() { 
						numItems = 0; 
						head = this;
						next = prev = this;
					};
					~MprList() {
					};
	inline void	insert(MprLink *item) {			/// Add to the end of the list
						inlineAssert(item->head == 0);
						if (item->head == 0) {
							numItems++;
						}
						item->head = this;
						item->next = head;
						item->prev = head->prev;
						prev->next = item;
						prev = item;
					};
	inline MprLink	*remove(MprLink *item) {	/// Remove this item
						inlineAssert(item->head == this);
						item->next->prev = item->prev;
						item->prev->next = item->next;
						item->prev = 0;
						item->next = 0;
						inlineAssert(numItems > 0);
						if (item->head == head) {
							numItems--;
						}
						item->head = 0;
						return next;
					};
	inline MprLink	*getFirst() {				/// Get first item
						return (next == head) ? 0 : next;
					};
	inline MprLink	*getLast() {				/// Get last item
						return (next == head) ? 0 : prev;
					};
	inline MprLink	*getNext(MprLink *item) {	/// Get next item
						inlineAssert(item->head == this);
						return (item->next == head) ? 0 : item->next;
					};
	inline MprLink	*getPrev(MprLink *item) {	/// Get previous item
						inlineAssert(item->head == this);
						return (item->prev == head) ? 0 : item->prev;
					};
	int				getNumItems() { 			/// Get number of items.
						return numItems; 
					};
	bool			emptyOk() { 
						if ((head == this) && (next == head) && 
							(prev == head) && (numItems == 0)) {
							return 1;
						} else {
							return 0;
						}
					};
	
	friend class	MprLink;
};

//
//	Inline methods for MprLink
//
inline void	MprLink::insertAfter(MprLink *item) {
					inlineAssert(item->head == 0);
					item->head = head;
					next->prev = item;
					item->prev = this;
					item->next = next;
					next = item;
					head->numItems++;
				};
inline void	MprLink::insertPrior(MprLink *item) {
					inlineAssert(item->head == 0);
					item->head = head;
					prev->next = item;
					item->next = this;
					item->prev = prev;
					prev = item;
					head->numItems++;
				};

//////////////////////////////// MprStringList /////////////////////////////////

class MprStringData : public MprLink {
  public:
	MprStr			string;

  public:
					MprStringData(char *s);
					~MprStringData();
	inline char		*getValue() { return string; };
};

class MprStringList : public MprList {
  public:
					MprStringList(char *str);
					MprStringList();
					~MprStringList();
	void			insert(char *str);
	void			parse(char *str);
};

////////////////////////////////// MprCmdLine //////////////////////////////////

class MprCmdLine {
  private:
	int				argc;
	char			**argv;				// Not duped
	void			*argvBuf;			// Storage for argv and args
	bool			inSwitch;
	int				optc;
	int				optind;
	char			*switches;			// Not duped

  public:
					MprCmdLine(int argc, char **argv, char *switches);
					MprCmdLine(char *args, char *switches);
					~MprCmdLine();
	char			**getArgv() { return argv; };
	int				getArgc() { return argc; };
	int				next(char **argp = 0);
	int				firstArg();
};

/////////////////////////////////// MprCond ////////////////////////////////////
#if BLD_FEATURE_MULTITHREAD

//
//	Condition variable for multi-thread synchronization
//
//	Condition variables can be used to coordinate threads when running in a
//	multi-threaded mode. These condition variables are level triggered in that
//	a condition can be signalled prior to another thread waiting. That thread
//	will then not block if it calls waitForCond().
//

class MprCond {
  private:
	#if BLD_DEBUG
		//
		//	This must be the first item in the class
		//
		MprLink		link;				// Cond-var leak monitoring
	#endif
	#if LINUX || MACOSX || SOLARIS
		pthread_cond_t 
					cv;					// Pthreads condition variable 
	#endif
	#if WIN
		HANDLE		cv;					// Windows event handle
		int			numWaiting;			// Number waiting to be signalled
	#endif
	#if VXWORKS
		SEM_ID		cv;					// Condition variable
	#endif
		MprMutex	*mutex;				// Thread sync
		int			triggered;			// Value of the condition

#if UNUSED
		int			wakeAll;			// Wake all waiters on signalCond()
#endif

  public:
					MprCond();
					~MprCond();
		int			waitForCond(long timeout = -1);
		void		signalCond();

#if UNUSED
		int			multiWait(MprMutex *externalMutex, long timeout = -1);
		void		reset();
		void		signalAll();
#endif
};

#endif // BLD_FEATURE_MULTITHREAD
/////////////////////////////////// MprDebug ///////////////////////////////////
#if BLD_DEBUG

class MprDebug {
  public:
#if BLD_FEATURE_MULTITHREAD
	int				getMutexNum();
#endif 
};

#endif
/////////////////////////////////// MprFile ////////////////////////////////////

class MprFile {
  private:
	MprBuf			*inBuf;
	int				fd;
  public:
					MprFile();
	virtual			~MprFile();
	virtual int 	open(char* path, int flags, int mode);
	virtual void	close();
	virtual char	*gets(char *buf, int len);
	virtual int		read(void* buf, int len);
	virtual int		write(void* buf, int len);
	virtual long 	lseek(long offset, int origin);
};

//////////////////////////////// MprFileSystem /////////////////////////////////

class MprFileSystem {
  private:
  public:
					MprFileSystem();
	virtual			~MprFileSystem();
	virtual MprFile	*newFile();
	virtual int 	stat(char* path, MprFileInfo* info);
	virtual bool 	isDir(char* path);
	virtual void 	setRoot(char* path);
};

/////////////////////////////////// MprMutex ///////////////////////////////////
#if BLD_FEATURE_MULTITHREAD

//
//	Mutual exclusion locks
//
class MprMutex {
  public:
	#if BLD_DEBUG
		MprLink		link;				// Must be the first in the class
	#endif
	#if WIN
		CRITICAL_SECTION cs;			// O/S critical section
	#endif
	#if LINUX || MACOSX || SOLARIS
		pthread_mutex_t	 cs;			// O/S critical section
	#endif
	#if VXWORKS
		SEM_ID		cs;					// Semaphore
	#endif

  public:
					MprMutex();
					~MprMutex();
	int				tryLock();

	//	FUTURE -- should do Windows inline also.

	#if LINUX || MACOSX || SOLARIS
		inline void	lock() { pthread_mutex_lock(&cs); };
		inline void	unlock() { pthread_mutex_unlock(&cs); };
	#elif VXWORKS && 0
		inline void	lock() { semTake(cs, WAIT_FOREVER); };
		inline void	unlock() { semGive(cs); };
	#else
		void		lock();
		void		unlock();
	#endif

	friend class	MprCond;
};

#endif // BLD_FEATURE_MULTITHREAD
////////////////////////////////////// Mpr /////////////////////////////////////
//
//	Mpr flags
//
#define MPR_EXITING				0x1		// Mpr is exiting
#define MPR_ASYNC_SELECTING		0x2		// Using async select
#define MPR_HEADLESS			0x4		// No user interface
#define MPR_SERVICE_THREAD		0x10	// Using a service thread for events
#define MPR_IS_DAEMON			0x20	// Is a daemon / service
#define MPR_STOPPED				0x40	// Mpr services stopped
#define MPR_STARTED				0x80	// Mpr services started
#define MPR_KILLABLE			0x100	// MPR can be killed (need a pid file)
#define MPR_USER_START_FLAGS	(MPR_SERVICE_THREAD | MPR_KILLABLE)

typedef int		(*MprDllEntryProc)(void *arg);

//
//	The Mbedthis Portable Runtime (MPR) internal state class.
//	
class Mpr {
  private:
	MprStr			appName;			// One word name of the application 
	MprStr			appTitle;			// Displayable name of the product 
	int				buildNumber;		// Build number 
	MprStr			buildType;			// Build type 
	MprHashTable	*configSettings;	// Configuration settings for app
	MprStr			cpu;				// Procesor 
	MprStr			domainName;			// Domain portion
	MprStr			hostName;			// Host name (fully qualified name)
	MprStr			installDir;			// Installation directory (!= cwd)
	MprStr			os;					// Operating system
	MprStr			serverName;			// Server name portion (no domain)
	MprStr			version;			// Application version number (x.y.z)

	//
	//	FUTURE -- Convert to flags
	//
	int				flags;				// Processing state
	int				headless;			// Run headless
	bool			runAsService;		// Running as a service (daemon)
	bool			eventsThread;		// Running an events thread

#if WIN
	long			appInstance;		// Application instance (windows)
	HWND			hwnd;				// Window handle
#endif

#if BLD_FEATURE_LOG
	MprLogModule	*defaultLog;		// Default log module
#endif

#if BLD_FEATURE_MULTITHREAD
	MprMutex		*mutex;				// Thread synchronization 
	MprMutex		*timeMutex;			// Thread sync for mprGetTime 
	MprMutex		*eventsMutex;		// Thread sync for serviceEvents 
#endif

  public:
#if BLD_FEATURE_LOG
	MprLogService		*logService;	// Log service object
#endif
	MprPoolService		*poolService;	// Pool service object
	MprSelectService	*selectService;	// Select service object
	MprSocketService	*socketService;	// MprSocket service object
	MprTimerService		*timerService;	// Timer service object
	MprList				modules;		// List of modules

#if BLD_FEATURE_CGI_MODULE
	MprCmdService		*cmdService;	// Run command service object
#endif
#if BLD_FEATURE_MULTITHREAD
	MprThreadService	*threadService;	// Thread service object
#endif

  public:
	//
	//	Published API
	//
					Mpr(char *appName);
					~Mpr();
#if BLD_FEATURE_LOG
	void			addListener(MprLogListener *lp);
#endif
	bool			getAsyncSelectMode();
	int				getIdleTime();
	bool			isExiting(void);
	int				runTasks();
	int				runTimers();
	void			serviceEvents(bool loopOnce, int maxTimeout);
	void			setAsyncSelectMode(bool on);
	int				setLogSpec(char *spec);
	int				start(int startFlags = 0);
	int				stop(bool immediateStop);
	void			terminate(bool graceful = 1);
#if WIN
	void			setHwnd(HWND appHwnd);
	void			setSocketHwnd(HWND socketHwnd);
	void			setSocketMessage(int msgId);
#endif

	//
	//	Unpublished API
	//

	int				configure(char *configFile);
	char			*getAppName(void);
	char			*getAppTitle(void);
	int				getBuildNumber(void);
	char			*getBuildType(void);
	char			*getCpu(void);
	char			*getDomainName(void);
	int				getFds(fd_set *readInterest, fd_set *writeInterest, 
						fd_set *exceptInterest, int *maxFd, int *lastGet);
	int				getHeadless(void);
	char			*getHostName(void);
	char			*getInstallDir(void);
	char			*getOs(void);
	char			*getServerName(void);
	char			*getVersion(void);
	bool			isRunningEventsThread() { return eventsThread; };
	bool			isService();
	int				killMpr();
	int				makeDaemon(int parentExit);
	void			serviceIO(int readyFds, fd_set *readFds, fd_set *writeFds, 
						fd_set *exceptFds);
	void			serviceIO(int sockFd, int winMask);
	void			setAppName(char *name);
	void			setAppTitle(char *name);
	void			setBuildNumber(int buildNumber);
	void			setBuildType(char *type);
	void			setCpu(char *cpu);
	void			setDomainName(char *host);
	void			setHeadless(int headless);
	void			setHostName(char *host);
	void			setInstallDir(char *dir);
	void			setOs(char *os);
	void			setPriority(int pri);
	void			setServerName(char *host);
	void			setService(bool service);
	void			setVersion(char *version);
	void			setWebServerAddress(char *path);
	void			writeToOsLog(char *msg, int etype);

#if BLD_FEATURE_MULTITHREAD
	void			startEventsThread();
	void			setMinPoolThreads(int n);
	void			setMaxPoolThreads(int n);
	int				getMinPoolThreads();
	int				getMaxPoolThreads();
	int				getNextThreadNum();
	MprThread		*getCurrentThread();
	inline void	lock() { 
						if (mutex) {
							mutex->lock(); 
						}
					};
	inline void		unlock() { 
						if (mutex) {
							mutex->unlock(); 
						}
					};
	void			timeLock() { timeMutex->lock(); };
	void			timeUnlock() { timeMutex->unlock(); };
#else
	int				getMaxPoolThreads() { return 0; };
	inline void		lock() {};
	inline void		unlock() {};
	inline void		timeLock() {};
	inline void		timeUnlock() {};
#endif

#if WIN
	HWND			getHwnd();
	long			getInst();
	void			setInst(long inst);
#endif

#if BLD_FEATURE_DLL
	int				loadDll(char *path, char *fnName, void *arg, void **handle);
	void			unloadDll(void *handle);
#endif

#if BLD_FEATURE_XML_CONFIG
	int				openConfigFile(char *path);
	int				openXmlFile(char *path);
	int				readXmlInt(MprHashTable *symTab, char *key, int *value);
	int				readXmlStr(MprHashTable *symTab, char *key, char **value);
#endif
	char			*getConfigStr(char *key, char *defaultValue);
	int				getConfigInt(char *key, int defaultValue);

#if BLD_FEATURE_CGI_MODULE
	MprCmdService	*getCmdService() { return cmdService; };
#endif

  private:
	int				platformInitialize();
	int				platformTerminate();
	int				platformStart(int startFlags);
	int				platformStop();
};

#if MPR_IN_MPR
extern Mpr			*mpr;					// Default global Mpr class
#endif

extern Mpr			*mprGetMpr();

//////////////////////////////// MprHashEntry //////////////////////////////////
//
//	Master hash entry type. Not thread safe.
//

class MprHashEntry : public MprLink {
  private:
	MprStr			key;
	MprList			*bucket;

  public:
					MprHashEntry();
					MprHashEntry(char *key);
	virtual			~MprHashEntry();
	char			*getKey();
	void			setKey(char *key);
	friend class	MprHashTable;
};

//
//	String entry type
//
class MprStringHashEntry : public MprHashEntry {
  private:
	MprStr			value;
  public:
					MprStringHashEntry(char *key, char *str);
	virtual			~MprStringHashEntry();
	char			*getValue() { return value; };
};

//
//	Static string (not duplicated)
//
class MprStaticHashEntry : public MprHashEntry {
  private:
	char			*value;
  public:
					MprStaticHashEntry(char *key, char *str);
	virtual			~MprStaticHashEntry();
	char			*getValue() { return value; };
};

#if PERHAPS
//
//	Object string (not duplicated)
//
class MprObjectHashEntry : public MprHashEntry {
  private:
	char			*value;
  public:
					MprObjectHashEntry(char *key, char *str);
	virtual			~MprObjectHashEntry();
	char			*getValue() { return value; };
};
#endif

///////////////////////////////// MprHashTable /////////////////////////////////

class MprHashTable {
  private:
	MprList			*buckets;
	int				size;
	int				count;

  public:
					MprHashTable(int hash_size = MPR_DEFAULT_HASH_SIZE);
					~MprHashTable();
	MprHashEntry	*getFirst();
	MprHashEntry	*getNext(MprHashEntry *ep);
	int				getNumItems() { return count; };
	int				insert(MprHashEntry *entry);
	MprHashEntry	*lookup(char *key);
	int				remove(char *key);
	int				remove(MprHashEntry *entry);
	int				removeAll();

  private:
	MprHashEntry	*lookupInner(char *key, MprList **bucket);
	int				hashIndex(char *key);
	int				getNextPrime(int size);
};

//////////////////////////////// MprLogService /////////////////////////////////
#if BLD_FEATURE_LOG

class MprLogListener : public MprLink {
  private:
	int				maxSize;				// Max size of log
  public:
	//
	//	Published API
	//
					MprLogListener();		///< Constructor
	virtual			~MprLogListener();		///< Destructor
	virtual void	logEvent(char *module, int flags, int level, char *thread, 
		char *msg);
	virtual int	 	start();

	//
	//	Unpublished API
	//
	virtual void	shuttingDown();
	virtual int	 	setLogSpec(char *path, int maxSize);
	virtual void 	stop();
};


class MprLogToFile : public MprLogListener {
  private:
	int				logFd;				// MprLogService file handle 
	MprStr			logFileName;		// Current name of log file
	bool			timeStamps;			// Output high res time stamps
	uint			maxSize;			// Maximum extent of trace file 
	int				rotationCount;		// Number of times logs rotated
	MprTimer		*timer;				// Log file time stamp timer
  public:
					MprLogToFile();		///< Constructor
					~MprLogToFile();	///< Destructor
	void			logEvent(char *module, int flags, int level, char *thread, 
						char *msg);
	void			enableTimeStamps(bool on);
	void			logConfig();
	void			rotate();
	void			shuttingDown();
	int				setLogSpec(char *path, int maxSize);
	int				start();
	void			stop();
	void			writeTimeStamp();
};


class MprLogToWindow : public MprLogListener {
  private:
  public:
					MprLogToWindow();		///< Constructor
					~MprLogToWindow();		///< Destructor
	void			logEvent(char *module, int flags, int level, char *thread, 
						char *msg);
};


//
//	Overall logging service
//
class MprLogService {
  private:
	MprList			listeners;			// Users registered for output
	uint			defaultLevel;		// Default level for modules
	MprLogModule	*defaultModule;		// Default log module for this log
	MprList			moduleList;			// List of modules to trace 
	char			*moduleSpecs;		// Module level spec string
	char			*logSpec;			// Saved logging spec string
	bool			logging;			// Logging is enabled
#if BLD_FEATURE_MULTITHREAD
	MprMutex		*mutex;				// Mutex lock 
#endif

  public:
					MprLogService();
					~MprLogService(void);
	void			addListener(MprLogListener *lp);
	void			insertModule(MprLogModule *module);
	void			error(char *file, int line, int flags, char *fmt, 
						va_list args);
	MprLogModule	*getDefaultModule() { return defaultModule; }; 
	int				getDefaultLevel() { return defaultLevel; };
	char			*getLogSpec() { return logSpec; };
	char			*getModuleSpecs();
	bool			isLogging();
	void			removeListener(MprLogListener *lp);
	void			removeModule(MprLogModule *module);
	void			setDefaultLevel(int l);
	void			setDefaultModule(MprLogModule *m) { defaultModule = m; };
	int				setLogSpec(char *fileSpec);
	void			shuttingDown();
	void			start();
	void			stop();
	void			traceCore(int level, int flags, MprLogModule *module, 
						char *fmt, va_list ap);
	void			writeHeader();
	void			writeLogStamp();

#if BLD_FEATURE_MULTITHREAD
	void			lock() { 
						if (mutex) {
							mutex->lock(); 
						}
					};
	void			unlock() { 
						if (mutex) {
							mutex->unlock(); 
						}
					};
#else
	inline void		lock() {};
	inline void		unlock() {};
#endif

  private:
	void			output(MprLogModule *module, int flags, int level, 
						char *msg);
	void			breakpoint(char *file, int line);
};

extern void		mprLog(int level, MprLogModule *module, char *fmt, ...);
extern void		mprLog(int level, int flags, MprLogModule *module, 
					char *fmt, ...);
extern void		mprLog(char *fmt, ...);

#else // !BLD_FEATURE_LOG
//
//	If logging is not enabled, we inline these functions to nothing
//
class MprLogModule { 
	void *x; 
  public:
	MprLogModule(char *name) {}
};
inline void		mprLog(int level, MprLogModule *module, char *fmt, ...) {};
inline void		mprLog(char *fmt, ...) {}
extern "C" void		mprLog(int level, char *fmt, ...);
#endif

///////////////////////////////// MprLogModule /////////////////////////////////
#if BLD_FEATURE_LOG
//
//	Class to describe a trace log module
//

class MprLogModule : public MprLink {
  private:
	MprStr			name;
	int				level;				// Current trace output level 
	bool			enabled;

  public:
					MprLogModule(char *name);
					~MprLogModule();
	void			innerMprLogModule(char *name);
	int				getLevel(void) { return level; };
	void			disable() { enabled = 0; };
	void			enable() { enabled = 1; };
	int				getEnabled() { return enabled; };
	char			*getName() { return name; };
	void			setLevel(int l) { level = l; };
};

#endif // BLD_FEATURE_LOG
//////////////////////////////////// MprBuf ////////////////////////////////////

typedef int			(*MprBufProc)(MprBuf* bp, void *arg);

class MprBuf {
  private:
	uchar			*buf;				// Actual buffer for data 
	uchar			*endbuf;			// Pointer one past the end of buffer 
	uchar			*start;				// Pointer to next data char 
	uchar			*end;				// Pointer one past the last data char 
	int				buflen;				// Current size of buffer 
	int				maxsize;			// Max size the buffer can ever grow 
	int				growBy;				// Next growth increment to use 
	MprBufProc		refillProc;			// Function to refill the buffer
	void			*refillArg;			// Arg to refill proc

  public:
					MprBuf();
					MprBuf(int initialSize, int maxsize = -1);
					~MprBuf();
	inline void		addNull() {
						*((char*) end) = (char) '\0';
					};
	void			adjustStart(int size);
	void			adjustEnd(int size);
	void			copyDown();
	inline void		flush() {
						start = buf;
						end = buf;
					};
	inline int		get() {
						if (start == end) {
							return -1;
						}
						int	c = (uchar) *start++;
						if (start >= endbuf) {
							start = buf;
						}
						return c;
					};
	int				get(uchar *buf, int len);
	inline char		*getBuf() { return (char*) buf; };
	inline char		*getEnd() { return (char*) end; };
	inline char		*getEndBuf() { return (char*) endbuf; };
	inline int		getLength() {
						return ((start > end) ? 
							(buflen + (end - start)) : (end - start));
					};
	inline int		getLinearData() {
						return min((endbuf - start), getLength());
					}
	inline int		getLinearSpace() {
						int len = getLength();
						int space = buflen - len - 1;
						return min((endbuf - end), space);
					}
	inline int		getSpace() {
						return buflen - getLength() - 1;
					};
	inline char		*getStart() { return (char*) start; };
	inline int		getSize() { return buflen; };
	int				insert(char c);
	inline int		look() {
						if (start == end) {
							return -1;
						}
						return* start;
					}
	int				lookLast();
	int				put(char c);
	int				put(char *str);
	int				putInt(int i);
	int				putFmt(char *fmt, ...);
	int				put(uchar *buf, int len);
	inline int		refill() { 
						return (refillProc) ? 
							(refillProc)(this, refillArg) : 0; 
					};
	inline void		resetIfEmpty() {
						if (getLength() == 0) {
							flush();
						}
					};
	void			setBuf(uchar *userBuf, int size);
	void			setBuf(int initialSize, int maxSize);
	void			setRefillProc(MprBufProc fn, void *arg) { 
						refillProc = fn; 
						refillArg = arg; 
					};
	uchar			*takeBuffer();
  private:
	int				grow();
};

//////////////////////////////// MprCmdService /////////////////////////////////
#if BLD_FEATURE_CGI_MODULE
//
//	Flags for MprCmd
//
#define MPR_CMD_BACKGROUND	0x1			// Continue running if MPR exits 
#define MPR_CMD_REAP_MAX	24

//
//	Cmd service control
//

class MprCmdService {
  private:
	MprList			cmdList;			// List of commands
	MprMutex		*mutex;				// Multi-thread sync
	ulong			completedCmds[MPR_CMD_REAP_MAX];
	int				exitStatus[MPR_CMD_REAP_MAX];
	MprTimer		*timer;				// Timer to poll for child completion

  public:
					MprCmdService();
					~MprCmdService();
	void			cmdWatcher();
	void			cmdWatcherTimer(MprTimer *tp);
	void			insertCmd(MprCmd* rp);
	void			removeCmd(MprCmd* rp);
	int				start();
	void			startWatcher();
	int				stop();

#if LINUX || SOLARIS || VXWORKS
	void			processStatus(int pid, int status);
	void			initSignals();
#endif

#if BLD_FEATURE_MULTITHREAD
	void			lock() { mutex->lock(); };
	void			unlock() { mutex->unlock(); };
#else
	inline void		lock() {};
	inline void		unlock() {};
#endif
};

//////////////////////////////////// MprCmd ////////////////////////////////////

//
//	Cmd procs must return the number of bytes read or -1 for errors.
//
typedef void	(*MprCmdProc)(MprCmd* rp, void *data);

#define MPR_CMD_EOF			-1			// EOF return value

//
//	Flags
//
#define MPR_CMD_DETACHED	0x1
#define MPR_CMD_NEW_SESSION	0x2
#define MPR_CMD_CHDIR		0x4
#define MPR_CMD_WAIT		0x8
#define MPR_CMD_SHOW		0x10
#define MPR_CMD_USER_FLAGS	0x1f

#define MPR_CMD_COMPLETE	0x40
#define MPR_CMD_DISPOSED	0x80
#define MPR_CMD_STDIO_MADE	0x100

//
//	Indicies for clientFd and serverFd
//
#define MPR_CMD_IN			0			// Stdin for the server
#define MPR_CMD_OUT			1			// Stdout for the server
#define MPR_CMD_MAX_FD		2

#define MPR_CMD_WATCHER_NAP		100		// Timeout for watcher while polling
#define MPR_CMD_WATCHER_TIMEOUT	5000	// Timeout for child to start

class MprCmdFiles {
  public:
	MprStr			name[MPR_CMD_MAX_FD];
	int				fd[MPR_CMD_MAX_FD];
	int				clientFd[MPR_CMD_MAX_FD];
  public:
					MprCmdFiles();
					~MprCmdFiles();
};

//
//	MprCmd class
//
class MprCmd : public MprLink {
  private:
	MprStr			cwd;				// Current working dir for the process
	void			*data;				// Callback user data
	int				exitStatus;			// Command exit status
	int				flags;				// Control flags (userFlags not here)
	MprCmdFiles		files;				// Stdin, stdout for the command
	int				inUse;				// Used by dispose()
	MprLogModule	*log;
	MprCmdProc		cmdDoneProc;		// Handler for client completion

#if VXWORKS
	MprSelectHandler	
					*handler;
	int				waitFd;				// Pipe to await child exit
#endif
	ulong			process;			// Id/handle of the created process

#if BLD_FEATURE_MULTITHREAD
#if VXWORKS
	MprCond			*startCond;
	MprCond			*exitCond;
#endif
	MprMutex		*mutex;
#endif

  public:
					MprCmd();
					~MprCmd();
	void			closeWriteFd();
	int				dispose();
	int				getExitCode(int *code = 0);
	int				getWriteFd();
	int				getReadFd();
	void			invokeCallback(MprMutex *callerMutex);
	bool			isRunning();
	int				makeStdio();
	void			setCwd(char *dir);
	int				setInuse();
	int				start(char *cmd, int flags);
	int				start(char *cmd, char **argv, char **envp, 
						MprCmdProc completionProc, void *data, int flags);
	void			stop();

	//
	//	Internal API
	//
	ulong			getProcess() { return process; };
	void			reset();
	void			resetFiles();
	void			setExitStatus(int status);

  private:
	int				waitForChild(int timeout);

#if BLD_FEATURE_MULTITHREAD
	void			lock() { mutex->lock(); };
	void			unlock() { mutex->unlock(); };
#else
	inline void		lock() {};
	inline void		unlock() {};
#endif

	friend class	MprCmdService;
};

#endif // BLD_FEATURE_CGI_MODULE
////////////////////////////// MprSelectService ////////////////////////////////
//
//	Standard select bit mask options
//
#define MPR_READABLE			0x2
#define MPR_WRITEABLE			0x4
#define MPR_EXCEPTION			0x8

typedef void		(*MprSelectProc)(void *data, int mask, int isMprPoolThread);

class MprSelectService {
  private:
	struct sockaddr_in 
					breakAddress;		// Breakout port socket address
	int				breakSock;			// MprSocket to wakeup select service
	int				breakPort;			// Port to talk to the select service
	int				breakRetries;		// Retry attempts to open breakout port
	MprList			list;				// List of select handlers
	int				flags;				// State flags
	int				maskGeneration;		// Generation number for mask changes
	int				listGeneration;		// Generation number for list changes
	MprLogModule	*log;
	int				rebuildMasks;		// Complete select mask rebuild required
	int				delayedFds[FD_SETSIZE];
	int				maxDelayedFd;
#if WIN
	int				sockMessage;		// MprSocket message for AsyncSelect
	HWND			hwnd;				// Window handle to use for AsyncSelect
#endif

#if BLD_FEATURE_MULTITHREAD
	MprCond			*cond;				// Wait for select to breakout
	MprMutex		*mutex;				// General multi-thread synchronization
#endif

  public:
	//
	//	Published API
	//
					MprSelectService();
					~MprSelectService();
	int				getFds(fd_set *readInterest, fd_set *writeInterest, 
						fd_set *exceptInterest, int *maxFd, int *lastGet);
	void			serviceIO(int readyFds, fd_set *readFds, fd_set *writeFds, 
						fd_set *exceptFds);
	void			serviceIO(int sockFd, int winMask);

	//
	//	Unpublished API
	//
	int				insertHandler(MprSelectHandler *sp);
	void			awaken(int wait = 0);
	void			delayedClose(int fd);
	bool			getAsyncSelectMode();
	int				getFlags() { return flags; };
	int				modifyHandler(MprSelectHandler *sp, bool wakeUp);
	void			removeHandler(MprSelectHandler *sp);
	MprLogModule	*getLog() { return log; };
	int				openBreakoutPort();
	void			setPort(int n);
	int				start();
	int				stop();

#if BLD_FEATURE_MULTITHREAD
	void			lock() { mutex->lock(); };
	void			unlock() { mutex->unlock(); };
#else
	inline void		lock() {};
	inline void		unlock() {};
#endif

#if WIN
	HWND			getHwnd() { return hwnd; };
	int				getMessage() { return sockMessage; };
	void			setHwnd(HWND h) { hwnd = (HWND) h; };
	void			setMessage(int m) { sockMessage = m; };
	void			setAsyncSelectMode(bool asyncSelect);
#endif
};

////////////////////////////// MprSelectHandler ////////////////////////////////
//
//	Flags
//
#define MPR_SELECT_DISPOSED			0x1
#define MPR_SELECT_RUNNING			0x2
#define MPR_SELECT_CLOSEFD			0x4
#define MPR_SELECT_CLIENT_CLOSED	0x8	// Client disconnection received

class MprSelectHandler : public MprLink {
  private:
	int				desiredMask;		// Mask of desired events 
	int				disableMask;		// Mask of disabled events 
	int				fd;					// O/S File descriptor (sp->sock) 
	int				flags;				// Control flags
	void			*handlerData;		// Argument to pass to proc. 
	int				inUse;				// Used by dispose()
	MprLogModule	*log;
	int				presentMask;		// Mask of events that have been seen 
	int				priority;			// Priority if events handled by threads

#if BLD_FEATURE_MULTITHREAD
	MprCond			*stoppingCond;		// Synchronization when stopping
#endif

  public:
	MprSelectService *selectService;	// Select service pointer
	MprSelectProc	proc;				// Select handler procedure 

  public:
					MprSelectHandler(int fd, int mask, MprSelectProc proc, 
						void *data, int priority);
	bool			dispose();
	void			disableEvents(bool wakeUp);
	void			enableEvents(bool wakeUp);
	int				getFd() { return fd; };
	int				getFlags() { return flags; };
	void			runHandler();
	void			selectProc(MprTask *tp);
	void			setInterest(int mask);
	void			setWinInterest();
	void			setProc(MprSelectProc newProc, int mask);
	void			setCloseOnDispose();
	int				stop(int timeout);

  private:
					~MprSelectHandler();

	friend class	MprSelectService;
};

//////////////////////////////// MprInterface //////////////////////////////////

class MprInterface : public MprLink {
  public:
	MprStr			name;				// Interface name
	MprStr			ipAddr;
	MprStr			broadcast;
	MprStr			mask;
  public:
					MprInterface(char *name, char *ipAddr, char *bcast, 
						char *mask);
					~MprInterface();
};

////////////////////////////// MprSocketService ////////////////////////////////

typedef void		(*MprSocketIoProc)(void *data, MprSocket *sp, int mask, 
						int isMprPoolThread);
typedef void		(*MprSocketAcceptProc)(void *data, MprSocket *sp, char *ip, 
						int port, MprSocket *lp, int isMprPoolThread);
//
//	Mpr socket service class
//
class MprSocketService {
  private:
	MprList			socketList;			// List of all sockets
	MprList			ipList;				// List of ip addresses 
	MprLogModule	*log;

#if BLD_FEATURE_MULTITHREAD
	MprMutex		*mutex;
#endif

  public:
					MprSocketService();
					~MprSocketService();
#if BLD_FEATURE_LOG
	MprLogModule	*getLogModule() { return log; };
#endif
	MprList			*getInterfaceList();
	void			insertMprSocket(MprSocket *sp);
	void			removeMprSocket(MprSocket *sp);
	int				start();
	int				stop();

#if BLD_FEATURE_MULTITHREAD
	void			lock() { mutex->lock(); };
	void			unlock() { mutex->unlock(); };
#else
	inline void		lock() {};
	inline void		unlock() {};
#endif

  private:
	int				getInterfaces();
};

////////////////////////////////// MprSocket ///////////////////////////////////
//
//	close flags
//
#define MPR_SHUTDOWN_READ		0
#define MPR_SHUTDOWN_WRITE		1
#define MPR_SHUTDOWN_BOTH		2

//
//	Flags
//
#define MPR_SOCKET_BLOCK		0x1			// Use blocking I/O 
#define MPR_SOCKET_BROADCAST	0x2			// Broadcast mode 
#define MPR_SOCKET_CLOSED		0x4			// MprSocket has been closed 
#define MPR_SOCKET_CONNECTING	0x8			// MprSocket has been closed 
#define MPR_SOCKET_DATAGRAM		0x10		// Use datagrams 
#define MPR_SOCKET_EOF			0x20		// Seen end of file 
#define MPR_SOCKET_LISTENER		0x40		// MprSocket is server listener 
#define MPR_SOCKET_NOREUSE		0x80		// Dont set SO_REUSEADDR option  
#define MPR_SOCKET_NODELAY		0x100		// Disable Nagle algorithm 
#define MPR_SOCKET_DISPOSED		0x200		// Delete requested

#define MPR_SOCKET_READABLE		0x2
#define MPR_SOCKET_WRITABLE		0x4
#define MPR_SOCKET_EXCEPTION	0x8

class MprSocket : public MprLink 
{
  private:
	MprSocketAcceptProc 
					acceptCallback;		// Accept callback 
	void			*acceptData;		// User accept callback data 
	int				currentEvents;		// Mask of ready events (FD_x) 
	int				error;				// Last error 
	MprSelectHandler *handler;			// Select handler
	int				handlerMask;		// Handler events of interest 
	int				handlerPriority;	// Handler priority 
	int				interestEvents;		// Mask of events to watch for 
	MprSocketIoProc	ioCallback;			// User I/O callback 
	void			*ioData;			// User io callback data 
	void			*ioData2;			// Secondary user io callback data 
	int				inUse;				// In use counter. Used by dispose()
	MprStr			ipAddr;				// Host IP address
	MprLogModule	*log;				// Pointer to MprSocketService module
	int				port;				// Port to listen on 
	int				selectEvents;		// Events being selected 

#if BLD_FEATURE_MULTITHREAD
	MprMutex		*mutex;				// Multi-thread sync
#endif

  protected:
	int				sock;				// Actual socket handle 
	int				flags;				// Current state flags 
	bool			secure;				// MprSocket is using SSL

  public:
					MprSocket();
	void			forcedClose();
	void			acceptProc(int isMprPoolThread);
	bool			getEof();
	int				getError();
	int				getFlags();
	char			*getIpAddr() { return ipAddr; };
	int				getPort();
	int				getFd();
	bool			getBlockingMode();
	void			getAcceptCallback(MprSocketAcceptProc *fn, void **data);
	void			getCallback(MprSocketIoProc *fn, void **data, 
						void **data2, int *mask);
	bool			isSecure() { return secure; };
	int				openServer(char *ipAddr, int portNum, 
						MprSocketAcceptProc acceptFn, void *data, int flags);
	int				openClient(char *hostName, int portNum, int flags);
	void			setBlockingMode(bool on);
	int				setBufSize(int sendSize, int recvSize);
	//	FUTURE -- rename: handler vs callback
	void			setCallback(MprSocketIoProc fn, void *data, 
						void *data2, int mask, int pri = MPR_NORMAL_PRIORITY);
	int				write(char *s);

	virtual 		~MprSocket();
	virtual void	close(int how);
	virtual bool	dispose();
	virtual void	ioProc(int mask, int isMprPoolThread);
	virtual MprSocket	
					*newSocket();
	virtual int		read(char *buf, int len);
	virtual int		write(char *buf, int len);

#if BLD_FEATURE_MULTITHREAD
	void			lock() { mutex->lock(); };
	void			unlock() { mutex->unlock(); };
#else
	inline void		lock() {};
	inline void		unlock() {};
#endif

  private:
	void			setMask(int handlerMask);
	void			setNoDelay(bool on);

	friend class	MprSocketService;
};

//////////////////////////////// MprPoolService ////////////////////////////////

#if BLD_DEBUG
class MprPoolStats {
  public:
	int				maxThreads;			// Configured max number of threads
	int				minThreads;			// Configured minimum
	int				numThreads;			// Configured minimum
	int				maxUse;				// Max used 
	int				pruneHighWater;		// Peak thread use in last minute
	int				idleThreads;		// Current idle
	int				busyThreads;		// Current busy
};
#endif

//
//	A task queue consists of a list of tasks and optional list of threads
//
typedef void		(*MprTaskProc)(void *data, MprTask *tp);

//
//	Class for the overall thread pool service
//
class MprPoolService {
  protected:							// Allow MprPoolThreads to access
	MprStr			name;				// Name of pool
	int				nextTaskNum;		// Unique next task number
	MprList			runningTasks;		// List of executing tasks
	int				stackSize;			// Stack size for worker threads 
	MprList			tasks;				// Prioritized list of pending tasks

#if BLD_FEATURE_MULTITHREAD
	MprList			busyThreads;		// List of threads to service tasks
	MprList			idleThreads;		// List of threads to service tasks
	int				maxThreads;			// Max # threads in pool 
	int				maxUseThreads;		// Max threads ever used
	int				minThreads;			// Max # threads in pool 
	MprMutex		*mutex;				// Per task synchronization
	int				nextThreadNum;		// Unique next thread number
	int				numThreads;			// Current number of threads in pool
	int				pruneHighWater;		// Peak thread use in last minute
	MprTimer		*pruneTimer;		// Timer for excess threads pruner
	MprMutex		*incMutex;			// Per task synchronization
#endif

  public:
	MprLogModule	*log;

  public:
					MprPoolService(char *name);
					~MprPoolService();
	int				assignNextTask(MprPoolThread *pt);
	void			dequeueTask(MprTask *tp);
#if BLD_DEBUG
	void			getStats(MprPoolStats *ps);
#endif
	void			insertTask(MprTask *np, MprTask *tp);
	void			prune();
	void			queueTask(MprTask *tp);
	void			queueRunningTask(MprTask *tp);
	void			removeTask(MprTask *tp);
	int				runTasks();
	void			setStackSize(int n);
	int				start();
	int				stop(int timeout);

#if BLD_FEATURE_MULTITHREAD
	void			dispatchTasks();
	int				getMinPoolThreads() { return minThreads; };
	int				getNumPoolThreads() { 
						return idleThreads.getNumItems() +
								busyThreads.getNumItems();
					};
	int				getMaxPoolThreads() { return maxThreads; };
	int				getNumIdleThreads() { return idleThreads.getNumItems(); };
	void			lock();
	int				getNextThreadNum();
	void			removeThread(MprPoolThread *pt);
	void			setMinPoolThreads(int n);
	void			setMaxPoolThreads(int n);
	void			unlock();
#else
	inline void		lock() {};
	inline void		unlock() {};
	int				getMaxPoolThreads() { return 0; };
#endif

	friend class	MprPoolThread;
	friend class	MprTask;
};

///////////////////////////////// MprPoolThread ////////////////////////////////
#if BLD_FEATURE_MULTITHREAD
//
//	Flags
//
#define MPR_POOL_THREAD_SLEEPING	0x1

//
//	Class for each thread in the thread pool
//
class MprPoolThread : public MprLink {
  private:
	MprPoolService	*pool;				// Which thread pool do we swim in
	MprTask			*currentTask;		// Current task being run
	int				flags;				

#if BLD_FEATURE_MULTITHREAD
	MprThread		*thread;			// Associated thread
	MprCond			*idleCond;			// Used to wait for work
#endif

  public:
					MprPoolThread(MprPoolService *pool, int stackSize);
					~MprPoolThread();
	MprPoolService	*getMprPoolService() { return pool; };
	MprThread		*getThread() { return thread; };
	MprTask			*getCurrentTask() { return currentTask; };
	void			makeIdle();
	void			start();
	void			setTask(MprTask *tp);
	void			threadMain();
	void			wakeup();
};

#endif
/////////////////////////////////// MprTask ////////////////////////////////////
//
//	Flags
//
#define MPR_TASK_DISPOSED	0x1
#define MPR_TASK_RUNNING	0x2

//
//	Class for each task (unit of work) 
//
class MprTask : public MprLink {
  public:
	void			*data;				// Task data 
	int				flags;				// Control flags
	int				inUse;				// In use counter. Used by dispose()
	MprPoolService	*pool;				// Managing pool
	int				priority;			// Priority of event 
	MprTaskProc		proc;				// Procedure to service this event. 

#if BLD_FEATURE_MULTITHREAD
	MprPoolThread	*pt;				// Pool thread servicing this task
	MprCond			*stoppingCond;		// Synchronization for timer->dispose()
#endif

  public:
					MprTask(MprTaskProc proc, void *data, 
						int priority = MPR_NORMAL_PRIORITY);
					MprTask(MprPoolService *pool, MprTaskProc proc, 
						void *data, int priority = MPR_NORMAL_PRIORITY);
	bool			dispose();
	void			start();
	int				stop(int timeout);

#if BLD_FEATURE_MULTITHREAD
	MprPoolThread	*getThread() { return pt; }; 
#endif

  private:
					~MprTask();
	friend class	MprPoolThread;
	friend class	MprPoolService;
};

/////////////////////////////// MprThreadService ///////////////////////////////
#if BLD_FEATURE_MULTITHREAD
// 
//	Threading primitives
//
typedef void		(*MprThreadProc)(void *arg, MprThread *tp);

class MprThreadService {
  private:
	MprList			threads;			// List of all threads
	MprThread		*mainThread;		// Main application Mpr thread id 
	MprMutex		*mutex;				// Multi-thread sync

  public:
					MprThreadService();
					~MprThreadService();
	MprThread		*getCurrentThread();
	void			insertThread(MprThread *tp);
	void			removeThread(MprThread *tp);
	int				start();
	int				stop(int timeout);

	inline void	lock() { 
						if (mutex) {
							mutex->lock(); 
						}
					};
	inline void		unlock() { 
						if (mutex) {
							mutex->unlock(); 
						}
					};
};

/////////////////////////////////// MprThread //////////////////////////////////

class MprThread : public MprLink {
  private:
	#if WIN
		int			osThreadId;			// O/S thread id
		handle		threadHandle;		// Threads OS handle 
	#endif
	#if LINUX || MACOSX || SOLARIS
		pthread_t	osThreadId;			// O/S thread id 
	#endif
	#if VXWORKS
		int			osThreadId;			// O/S thread id (same as pid)
	#endif
	void			*data;				// Data argument
	MprThreadProc	entry;				// Users thread entry point
	MprStr			name;				// Name of thead for trace
	MprMutex		*mutex;				// Multi-thread synchronization
	int				pid;				// Owning process id
	int				priority;			// Current priority 
	int				stackSize;			// Only VxWorks implements

  public:
					MprThread(int pri, char *name);
					//	FUTURE -- move pri to last and default it.
					MprThread(MprThreadProc proc, int pri, void *data, 
						char *name, int stackSize = 0);
					~MprThread();
	int				getId() { return (int) osThreadId; };
	char			*getName() { return name; };
	int				getPriority() { return priority; };
	void			lock() { mutex->lock(); };
	void			setId(int id);
	void			setPriority(int priority);
	void			setStackSize(int size);
	int				start();
	void			threadProc();
	void			unlock() { mutex->unlock(); };
 
  private:
	int				mapMprPriorityToOs(int mprPriority);
	int				mapOsPriorityToMpr(int nativePriority);
};

extern MprThread	*mprGetCurrentThread();
extern int			mprGetMaxPoolThreads();

#endif // BLD_FEATURE_MULTITHREAD
/////////////////////////////// MprTimerService ////////////////////////////////

#define MPR_TIMER_TOLERANCE		2		// Used in timer calculations

//
//	Timer service. One per MPR 
//
class MprTimerService {
  private:
	int				lastIdleTime;		// Last return value from getIdleTime()
	int				lastRanTimers;		// Last call to runTimers()
	MprLogModule	*log;				// Log module to identify trace
	MprList			timerList;			// List of all timers

#if BLD_FEATURE_MULTITHREAD
	MprMutex		*mutex;				// Multi-thread sync
#endif

  public:
					MprTimerService();
					~MprTimerService();
	void			callTimer(MprTimer *tp);
	int				getIdleTime();
	int				runTimers();
	int				stop();
	int				start();

#if BLD_FEATURE_MULTITHREAD
	MprMutex		*getMutex() { return mutex; };
	inline void		lock() { mutex->lock(); };
	inline void		unlock() { mutex->unlock(); };
#else
	inline void		lock() {};
	inline void		unlock() {};
#endif

  protected:
	void			updateSelect(MprTimer *tp);

	friend class	MprTimer;
};

//////////////////////////////////// MprTimer //////////////////////////////////
//
//	MprTimer callback function prototype
//
typedef void		(*MprTimerProc)(void *data, MprTimer *tp);

//
//	MprTimer flags
//
#define MPR_TIMER_DISPOSED		0x1
#define MPR_TIMER_RUNNING		0x2
#define MPR_TIMER_TASK			0x4
#define MPR_TIMER_AUTO_RESCHED	0x8

class MprTimer : public MprLink {
  private:
	void			*data;				// Argument to pass to callback
	int				flags;
	int				inUse;				// In use counter. Used by dispose()
	int				period;				// Reschedule period 
	MprTimerProc	proc;				// Callback procedure
	MprTime			time;				// When timer is due to next run
	MprTimerService	*timerService;

#if BLD_FEATURE_MULTITHREAD
	MprCond			*stoppingCond;		// Synchronization when stopping
#endif

  public:
					MprTimer(int msec, MprTimerProc routine, void *arg, 
						int userFlags = 0);
	bool			dispose();
	int				getPeriod() { return period; };
	MprTimerService	*getMprTimerService() { return timerService; };
	void			reschedule();
	void			reschedule(int msec);
	int				stop(int timeout);

private:
					~MprTimer();
	friend class	MprTimerService;
};

//////////////////////////////// MprWinService /////////////////////////////////
#if BLD_FEATURE_RUN_AS_SERVICE && WIN

class MprWinService {
  private:
	MprStr			svcName;
  public:
					MprWinService(char *name);
					~MprWinService();
	int				install(char *displayName, char *cmd);
	int				registerService(HANDLE threadHandle, HANDLE waitEvent);
	int				remove(int code);
	int				startDispatcher(LPSERVICE_MAIN_FUNCTION svcMain);
	int				start();
	int				stop(int code);
	void			updateStatus(int status, int exitCode);
};

#endif
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////// Other C++ Stuff ////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#if BLD_DEBUG && UNUSED
#if LINUX || MACOSX
#if MPR_CPU_IX86
	inline int64 mprGetHiResTime() {
		int64	now;
		__asm__ __volatile__ ("rdtsc" : "=A" (now));
		return now;
	}
#endif
#endif
#if WIN
	inline int64 mprGetHiResTime() {
		int64	now;
		QueryPerformanceCounter((LARGE_INTEGER*) &now);
		return now;
	}
#endif
	
////////////////////////////////////////////////////////////////////////////////

inline int64 mprGetElapsedTime() 
{
	static int64	lastMark = 0;
	int64			now, elapsed;
	
	now = mprGetHiResTime();
	if (now > lastMark) {
		elapsed = now - lastMark;
		lastMark = now;
	} else {
		elapsed = lastMark - now + 1;
		lastMark = now;
	}
	return elapsed;
};

#endif // BLD_DEBUG && UNUSED
#endif // __cplusplus

////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////// C Prototypes //////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
extern "C" {
#endif

/*
 *	Generic array type
 */
typedef struct MprArray {
	int		max;					/**< Size of the handles array. */
	int		used;					/**< Count of used entries in handles. */
	void	**handles;
} MprArray;

#if BLD_FEATURE_SQUEEZE
#define MPR_ARRAY_INCR		8
#else
#define MPR_ARRAY_INCR		16
#endif

//
//	Array
//
extern MprArray	*mprCreateArray();
extern void 	mprDestroyArray(MprArray *array);
extern int 		mprAddToArray(MprArray *array, void *item);
extern int 		mprRemoveFromArray(MprArray *array, int index);

//
//	Printf replacements
//
#define	MPR_STDOUT	1
#define	MPR_STDERR	2

extern int		mprPrintf(char *fmt, ...);
extern int		mprStaticPrintf(char *fmt, ...);
extern int		mprFprintf(int fd, char *fmt, ...);
extern int		mprAllocSprintf(char **s, int n, char *fmt, ...);
extern int		mprAllocVsprintf(char **s, int n, char *fmt, va_list arg);
extern int		mprSprintf(char *s, int n, char *fmt, ...);
extern int		mprVsprintf(char *s, int n, char *fmt, va_list arg);
extern char		*mprItoa(int value, char *userBuf, int width);
extern int 		mprAtoi(char *str, int radix);

//
//	Safe string routines
//
extern int		mprStrcpy(char *dest, int destMax, const char *src);
extern int		mprMemcpy(char *dest, int destMax, const char *src, 
						int nbytes);
extern int		mprAllocStrcpy(char **dest, int max, const char *src);
extern int		mprReallocStrcpy(char **dest, int max, const char *src);
extern int		mprAllocMemcpy(char **dest, int destMax, const char *src, 
						int nbytes);
extern int		mprStrcat(char *dest, int max, const char *delim, 
						const char *src, ...);
extern int		mprAllocStrcat(char **dest, int max, const char *delim, 
						const char *src, ...);
extern int		mprReallocStrcat(char **dest, int max, int existingLen,
						const char *delim, const char *src, ...);
extern int		mprStrlen(char *src, int max);

//	FUTURE (rename to Strcmpi, Strncmpi)
extern int		mprStrCmpAnyCase(char *s1, char *s2);
extern int		mprStrCmpAnyCaseCount(char *s1, char *s2, int len);
extern char		*mprStrLower(char *string);
extern char		*mprStrUpper(char *string);
extern char		*mprStrTrim(char *string, char c);

//
//	Reentrant string and time routines
//
extern char		*mprStrTok(char *str, const char *sep, char **last);
extern char		*mprGetWordTok(char *word, int wordLen, char *str, 
						const char *delim, char **tok);
extern int		mprCtime(const time_t* timer, char *buf, int bufsize);
extern int		mprGetTime(MprTime *tp);
extern int		mprAsctime(const struct tm *timeptr, char *buf, int bufsiz);
extern struct tm *mprGmtime(time_t* now, struct tm *tmp);
extern struct tm *mprLocaltime(time_t* now, struct tm *tmp);
extern int		mprRfcTime(char *buf, int size, const struct tm *timeptr);

//
//	General other xPlatform routines
//
extern char		*mprGetBaseName(char *name);
extern int		mprGetDirName(char *buf, int bufsize, char *path);
extern void		mprMakeArgv(char *prog, char *cmd, char ***argv, int *argc);
extern int		mprMakeDir(char *path);
extern char 	*mprInetNtoa(char *buf, int size, const struct in_addr in);
extern void		mprSleep(int msec);
extern struct hostent* mprGetHostByName(char *name);
extern void		mprFreeGetHostByName(struct hostent* hostp);
extern int		mprGetRandomBytes(uchar *buf, int size, int block);

#if BLD_FEATURE_MULTITHREAD
extern char		*mprGetCurrentThreadName();
extern void		mprLock();
extern void		mprUnlock();
#else
#if __cplusplus
inline void		mprLock() {};
inline void		mprUnlock() {};
#else
#define mprLock()
#define mprUnlock()
#endif
#endif

extern bool		mprGetDebugMode();
extern void		mprSetDebugMode(bool on);

extern int		mprGetOsError();
extern char		*mprGetErrorMsg(int errCode);
extern char		*mprMakeTempFileName(char *buf, int bufsize, char *tempDir);
extern void		mprNextFds(char *msg);
extern char		*mprGetFullPathName(char *buf, int buflen, char *path);

extern void		mprError(char *file, int line, int flags, char *fmt, ...);


#if BLD_FEATURE_LOG || !__cplusplus
extern void		mprLog(int level, char *fmt, ...);
#endif

typedef void	(*MprMemProc)(int askSize, int totalPoolMem, int limit);

extern void		*mprCalloc(uint numElem, uint size);
extern int		mprCreateMemHeap(char *userBuf, int initialSize, int limit);
extern void		mprFree(void *ptr);
extern void		*mprMalloc(uint size);
extern void		mprMemClose();
#if BLD_FEATURE_MALLOC_HOOK
extern void		mprHookMalloc();
#endif
extern void		mprMemStop();
extern void		mprPrintMemStats();
extern void		*mprRealloc(void *ptr, uint size);
extern void		mprRequestMemStats(bool on);
extern void		mprSetMemHandler(MprMemProc cback);
extern char		*mprStrdup(const char *str);

#if WIN
extern int		mprReadRegistry(char *key, char *val, char **buf, int max);
#endif


#if __cplusplus
} // extern "C"
#endif

#endif // _h_MPR 

//
// Local variables:
// tab-width: 4
// c-basic-offset: 4
// End:
// vim:tw=78
// vim600: sw=4 ts=4 fdm=marker
// vim<600: sw=4 ts=4
//