PUBLIC MprCmd *mprCreateCmd(MprDispatcher *dispatcher)
{
MprCmd *cmd;
MprCmdFile *files;
int i;
if ((cmd = mprAllocObj(MprCmd, manageCmd)) == 0) {
return 0;
}
cmd->forkCallback = (MprForkCallback) closeFiles;
cmd->dispatcher = dispatcher ? dispatcher : MPR->dispatcher;
cmd->status = -1;
cmd->searchPath = MPR->pathEnv;
#if VXWORKS
cmd->startCond = semCCreate(SEM_Q_PRIORITY, SEM_EMPTY);
cmd->exitCond = semCCreate(SEM_Q_PRIORITY, SEM_EMPTY);
#endif
files = cmd->files;
for (i = 0; i < MPR_CMD_MAX_PIPE; i++) {
files[i].clientFd = -1;
files[i].fd = -1;
}
cmd->mutex = mprCreateLock();
return cmd;
}
static EjsService *createService()
{
EjsService *sp;
if (MPR->ejsService) {
return MPR->ejsService;
}
if ((sp = mprAllocObj(EjsService, manageEjsService)) == NULL) {
return 0;
}
mprGlobalLock();
MPR->ejsService = sp;
#if FUTURE && KEEP
mprSetMemNotifier((MprMemNotifier) allocNotifier);
#endif
sp->nativeModules = mprCreateHash(-1, MPR_HASH_STATIC_KEYS);
sp->mutex = mprCreateLock();
sp->vmlist = mprCreateList(-1, MPR_LIST_STATIC_VALUES);
sp->vmpool = mprCreateList(-1, MPR_LIST_STATIC_VALUES);
sp->intern = ejsCreateIntern(sp);
sp->dtoaSpin[0] = mprCreateSpinLock();
sp->dtoaSpin[1] = mprCreateSpinLock();
ejsInitCompiler(sp);
mprGlobalUnlock();
return sp;
}
/*
* Create a new connection object.
*/
static MaConn *createConn(MprCtx ctx, MaHost *host, MprSocket *sock, cchar *ipAddr, int port, MaHostAddress *address)
{
MaConn *conn;
conn = mprAllocObjWithDestructorZeroed(ctx, MaConn, connectionDestructor);
if (conn == 0) {
return 0;
}
if (host->keepAlive) {
conn->keepAliveCount = host->maxKeepAlive;
}
conn->http = host->server->http;
conn->sock = sock;
mprStealBlock(conn, sock);
conn->state = MPR_HTTP_STATE_BEGIN;
conn->timeout = host->timeout;
conn->remotePort = port;
conn->remoteIpAddr = mprStrdup(conn, ipAddr);
conn->address = address;
conn->host = host;
conn->originalHost = host;
conn->expire = mprGetTime(conn) + host->timeout;
conn->eventMask = -1;
maInitSchedulerQueue(&conn->serviceq);
#if BLD_FEATURE_MULTITHREAD
conn->mutex = mprCreateLock(conn);
#endif
return conn;
}
/*
Parent may be null
*/
PUBLIC HttpTrace *httpCreateTrace(HttpTrace *parent)
{
HttpTrace *trace;
if ((trace = mprAllocObj(HttpTrace, manageTrace)) == 0) {
return 0;
}
if (parent) {
*trace = *parent;
trace->parent = parent;
} else {
if ((trace->events = mprCreateHash(0, MPR_HASH_STATIC_VALUES)) == 0) {
return 0;
}
mprAddKey(trace->events, "request", ITOP(1));
mprAddKey(trace->events, "result", ITOP(2));
mprAddKey(trace->events, "error", ITOP(2));
mprAddKey(trace->events, "context", ITOP(3));
mprAddKey(trace->events, "form", ITOP(4));
mprAddKey(trace->events, "body", ITOP(5));
mprAddKey(trace->events, "debug", ITOP(5));
trace->size = HTTP_TRACE_MAX_SIZE;
trace->formatter = httpDetailTraceFormatter;
trace->logger = httpWriteTraceLogFile;
trace->mutex = mprCreateLock();
}
return trace;
}
MprCmd *mprCreateCmd(MprCtx ctx)
{
MprCmdService *cs;
MprCmd *cmd;
MprCmdFile *files;
int i;
cmd = mprAllocObjWithDestructorZeroed(ctx, MprCmd, cmdDestructor);
if (cmd == 0) {
return 0;
}
cmd->completeCond = mprCreateCond(cmd);
cmd->timeoutPeriod = MPR_TIMEOUT_CMD;
cmd->timestamp = mprGetTime(cmd);
cmd->forkCallback = (MprForkCallback) closeFiles;
#if VXWORKS
cmd->startCond = semCCreate(SEM_Q_PRIORITY, SEM_EMPTY);
cmd->exitCond = semCCreate(SEM_Q_PRIORITY, SEM_EMPTY);
#endif
files = cmd->files;
for (i = 0; i < MPR_CMD_MAX_PIPE; i++) {
files[i].clientFd = -1;
files[i].fd = -1;
}
#if BLD_FEATURE_MULTITHREAD
cmd->mutex = mprCreateLock(cmd);
#endif
cs = mprGetMpr(ctx)->cmdService;
mprLock(cs->mutex);
mprAddItem(cs->cmds, cmd);
mprUnlock(cs->mutex);
return cmd;
}
static void initSettings()
{
app->method = 0;
app->verbose = 0;
app->continueOnErrors = 0;
app->showHeaders = 0;
app->verifyIssuer = -1;
app->verifyPeer = 0;
app->zeroOnErrors = 0;
app->authType = sclone("basic");
app->host = sclone("localhost");
app->iterations = 1;
app->loadThreads = 1;
app->protocol = "HTTP/1.1";
app->retries = HTTP_RETRIES;
app->success = 1;
/* zero means no timeout */
app->timeout = 0;
app->workers = 1;
app->headers = mprCreateList(0, 0);
app->mutex = mprCreateLock();
#if WINDOWS
_setmode(fileno(stdout), O_BINARY);
#endif
}
/*
* Create a new virtual host and inherit settings from another host
*/
MaHost *maCreateVirtualHost(MaServer *server, cchar *ipAddrPort, MaHost *parent)
{
MaHost *host;
host = mprAllocObjZeroed(server, MaHost);
if (host == 0) {
return 0;
}
host->parent = parent;
host->connections = mprCreateList(host);
if (ipAddrPort) {
host->ipAddrPort = mprStrdup(server, ipAddrPort);
host->name = mprStrdup(server, ipAddrPort);
} else {
host->ipAddrPort = 0;
host->name = 0;
}
/*
* The aliases, dirs and locations are all copy-on-write
*/
host->aliases = parent->aliases;
host->dirs = parent->dirs;
host->locations = parent->locations;
host->server = parent->server;
host->flags = parent->flags;
host->httpVersion = parent->httpVersion;
host->timeout = parent->timeout;
host->limits = parent->limits;
host->keepAliveTimeout = parent->keepAliveTimeout;
host->maxKeepAlive = parent->maxKeepAlive;
host->keepAlive = parent->keepAlive;
host->accessLog = parent->accessLog;
host->mimeTypes = parent->mimeTypes;
host->location = maCreateLocation(host, parent->location);
host->logHost = parent->logHost;
host->traceMask = parent->traceMask;
host->traceLevel = parent->traceLevel;
host->traceMaxLength = parent->traceMaxLength;
if (parent->traceInclude) {
host->traceInclude = mprCopyHash(host, parent->traceInclude);
}
if (parent->traceExclude) {
host->traceExclude = mprCopyHash(host, parent->traceExclude);
}
maAddLocation(host, host->location);
updateCurrentDate(host);
#if BLD_FEATURE_MULTITHREAD
host->mutex = mprCreateLock(host);
#endif
return host;
}
static DynLock *sslCreateDynLock(cchar *file, int line)
{
DynLock *dl;
dl = mprAllocZeroed(sizeof(DynLock));
dl->mutex = mprCreateLock(dl);
mprHold(dl->mutex);
return dl;
}
/*
Initialize the MPR SSL layer
*/
PUBLIC int mprSslInit(void *unused, MprModule *module)
{
RandBuf randBuf;
int i;
randBuf.now = mprGetTime();
randBuf.pid = getpid();
RAND_seed((void*) &randBuf, sizeof(randBuf));
#if ME_UNIX_LIKE
RAND_load_file("/dev/urandom", 256);
#endif
if ((openProvider = mprAllocObj(MprSocketProvider, manageOpenProvider)) == NULL) {
return MPR_ERR_MEMORY;
}
openProvider->name = sclone("openssl");
openProvider->upgradeSocket = upgradeOss;
openProvider->closeSocket = closeOss;
openProvider->disconnectSocket = disconnectOss;
openProvider->flushSocket = flushOss;
openProvider->socketState = getOssState;
openProvider->readSocket = readOss;
openProvider->writeSocket = writeOss;
mprSetSslProvider(openProvider);
/*
Configure the SSL library. Use the crypto ID as a one-time test. This allows
users to configure the library and have their configuration used instead.
*/
mprGlobalLock();
if (CRYPTO_get_id_callback() == 0) {
numLocks = CRYPTO_num_locks();
if ((olocks = mprAlloc(numLocks * sizeof(MprMutex*))) == 0) {
return MPR_ERR_MEMORY;
}
for (i = 0; i < numLocks; i++) {
olocks[i] = mprCreateLock();
}
CRYPTO_set_id_callback(sslThreadId);
CRYPTO_set_locking_callback(sslStaticLock);
CRYPTO_set_dynlock_create_callback(sslCreateDynLock);
CRYPTO_set_dynlock_destroy_callback(sslDestroyDynLock);
CRYPTO_set_dynlock_lock_callback(sslDynLock);
#if !ME_WIN_LIKE
OpenSSL_add_all_algorithms();
#endif
/*
WARNING: SSL_library_init() is not reentrant. Caller must ensure safety.
*/
SSL_library_init();
SSL_load_error_strings();
}
mprGlobalUnlock();
return 0;
}
MAIN(benchMpr, int argc, char **argv, char **envp)
{
MprThread *thread;
Mpr *mpr;
char *argp;
int err, nextArg;
if ((mpr = mprCreate(argc, argv, MPR_USER_EVENTS_THREAD)) == 0) {
return MPR_ERR_MEMORY;
}
if ((app = mprAllocObj(App, manageApp)) == 0) {
return MPR_ERR_MEMORY;
}
mprAddRoot(app);
app->mutex = mprCreateLock(mpr);
app->complete = mprCreateCond();
app->iterations = 5;
err = 0;
for (nextArg = 1; nextArg < argc; nextArg++) {
argp = argv[nextArg];
if (*argp != '-') {
break;
}
if (strcmp(argp, "--iterations") == 0 || strcmp(argp, "-i") == 0) {
if (nextArg >= argc) {
err++;
} else {
app->iterations = atoi(argv[++nextArg]);
}
} else if (strcmp(argp, "--alloc") == 0 || strcmp(argp, "-a") == 0) {
app->testAllocOnly++;
} else {
err++;
}
}
if (err) {
mprEprintf("usage: bench [-a] [-i iterations]\n");
mprEprintf("usage: %s [options]\n"
" -a # Alloc test only\n"
" --iterations count # Number of iterations to run the test\n",
mprGetAppName(mpr));
exit(2);
}
mprStart(mpr);
thread = mprCreateThread("bench", (MprThreadProc) doBenchmark, (void*) MPR, 0);
mprStartThread(thread);
while (!testComplete) {
mprServiceEvents(250, 0);
}
mprPrintMem("Memory Report", 0);
mprDestroy();
return 0;
}
static int initLock(MprTestGroup *gp)
{
mprGlobalLock(gp);
if (mutex == 0) {
mutex = mprCreateLock(gp);
}
mprGlobalUnlock(gp);
return 0;
}
/*
* Dynamic module initialization
*/
MprModule *maEjsHandlerInit(MaHttp *http, cchar *path)
{
MprModule *module;
MaStage *handler;
EjsWebControl *control;
module = mprCreateModule(http, "ejsHandler", BLD_VERSION, 0, 0, 0);
if (module == 0) {
return 0;
}
handler = maCreateHandler(http, "ejsHandler",
MA_STAGE_GET | MA_STAGE_HEAD | MA_STAGE_POST | MA_STAGE_PUT | MA_STAGE_FORM_VARS | MA_STAGE_VIRTUAL);
if (handler == 0) {
mprFree(module);
return 0;
}
http->ejsHandler = handler;
handler->match = matchEjs;
handler->run = runEjs;
handler->parse = parseEjs;
/*
* Setup the control block
*/
handler->stageData = control = mprAllocObjZeroed(handler, EjsWebControl);
control->defineParams = defineParams;
control->discardOutput = discardOutput;
control->error = error;
control->getHeader = getHeader;
control->getVar = getVar;
control->redirect = redirect;
control->setCookie = setCookie;
control->setHeader = setHeader;
control->setHttpCode = setHttpCode;
control->setMimeType = setMimeType;
control->write = writeBlock;
control->modulePath = mprStrdup(control, path);
#if BLD_FEATURE_MULTITHREAD && FUTURE
/*
* This mutex is used very sparingly and must be an application global lock.
*/
mutex = mprCreateLock(control);
control->lock = ejsWebLock;
control->unlock = ejsWebUnlock;
control->lockData = mutex;
#endif
if (ejsOpenWebFramework(control, 1) < 0) {
return 0;
}
return module;
}
PUBLIC MprCmdService *mprCreateCmdService()
{
MprCmdService *cs;
if ((cs = (MprCmdService*) mprAllocObj(MprCmd, manageCmdService)) == 0) {
return 0;
}
cs->cmds = mprCreateList(0, 0);
cs->mutex = mprCreateLock();
return cs;
}
static int initLock(MprTestGroup *gp)
{
mprGlobalLock(gp);
if (mutex == 0) {
mutex = mprCreateLock(gp);
gp->data = mutex;
mprAddRoot(mutex);
}
threadCount++;
mprGlobalUnlock(gp);
return 0;
}
MprSignalService *mprCreateSignalService()
{
MprSignalService *ssp;
if ((ssp = mprAllocObj(MprSignalService, manageSignalService)) == 0) {
return 0;
}
ssp->mutex = mprCreateLock();
ssp->signals = mprAllocZeroed(sizeof(MprSignal*) * MPR_MAX_SIGNALS);
ssp->standard = mprCreateList(-1, 0);
return ssp;
}
static Mdb *mdbCreate(cchar *path, int flags)
{
Mdb *mdb;
if ((mdb = mprAllocObj(Mdb, manageMdb)) == 0) {
return 0;
}
mdb->edi.provider = &MdbProvider;
mdb->edi.flags = flags;
mdb->path = sclone(path);
mdb->mutex = mprCreateLock();
return mdb;
}
/*
Open the module service
*/
PUBLIC MprModuleService *mprCreateModuleService()
{
MprModuleService *ms;
if ((ms = mprAllocObj(MprModuleService, manageModuleService)) == 0) {
return 0;
}
ms->modules = mprCreateList(-1, 0);
ms->mutex = mprCreateLock();
MPR->moduleService = ms;
mprSetModuleSearchPath(NULL);
return ms;
}
MaHttp *maCreateHttp(MprCtx ctx)
{
MaHttp *http;
http = mprAllocObjWithDestructorZeroed(ctx, MaHttp, httpDestructor);
if (http == 0) {
return 0;
}
mprGetMpr(ctx)->appwebHttpService = http;
http->servers = mprCreateList(http);
http->stages = mprCreateHash(http, 0);
#if BLD_FEATURE_MULTITHREAD
http->mutex = mprCreateLock(http);
#endif
initLimits(http);
#if BLD_UNIX_LIKE
{
struct passwd *pp;
struct group *gp;
http->uid = getuid();
if ((pp = getpwuid(http->uid)) == 0) {
mprError(http, "Can't read user credentials: %d. Check your /etc/passwd file.", http->uid);
} else {
http->username = mprStrdup(http, pp->pw_name);
}
http->gid = getgid();
if ((gp = getgrgid(http->gid)) == 0) {
mprError(http, "Can't read group credentials: %d. Check your /etc/group file", http->gid);
} else {
http->groupname = mprStrdup(http, gp->gr_name);
}
}
#else
http->uid = http->gid = -1;
#endif
#if BLD_FEATURE_SEND
maOpenSendConnector(http);
#endif
#if BLD_FEATURE_NET
maOpenNetConnector(http);
#endif
maOpenPassHandler(http);
return http;
}
MprCmdService *mprCreateCmdService(Mpr *mpr)
{
MprCmdService *cs;
cs = (MprCmdService*) mprAllocObjWithDestructorZeroed(mpr, MprCmd, cmdDestructor);
if (cs == 0) {
return 0;
}
cs->cmds = mprCreateList(cs);
#if BLD_FEATURE_MULTITHREAD
cs->mutex = mprCreateLock(cs);
#endif
return cs;
}
/*
* Create a host from scratch
*/
MaHost *maCreateHost(MaServer *server, cchar *ipAddrPort, MaLocation *location)
{
MaHost *host;
host = mprAllocObjZeroed(server, MaHost);
if (host == 0) {
return 0;
}
host->aliases = mprCreateList(host);
host->dirs = mprCreateList(host);
host->connections = mprCreateList(host);
host->locations = mprCreateList(host);
if (ipAddrPort) {
host->ipAddrPort = mprStrdup(server, ipAddrPort);
host->name = mprStrdup(server, ipAddrPort);
} else {
host->ipAddrPort = 0;
host->name = 0;
}
host->server = server;
host->flags = MA_HOST_NO_TRACE;
host->httpVersion = MPR_HTTP_1_1;
host->timeout = MA_SERVER_TIMEOUT;
host->limits = &server->http->limits;
host->traceMask = MA_TRACE_REQUEST | MA_TRACE_RESPONSE | MA_TRACE_HEADERS;
host->traceLevel = 3;
host->traceMaxLength = INT_MAX;
host->keepAliveTimeout = MA_KEEP_TIMEOUT;
host->maxKeepAlive = MA_MAX_KEEP_ALIVE;
host->keepAlive = 1;
host->location = (location) ? location : maCreateBareLocation(host);
maAddLocation(host, host->location);
updateCurrentDate(host);
#if BLD_FEATURE_AUTH
host->location->auth = maCreateAuth(host->location, host->location->auth);
#endif
#if BLD_FEATURE_MULTITHREAD
host->mutex = mprCreateLock(host);
#endif
mprSetIdleCallback(host, appwebIsIdle);
return host;
}
/*
Initialize the service
*/
PUBLIC MprWaitService *mprCreateWaitService()
{
MprWaitService *ws;
ws = mprAllocObj(MprWaitService, manageWaitService);
if (ws == 0) {
return 0;
}
MPR->waitService = ws;
ws->handlers = mprCreateList(-1, 0);
ws->mutex = mprCreateLock();
ws->spin = mprCreateSpinLock();
mprCreateNotifierService(ws);
return ws;
}
Ejs *ejsCreateVM(int argc, cchar **argv, int flags)
{
EjsService *sp;
Ejs *ejs;
if ((ejs = mprAllocObj(Ejs, manageEjs)) == NULL) {
return 0;
}
sp = ejs->service = MPR->ejsService;
if (sp == 0) {
sp = ejs->service = createService();
defineSharedTypes(ejs);
}
ejs->empty = 1;
ejs->state = mprAllocZeroed(sizeof(EjsState));
ejs->argc = argc;
ejs->argv = argv;
ejs->name = sfmt("ejs-%d", sp->seqno++);
ejs->dispatcher = mprCreateDispatcher(ejs->name, MPR_DISPATCHER_ENABLED);
ejs->mutex = mprCreateLock(ejs);
ejs->dontExit = sp->dontExit;
ejs->flags |= (flags & (EJS_FLAG_NO_INIT | EJS_FLAG_DOC | EJS_FLAG_HOSTED));
ejs->hosted = (flags & EJS_FLAG_HOSTED) ? 1 : 0;
ejs->global = ejsCreateBlock(ejs, 0);
mprSetName(ejs->global, "global");
ejsDefineGlobalNamespaces(ejs);
/*
Modules are not marked in the modules list. This way, modules are collected when not referenced.
Workers are marked. This way workers are preserved to run in the background until they exit.
*/
ejs->modules = mprCreateList(-1, MPR_LIST_STATIC_VALUES);
ejs->workers = mprCreateList(0, 0);
initStack(ejs);
initSearchPath(ejs, 0);
mprAddItem(sp->vmlist, ejs);
if (ejs->hasError || mprHasMemError(ejs)) {
ejsDestroyVM(ejs);
mprError("Cannot create VM");
return 0;
}
mprLog(5, "ejs: create VM");
return ejs;
}
/*
* Create a host from scratch
*/
MaHost *maCreateHost(MaServer *server, cchar *ipAddrPort, MaLocation *location)
{
MaHost *host;
host = mprAllocObjZeroed(server, MaHost);
if (host == 0) {
return 0;
}
host->currentDate = maGetDateString(host, 0);
host->aliases = mprCreateList(host);
host->dirs = mprCreateList(host);
host->connections = mprCreateList(host);
host->locations = mprCreateList(host);
if (ipAddrPort) {
host->ipAddrPort = mprStrdup(server, ipAddrPort);
host->name = mprStrdup(server, ipAddrPort);
} else {
host->ipAddrPort = 0;
host->name = 0;
}
host->server = server;
host->flags = MA_HOST_NO_TRACE;
host->httpVersion = MPR_HTTP_1_1;
host->timeout = MA_SERVER_TIMEOUT;
host->limits = &server->http->limits;
host->keepAliveTimeout = MA_KEEP_TIMEOUT;
host->maxKeepAlive = MA_MAX_KEEP_ALIVE;
host->keepAlive = 1;
host->location = (location) ? location : maCreateBareLocation(host);
maAddLocation(host, host->location);
#if BLD_FEATURE_AUTH
host->location->auth = maCreateAuth(host->location, host->location->auth);
#endif
#if BLD_FEATURE_MULTITHREAD
host->mutex = mprCreateLock(host);
#endif
return host;
}
/*
* Create a new virtual host and inherit settings from another host
*/
MaHost *maCreateVirtualHost(MaServer *server, cchar *ipAddrPort, MaHost *parent)
{
MaHost *host;
host = mprAllocObjZeroed(server, MaHost);
if (host == 0) {
return 0;
}
host->parent = parent;
host->currentDate = maGetDateString(host, 0);
host->connections = mprCreateList(host);
if (ipAddrPort) {
host->ipAddrPort = mprStrdup(server, ipAddrPort);
host->name = mprStrdup(server, ipAddrPort);
} else {
host->ipAddrPort = 0;
host->name = 0;
}
/*
* The aliases, dirs and locations are all copy-on-write
*/
host->aliases = parent->aliases;
host->dirs = parent->dirs;
host->locations = parent->locations;
host->server = parent->server;
host->flags = parent->flags;
host->httpVersion = parent->httpVersion;
host->timeout = parent->timeout;
host->limits = parent->limits;
host->keepAliveTimeout = parent->keepAliveTimeout;
host->maxKeepAlive = parent->maxKeepAlive;
host->keepAlive = parent->keepAlive;
host->accessLog = parent->accessLog;
host->location = maCreateLocation(host, parent->location);
maAddLocation(host, host->location);
#if BLD_FEATURE_MULTITHREAD
host->mutex = mprCreateLock(host);
#endif
return host;
}
/*
Create the overall dispatch service. There may be many event dispatchers.
*/
PUBLIC MprEventService *mprCreateEventService()
{
MprEventService *es;
if ((es = mprAllocObj(MprEventService, manageEventService)) == 0) {
return 0;
}
MPR->eventService = es;
es->now = mprGetTicks();
es->mutex = mprCreateLock();
es->waitCond = mprCreateCond();
es->runQ = createQhead("running");
es->readyQ = createQhead("ready");
es->idleQ = createQhead("idle");
es->pendingQ = createQhead("pending");
es->waitQ = createQhead("waiting");
return es;
}
PUBLIC MprCond *mprCreateCond()
{
MprCond *cp;
if ((cp = mprAllocObjNoZero(MprCond, manageCond)) == 0) {
return 0;
}
cp->triggered = 0;
cp->mutex = mprCreateLock();
#if ME_WIN_LIKE
cp->cv = CreateEvent(NULL, FALSE, FALSE, NULL);
#elif VXWORKS
cp->cv = semCCreate(SEM_Q_PRIORITY, SEM_EMPTY);
#else
pthread_cond_init(&cp->cv, NULL);
#endif
return cp;
}
static void initSettings(Mpr *mpr)
{
method = 0;
verbose = continueOnErrors = showHeaders = 0;
/*
* Default to HTTP/1.1
*/
httpVersion = 1;
success = 1;
host = "localhost";
retries = MPR_HTTP_RETRIES;
iterations = 1;
loadThreads = 1;
workers = 1;
timeout = (60 * 1000);
headers = mprCreateList(mpr);
#if BLD_FEATURE_MULTITHREAD
mutex = mprCreateLock(mpr);
#endif
}
/*
Load and initialize ESP module. Manually loaded when used inside esp.c.
*/
PUBLIC int espOpen(MprModule *module)
{
HttpStage *handler;
if ((handler = httpCreateHandler("espHandler", module)) == 0) {
return MPR_ERR_CANT_CREATE;
}
HTTP->espHandler = handler;
handler->open = openEsp;
handler->close = closeEsp;
handler->start = startEsp;
/*
Using the standard 'incoming' callback that simply transfers input to the queue head
Applications should read by defining a notifier for READABLE events and then calling httpGetPacket
on the read queue.
*/
if ((esp = mprAllocObj(Esp, manageEsp)) == 0) {
return MPR_ERR_MEMORY;
}
MPR->espService = esp;
handler->stageData = esp;
esp->mutex = mprCreateLock();
esp->local = mprCreateThreadLocal();
if (espInitParser() < 0) {
return 0;
}
if ((esp->ediService = ediCreateService()) == 0) {
return 0;
}
#if ME_COM_MDB
mdbInit();
#endif
#if ME_COM_SQLITE
sdbInit();
#endif
if (module) {
mprSetModuleFinalizer(module, unloadEsp);
}
return 0;
}
MprCache *mprCreateCache(int options)
{
MprCache *cache;
int wantShared;
if ((cache = mprAllocObj(MprCache, manageCache)) == 0) {
return 0;
}
wantShared = (options & MPR_CACHE_SHARED);
if (wantShared && shared) {
cache->shared = shared;
} else {
cache->mutex = mprCreateLock();
cache->store = mprCreateHash(CACHE_HASH_SIZE, 0);
cache->maxMem = MAXSSIZE;
cache->maxKeys = MAXSSIZE;
cache->resolution = CACHE_TIMER_PERIOD;
cache->lifespan = CACHE_LIFESPAN;
if (wantShared) {
shared = cache;
}
}
return cache;
}
/*
* Add a shell parameter then do the regular init
*/
Mpr *mprCreateEx(int argc, char **argv, MprAllocNotifier cback, void *shell)
{
MprFileSystem *fs;
Mpr *mpr;
char *cp;
if (cback == 0) {
cback = memoryFailure;
}
mpr = (Mpr*) mprCreateAllocService(cback, (MprDestructor) mprDestructor);
if (mpr == 0) {
mprAssert(mpr);
return 0;
}
/*
* Wince and Vxworks passes an arg via argc, and the program name in argv. NOTE: this will only work on 32-bit systems.
*/
#if WINCE
mprMakeArgv(mpr, (char*) argv, mprToAsc(mpr, (uni*) argc), &argc, &argv);
#elif VXWORKS
mprMakeArgv(mpr, NULL, (char*) argc, &argc, &argv);
#endif
mpr->argc = argc;
mpr->argv = argv;
mpr->name = mprStrdup(mpr, BLD_PRODUCT);
mpr->title = mprStrdup(mpr, BLD_NAME);
mpr->version = mprStrdup(mpr, BLD_VERSION);
mpr->idleCallback = mprServicesAreIdle;
if (mprCreateTimeService(mpr) < 0) {
goto error;
}
if ((mpr->osService = mprCreateOsService(mpr)) < 0) {
goto error;
}
/*
* See if any of the preceeding allocations failed and mark all blocks allocated so far as required.
* They will then be omitted from leak reports.
*/
if (mprHasAllocError(mpr)) {
goto error;
}
#if BREW
mprSetShell(mpr, shell);
#endif
#if BLD_FEATURE_MULTITHREAD
mpr->multiThread = 1;
if ((mpr->threadService = mprCreateThreadService(mpr)) == 0) {
goto error;
}
mpr->mutex = mprCreateLock(mpr);
mpr->spin = mprCreateSpinLock(mpr);
#endif
if ((fs = mprCreateFileSystem(mpr, "/")) == 0) {
goto error;
}
mprAddFileSystem(mpr, fs);
if ((mpr->moduleService = mprCreateModuleService(mpr)) == 0) {
goto error;
}
if ((mpr->dispatcher = mprCreateDispatcher(mpr)) == 0) {
goto error;
}
#if BLD_FEATURE_CMD
if ((mpr->cmdService = mprCreateCmdService(mpr)) == 0) {
goto error;
}
#endif
#if BLD_FEATURE_MULTITHREAD
if ((mpr->workerService = mprCreateWorkerService(mpr)) == 0) {
goto error;
}
#endif
if ((mpr->waitService = mprCreateWaitService(mpr)) == 0) {
goto error;
}
if ((mpr->socketService = mprCreateSocketService(mpr)) == 0) {
goto error;
}
#if BLD_FEATURE_HTTP
if ((mpr->httpService = mprCreateHttpService(mpr)) == 0) {
goto error;
}
#endif
if (mpr->argv && mpr->argv[0] && *mpr->argv[0]) {
mprFree(mpr->name);
mpr->name = mprGetPathBase(mpr, mpr->argv[0]);
if ((cp = strchr(mpr->name, '.')) != 0) {
*cp = '\0';
}
}
/*
* Now catch all memory allocation errors up to this point. Should be none.
*/
if (mprHasAllocError(mpr)) {
goto error;
}
return mpr;
/*
* Error return
*/
error:
mprFree(mpr);
return 0;
}
