diff options
Diffstat (limited to 'source4/web_server/ejs/mpr.h')
| -rw-r--r-- | source4/web_server/ejs/mpr.h | 2259 |
1 files changed, 2259 insertions, 0 deletions
diff --git a/source4/web_server/ejs/mpr.h b/source4/web_server/ejs/mpr.h new file mode 100644 index 0000000000..848518befa --- /dev/null +++ b/source4/web_server/ejs/mpr.h @@ -0,0 +1,2259 @@ +/// +/// @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 +// |