From: Andrew Tridgell Date: Sat, 28 May 2005 07:41:20 +0000 (+0000) Subject: r7051: remove an unused file X-Git-Tag: samba-4.0.0alpha6~801^3~10862 X-Git-Url: http://git.samba.org/samba.git/?p=sfrench%2Fsamba-autobuild%2F.git;a=commitdiff_plain;h=5aacc765e15a212af7bb97e35cd2340f7eafd2b1 r7051: remove an unused file (This used to be commit 7e6fbd4889a92ec985b8c6c70005cab76d64d262) --- diff --git a/source4/web_server/ejs/mpr.h b/source4/web_server/ejs/mpr.h deleted file mode 100644 index 848518befab..00000000000 --- a/source4/web_server/ejs/mpr.h +++ /dev/null @@ -1,2259 +0,0 @@ -/// -/// @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 -//