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;
}
