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; }
int mprCtime(MprCtx ctx, char *buf, int bufsize, const time_t *timer) { char localBuf[80]; char *cp; int len; mprAssert(buf); mprGlobalLock(ctx); cp = ctime_r(timer, localBuf); if ((int) strlen(cp) >= bufsize) { mprStrcpy(buf, bufsize, "WONT FIT"); mprAssert(0); return MPR_ERR_WONT_FIT; } len = mprStrcpy(buf, bufsize, cp); if (buf[len - 1] == '\n') { buf[len - 1] = '\0'; } mprGlobalUnlock(ctx); return 0; }
/* 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; }
static int initLock(MprTestGroup *gp) { mprGlobalLock(gp); if (mutex == 0) { mutex = mprCreateLock(gp); } mprGlobalUnlock(gp); return 0; }
static int termLock(MprTestGroup *gp) { mprGlobalLock(gp); if (mutex == 0) { mprFree(mutex); mutex = 0; } mprGlobalUnlock(gp); return 0; }
static int termLock(MprTestGroup *gp) { mprGlobalLock(gp); if (--threadCount == 0) { if (mutex) { mprRemoveRoot(mutex); mutex = 0; } } mprGlobalUnlock(gp); return 0; }
static int initLock(MprTestGroup *gp) { mprGlobalLock(gp); if (mutex == 0) { mutex = mprCreateLock(gp); gp->data = mutex; mprAddRoot(mutex); } threadCount++; mprGlobalUnlock(gp); return 0; }
static void semVerInit() { if (!semVer) { mprGlobalLock(); if (!semVer) { semVer = srcompile(SEM_VER); semCriteria = srcompile(SEM_CRITERIA); semExpr = srcompile(SEM_EXPR); mprAddTerminator((MprTerminator) versionTerminate); } mprGlobalUnlock(); } }
static void testMakeDir(MprTestGroup *gp) { TestPath *ts; int rc; ts = (TestPath*) gp->data; mprGlobalLock(gp); rc = mprMakeDir(ts->dir1, DIRMODE, -1, -1, 1); assert(rc == 0); assert(access(ts->dir1, X_OK) == 0); rmdir(ts->dir1); assert(access(ts->dir1, X_OK) < 0); rmdir(ts->dir2); rmdir(ts->dir1); /* Dir should not exist before test */ assert(access(ts->dir1, X_OK) < 0); /* Make directory path */ rc = mprMakeDir(ts->dir2, DIRMODE, -1, -1, 1); assert(rc == 0); assert(access(ts->dir2, X_OK) == 0); rc = mprDeletePath(ts->dir2); assert(rc == 0); rc = mprDeletePath(ts->dir1); assert(rc == 0); assert(access(ts->dir1, X_OK) < 0); assert(access(ts->dir2, X_OK) < 0); mprGlobalUnlock(gp); }
PUBLIC Http *httpCreate(int flags) { Http *http; HttpStatusCode *code; mprGlobalLock(); if (MPR->httpService) { mprGlobalUnlock(); return MPR->httpService; } if ((http = mprAllocObj(Http, manageHttp)) == 0) { mprGlobalUnlock(); return 0; } MPR->httpService = HTTP = http; http->software = sclone(ME_HTTP_SOFTWARE); http->protocol = sclone("HTTP/1.1"); http->mutex = mprCreateLock(); http->stages = mprCreateHash(-1, MPR_HASH_STABLE); http->hosts = mprCreateList(-1, MPR_LIST_STABLE); http->connections = mprCreateList(-1, MPR_LIST_STATIC_VALUES); http->authTypes = mprCreateHash(-1, MPR_HASH_CASELESS | MPR_HASH_UNIQUE | MPR_HASH_STABLE); http->authStores = mprCreateHash(-1, MPR_HASH_CASELESS | MPR_HASH_UNIQUE | MPR_HASH_STABLE); http->routeSets = mprCreateHash(-1, MPR_HASH_STATIC_VALUES | MPR_HASH_STABLE); http->booted = mprGetTime(); http->flags = flags; http->monitorPeriod = ME_HTTP_MONITOR_PERIOD; http->secret = mprGetRandomString(HTTP_MAX_SECRET); http->trace = httpCreateTrace(0); http->startLevel = 2; http->localPlatform = slower(sfmt("%s-%s-%s", ME_OS, ME_CPU, ME_PROFILE)); httpSetPlatform(http->localPlatform); httpSetPlatformDir(NULL); updateCurrentDate(); http->statusCodes = mprCreateHash(41, MPR_HASH_STATIC_VALUES | MPR_HASH_STATIC_KEYS | MPR_HASH_STABLE); for (code = HttpStatusCodes; code->code; code++) { mprAddKey(http->statusCodes, code->codeString, code); } httpGetUserGroup(); httpInitParser(); httpInitAuth(); httpOpenNetConnector(); httpOpenSendConnector(); httpOpenRangeFilter(); httpOpenChunkFilter(); #if ME_HTTP_WEB_SOCKETS httpOpenWebSockFilter(); #endif mprSetIdleCallback(isIdle); mprAddTerminator(terminateHttp); if (flags & HTTP_SERVER_SIDE) { http->endpoints = mprCreateList(-1, MPR_LIST_STABLE); http->counters = mprCreateList(-1, MPR_LIST_STABLE); http->monitors = mprCreateList(-1, MPR_LIST_STABLE); http->routeTargets = mprCreateHash(-1, MPR_HASH_STATIC_VALUES | MPR_HASH_STABLE); http->routeConditions = mprCreateHash(-1, MPR_HASH_STATIC_VALUES | MPR_HASH_STABLE); http->routeUpdates = mprCreateHash(-1, MPR_HASH_STATIC_VALUES | MPR_HASH_STABLE); http->sessionCache = mprCreateCache(MPR_CACHE_SHARED | MPR_HASH_STABLE); http->addresses = mprCreateHash(-1, MPR_HASH_STABLE); http->defenses = mprCreateHash(-1, MPR_HASH_STABLE); http->remedies = mprCreateHash(-1, MPR_HASH_CASELESS | MPR_HASH_STATIC_VALUES | MPR_HASH_STABLE); httpOpenUploadFilter(); httpOpenCacheHandler(); httpOpenPassHandler(); httpOpenActionHandler(); httpOpenDirHandler(); httpOpenFileHandler(); http->serverLimits = httpCreateLimits(1); httpDefineRouteBuiltins(); httpAddCounters(); httpAddRemedies(); httpCreateDefaultHost(); } if (flags & HTTP_CLIENT_SIDE) { http->defaultClientHost = sclone("127.0.0.1"); http->defaultClientPort = 80; http->clientLimits = httpCreateLimits(0); http->clientRoute = httpCreateConfiguredRoute(0, 0); http->clientHandler = httpCreateHandler("client", 0); } mprGlobalUnlock(); return http; }
/* * Start the command to run (stdIn and stdOut are named from the client's perspective). This is the lower-level way to * run a command. The caller needs to do code like mprRunCmd() themselves to wait for completion and to send/receive data. * The routine does not wait. Callers must call mprWaitForCmd to wait for the command to complete. */ int mprStartCmd(MprCmd *cmd, int argc, char **argv, char **envp, int flags) { MprPath info; char *program; int rc; mprAssert(argv); mprAssert(argc > 0); if (argc <= 0 || argv == NULL || argv[0] == NULL) { return MPR_ERR_BAD_STATE; } resetCmd(cmd); program = argv[0]; cmd->program = program; cmd->flags = flags; if (sanitizeArgs(cmd, argc, argv, envp) < 0) { return MPR_ERR_NO_MEMORY; } if (access(program, X_OK) < 0) { program = mprJoinPathExt(cmd, program, BLD_EXE); if (access(program, X_OK) < 0) { mprLog(cmd, 1, "cmd: can't access %s, errno %d", program, mprGetOsError()); return MPR_ERR_CANT_ACCESS; } } if (mprGetPathInfo(cmd, program, &info) == 0 && info.isDir) { mprLog(cmd, 1, "cmd: program \"%s\", is a directory", program); return MPR_ERR_CANT_ACCESS; } #if CYGWIN mprGlobalLock(cmd); #endif if (mprMakeCmdIO(cmd) < 0) { #if CYGWIN mprGlobalUnlock(cmd); #endif return MPR_ERR_CANT_OPEN; } /* * Determine how many end-of-files will be seen when the child dies */ cmd->requiredEof = 0; if (cmd->flags & MPR_CMD_OUT) { cmd->requiredEof++; } if (cmd->flags & MPR_CMD_ERR) { cmd->requiredEof++; } #if UNUSED && KEEP && NON_BLOCKING #if BLD_UNIX_LIKE || VXWORKS { int stdinFd, stdoutFd, stderrFd, nonBlock; stdinFd = cmd->files[MPR_CMD_STDIN].fd; stdoutFd = cmd->files[MPR_CMD_STDOUT].fd; stderrFd = cmd->files[MPR_CMD_STDERR].fd; nonBlock = 1; /* * Put the stdout and stderr into non-blocking mode. Windows can't do this because both ends of the pipe * share the same blocking mode (Ugh!). */ #if VXWORKS if (stdoutFd >= 0) { ioctl(stdoutFd, FIONBIO, (int) &nonBlock); } if (stderrFd >= 0) { ioctl(stderrFd, FIONBIO, (int) &nonBlock); } #else if (stdoutFd >= 0) { fcntl(stdoutFd, F_SETFL, fcntl(stdoutFd, F_GETFL) | O_NONBLOCK); } if (stderrFd >= 0) { fcntl(stderrFd, F_SETFL, fcntl(stderrFd, F_GETFL) | O_NONBLOCK); } #endif if (stdoutFd >= 0) { cmd->handlers[MPR_CMD_STDOUT] = mprCreateWaitHandler(cmd, stdoutFd, MPR_READABLE, (MprWaitProc) stdoutCallback, cmd, MPR_NORMAL_PRIORITY, MPR_WAIT_THREAD); } if (stderrFd >= 0) { cmd->handlers[MPR_CMD_STDERR] = mprCreateWaitHandler(cmd, stderrFd, MPR_READABLE, (MprWaitProc) stderrCallback, cmd, MPR_NORMAL_PRIORITY, MPR_WAIT_THREAD); if (stdoutFd >= 0) { /* * Delay enabling stderr events until stdout is complete */ mprDisableWaitEvents(cmd->handlers[MPR_CMD_STDERR]); } } } #endif #endif rc = startProcess(cmd); #if CYGWIN mprGlobalUnlock(cmd); #endif return rc; }