Example #1
0
static int setupServer(MaHttp *http, int poolThreads)
{
	mprLog(MPR_CONFIG, "Using server root: %s\n", serverRoot);

#if BLD_FEATURE_CONFIG_PARSE
	if (configFile) {
		if (configureViaFile() < 0) {
			return MPR_ERR_CANT_OPEN;
		}
	} else
#endif
	{
		if (configureViaApi() < 0) {
			return MPR_ERR_CANT_OPEN;
		}
	}

#if BLD_FEATURE_MULTITHREAD
	//
	//	The default limits my be updated via the config file
	//
	MaLimits *limits = http->getLimits();
	if (poolThreads >= 0) {
		limits->maxThreads = poolThreads;
		if (limits->minThreads > limits->maxThreads) {
			limits->minThreads = limits->maxThreads;
		}
	}
	if (limits->maxThreads > 0) {
		mprGetMpr()->setMaxPoolThreads(limits->maxThreads);
		mprGetMpr()->setMinPoolThreads(limits->minThreads);
	}
#endif
	return 0;
}
Example #2
0
static void catchSignal(int signo, siginfo_t *info, void *arg)
{
	mprLog(MPR_INFO, "Received signal %d\nExiting ...\n", signo);
	if (mprGetMpr()) {
		mprGetMpr()->terminate(1);
	}
}
Example #3
0
int MprCmd::waitForChild(int timeout)
{
	lock();
	//
	//	Prevent this object from being deleted by another thread while we 
	//	are using it.
	//
	inUse++;

	if (! (flags & MPR_CMD_COMPLETE)) {
		mprGetMpr()->cmdService->startWatcher();
	}
	unlock();

	while (! (flags & MPR_CMD_COMPLETE)) {
		mprGetMpr()->serviceEvents(1, MPR_CMD_WATCHER_NAP);
	}

	lock();
	//
	//	If the object was deleted while we were using it, then delete now.
	//
	if (--inUse == 0 && flags & MPR_CMD_DISPOSED) {
		delete this;
	} else {
		unlock();
	}
	return 0;
}
Example #4
0
/*
 *  Complete the request and return true if there is a pipelined request following.
 */
bool maProcessCompletion(MaConn *conn)
{
    MaRequest   *req;
    MaPacket    *packet;
    bool        more;

    mprAssert(conn->state == MPR_HTTP_STATE_COMPLETE);

    req = conn->request;
    maLogRequest(conn);

#if BLD_DEBUG
    mprLog(req, 4, "Request complete used %,d K, conn usage %,d K, mpr usage %,d K, page usage %,d K", 
        req->arena->allocBytes / 1024, conn->arena->allocBytes / 1024, mprGetMpr(conn)->heap.allocBytes / 1024, 
        mprGetMpr(conn)->pageHeap.allocBytes / 1024);
    /* mprPrintAllocReport(mprGetMpr(conn), "Before completing request"); */
#endif

    packet = conn->input;
    more = packet && (mprGetBufLength(packet->content) > 0);
    if (mprGetParent(packet) != conn) {
        if (more) {
            conn->input = maSplitPacket(conn, packet, 0);
            mprAssert(mprGetParent(conn->input) == conn);
        } else {
            conn->input = 0;
        }
    }

    /*
     *  This will free the request, response, pipeline and call maPrepConnection to reset the state.
     */
    mprFree(req->arena);
    return (conn->disconnected || conn->connectionFailed) ? 0 : more;
}
Example #5
0
void mprSetThreads(int low, int high)
{
#if BLD_FEATURE_MULTITHREAD
	if (low > 0) {
		mprGetMpr()->setMinPoolThreads(low);
	}
	if (high > 0) {
		mprGetMpr()->setMaxPoolThreads(high);
	}
#endif
}
Example #6
0
HWND mprGetHwnd(MprCtx ctx)
{
    Mpr     *mpr;

    mpr = mprGetMpr(ctx);
    return mpr->waitService->hwnd;
}
Example #7
0
void mprSetSocketMessage(MprCtx ctx, int socketMessage)
{
    Mpr     *mpr;

    mpr = mprGetMpr(ctx);
    mpr->waitService->socketMessage = socketMessage;
}
Example #8
0
void mprSetHwnd(MprCtx ctx, HWND h)
{
    Mpr     *mpr;

    mpr = mprGetMpr(ctx);
    mpr->waitService->hwnd = h;
}
Example #9
0
int MprWinService::stop(int cmd)
{
	int		exitCode;

	svcStopped++;
	mprGetMpr()->terminate(1);

	if (cmd == SERVICE_CONTROL_SHUTDOWN) {
		return 0;
	}

	SetEvent(waitEvent);
	svcStatus.dwCurrentState = SERVICE_STOP_PENDING;
	tellScm(svcStatus.dwCurrentState, NO_ERROR, 1000);

	exitCode = 0;
	GetExitCodeThread(threadHandle, (ulong*) &exitCode);
	while (exitCode == STILL_ACTIVE) {
		GetExitCodeThread(threadHandle, (ulong*) &exitCode);
		mprSleep(100);
		tellScm(svcStatus.dwCurrentState, NO_ERROR, 125);
	}
	svcStatus.dwCurrentState = SERVICE_STOPPED;
	tellScm(svcStatus.dwCurrentState, exitCode, 0);
	return 0;
}
Example #10
0
/*
 *  Load the ssl provider
 */
static MprModule *loadSsl(MprCtx ctx, bool lazy)
{
    Mpr         *mpr;
    MprModule   *mp;

    mpr = mprGetMpr(ctx);

    if (mpr->flags & MPR_SSL_PROVIDER_LOADED) {
        return mprLookupModule(ctx, "sslModule");
    }

    mprLog(ctx, MPR_CONFIG, "Activating the SSL provider");
#if BLD_FEATURE_OPENSSL
    /*
     *  NOTE: preference given to open ssl if both are enabled
     */
    mprLog(ctx, 2, "Loading OpenSSL module");
    if (mprCreateOpenSslModule(ctx, lazy) < 0) {
        return 0;
    }

#elif BLD_FEATURE_MATRIXSSL
    mprLog(ctx, 2, "Loading MatrixSSL module");
    if (mprCreateMatrixSslModule(ctx, lazy) < 0) {
        return 0;
    }
#endif
    if ((mp = mprCreateModule(ctx, "sslModule", BLD_VERSION, NULL, NULL, NULL)) == 0) {
        return 0;
    }
    mpr->flags |= MPR_SSL_PROVIDER_LOADED;
    return mp;
}
Example #11
0
MprThread::~MprThread()
{
	lock();
	mprFree(name);
	mprGetMpr()->threadService->removeThread(this);
	delete mutex;
}
Example #12
0
void mprSetServiceThread(MprCtx ctx, MprThread *thread)
{
    Mpr     *mpr;

    mpr = mprGetMpr(ctx);
    mpr->serviceThread = thread->osThread;
}
Example #13
0
static int windowsServiceOps()
{
	winService = new MprWinService(APPWEB_SERVICE_NAME);
	switch (serviceOp) {
	case MPR_INSTALL_SERVICE:
		char path[MPR_MAX_FNAME], cmd[MPR_MAX_FNAME];
		GetModuleFileName(0, path, sizeof(path));
		mprSprintf(cmd, sizeof(cmd), "\"%s\" %s", path, serviceCmdLine);
		winService->install(APPWEB_SERVICE_DISPLAY, cmd);
		break;

	case MPR_UNINSTALL_SERVICE:
		winService->remove(1);
		break;

	case MPR_GO_SERVICE:
		winService->start();
		//
		//	Give time for service to actually start 
		//
		mprSleep(2000);
		break;

	case MPR_STOP_SERVICE:
		winService->remove(0);
		break;
	}
	if (isService) {
		mprGetMpr()->setService(1);
	}
	return 0;
}
Example #14
0
static bool appwebIsIdle(MprCtx ctx)
{
    MaHost      *host;
    MaConn      *conn;
    MaHttp      *http;
    MprTime     now;
    int         nextHost, next;
    static MprTime lastTrace = 0;

    now = mprGetTime(ctx);
    http = (MaHttp*) mprGetMpr(ctx)->appwebHttpService;
    for (nextHost = 0; (host = mprGetNextItem(http->defaultServer->hosts, &nextHost)) != 0; ) {
        lock(host);
        for (next = 0; (conn = mprGetNextItem(host->connections, &next)) != 0; ) {
            if (conn->state != MPR_HTTP_STATE_BEGIN) {
                if (lastTrace < now) {
                    mprLog(ctx, 0, "Waiting for request %s to complete", 
                           *conn->request->url ? conn->request->url : conn->request->pathInfo);
                    lastTrace = now;
                }
                unlock(host);
                return 0;
            }
        }
        unlock(host);
    }
    if (!mprServicesAreIdle(ctx)) {
        if (lastTrace < now) {
            mprLog(ctx, 0, "Waiting for MPR services complete");
            lastTrace = now;
        }
        return 0;
    }
    return 1;
}
Example #15
0
void MprLogModule::innerMprLogModule(char *s)
{
	MprLogModule	*def;
	Mpr				*mpr;
	char			namBuf[MPR_MAX_FNAME];
	char			*moduleSpecs, *cp;

	name = mprStrdup(s);
	enabled = 1;
	level = -1;

	mpr = mprGetMpr();
	moduleSpecs = mpr->logService->getModuleSpecs();
	if (moduleSpecs) {
		mprSprintf(namBuf, sizeof(namBuf), "%s:", name);
		if ((cp = strstr(moduleSpecs, namBuf)) != 0) {
			if ((cp = strchr(cp, ':')) != 0) {
				level = atoi(++cp);
			}
		}
	}

	if (level < 0) {
		def = mpr->logService->getDefaultModule();
		if (def) {
			level = def->getLevel();
		}
	}
	mpr->logService->insertModule(this);
}
Example #16
0
static int windowsInit()
{
#if ONLY_SINGLE_INSTANCE
	if (serviceOp == 0 && findInstance()) {
		mprError(MPR_L, MPR_USER, "Application %s is already active.", program);
		return MPR_ERR_BUSY;
	}
#endif

	//
	//	Create the window
	// 
	if (initWindow() < 0) {
		mprError(MPR_L, MPR_ERROR, "Can't initialize application Window");
		return MPR_ERR_CANT_INITIALIZE;
	}

	if (trayIcon > 0) {
		if (openTrayIcon() < 0 && mp->isService()) {
			trayTimer = new MprTimer(10 * 1000, trayIconProc, (void *) NULL);
		}
	}
	mprGetMpr()->setAsyncSelectMode(MPR_ASYNC_SELECT);
	return 0;
}
Example #17
0
void MprLogToFile::logEvent(char *module, int flags, int level, char *thread, 
	char *msg)
{
	char		buf[MPR_MAX_LOG_STRING];

	if (mprGetMpr() == 0) {
		mprStrcpy(buf, sizeof(buf), msg);

	} else if (timeStamps) {
#if CYGWIN || LINUX || MACOSX || SOLARIS || VXWORKS || FREEBSD
#if	BLD_FEATURE_HIRES_TIME
		int64 elapsed = mprGetElapsedTime();
		mprSprintf(buf, sizeof(buf), "%,14Ld %10s:%d %s  %s", elapsed, module, 
			level, thread, msg);
#else
		static int last = 0;
		int now = mprGetTime(0);
		int elapsed = now - last;
		mprSprintf(buf, sizeof(buf), "%,14d %10s:%d %s  %s", elapsed, module, 
			level, thread, msg);
		last = now;
#endif
#endif // CYGWIN || LINUX || MACOSX || SOLARIS || VXWORKS || FREEBSD

	} else if (! (flags & MPR_RAW)) {
		mprSprintf(buf, sizeof(buf), "%10s:%d %4s  %s", module, level, thread, 
			msg);

	} else {
		//	Raw output
		mprStrcpy(buf, sizeof(buf), msg);
	}

	if (logFd < 0) {
		if (level <= 1) {
			//
			//	Always output fatal and error messages
			//
			mprFprintf(MPR_STDERR, buf);
		}
		return;
	}

	//	OPT -- could get length above
	mprAssert(logFd >= 0);
	write(logFd, buf, strlen(buf));

	if (logFd != MPR_STDOUT) {
		struct stat	sbuf;
		if (maxSize <= 0 || fstat(logFd, &sbuf) < 0) {
			return;
		}
		//
		//	Rotate logs when full
		//
		if (sbuf.st_mode & S_IFREG && (unsigned) sbuf.st_size > maxSize) {
			rotate();
		}
	}
}
Example #18
0
void MprLogService::output(MprLogModule *module, int flags, int level, 
	char *msg)
{
	MprLogListener	*lp;
	Mpr				*mpr;
	char			*threadName, *moduleName;

	mpr = mprGetMpr();

	lock();
	threadName = "";
#if BLD_FEATURE_MULTITHREAD
	if (mpr && mpr->threadService) {
		MprThread *tp = mpr->threadService->getCurrentThread();
		if (tp) {
			threadName = tp->getName();
		} 
	}
#endif

	moduleName = module ? module->getName() : (char*) "default";

	lp = (MprLogListener*) listeners.getFirst();
	while (lp) {
		lp->logEvent(moduleName, flags, level, threadName, msg);
		lp = (MprLogListener*) listeners.getNext(lp);
	}

	unlock();
}
Example #19
0
cchar *mprGetAppVersion(MprCtx ctx)
{
    Mpr *mpr;

    mpr = mprGetMpr(ctx);
    return mpr->version;
}
Example #20
0
int mprSetAppName(MprCtx ctx, cchar *name, cchar *title, cchar *version)
{
    Mpr     *mpr;
    char    *cp;

    mpr = mprGetMpr(ctx);

    if (name) {
        mprFree(mpr->name);
        if ((mpr->name = (char*) mprGetPathBase(mpr, name)) == 0) {
            return MPR_ERR_CANT_ALLOCATE;
        }
        if ((cp = strrchr(mpr->name, '.')) != 0) {
            *cp = '\0';
        }
    }

    if (title) {
        mprFree(mpr->title);
        if ((mpr->title = mprStrdup(ctx, title)) == 0) {
            return MPR_ERR_CANT_ALLOCATE;
        }
    }

    if (version) {
        mprFree(mpr->version);
        if ((mpr->version = mprStrdup(ctx, version)) == 0) {
            return MPR_ERR_CANT_ALLOCATE;
        }
    }
    return 0;
}
Example #21
0
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;
}
Example #22
0
MprThread::MprThread(MprThreadProc entry, int priority, void *data, char *name,
	int stackSize)
{
	Mpr		*mpr;

	mpr = mprGetMpr();
	mprLog(7, "Create Thread %s\n", name);

	osThreadId = 0;
	pid = 0;
	this->priority = priority;
	this->entry = entry;
	this->data = data;
	this->name = mprStrdup(name);
	this->stackSize = stackSize;
	mutex = new MprMutex();

	if (stackSize == 0) {
		this->stackSize = mpr->getConfigInt("stackSize", MPR_DEFAULT_STACK);
	} else {
		this->stackSize = stackSize;
	}

	if (mpr->threadService) {
		mpr->threadService->insertThread(this);
	}
}
Example #23
0
int MaClient::sendRetry(char *op, char *requestUrl, char *postData, int postLen)
{
	int		authCount, count, rc;

	authCount = count = 0;
	do {
again:
		rc = sendCore(op, requestUrl, postData, postLen);
		if (rc == 0 && !(flags & MPR_HTTP_TERMINATED)) {
			if (responseCode == 401) {
				//
				//	Carefull altering this code. Ran into GCC compiler bugs.
				//
				if (authCount++ == 0 && user && password && realm) {
					goto again;
				}
				count = retries;
			} else {
				break;
			}
		}
	} while (++count < retries && !mprGetMpr()->isExiting());

	if (rc < 0 && count >= retries) {
		mprError(MPR_L, MPR_LOG, "sendRetry: failed to get %s %s, %d", 
			op, requestUrl, rc);
		return MPR_ERR_TOO_MANY;
	}
	return 0;
}
Example #24
0
static void readEventWrapper(void *data, MprSocket *sp, int mask, 
	int isPoolThread)
{
	MaClient	*cp;
	int			moreData, loopCount;

	mprLog(5, "%d: readEventWrapper: mask %x, isPool %d\n", 
		sp->getFd(), mask, isPoolThread);

	//
	//	Make sure we are not being deleted
	//
	mprGetMpr()->lock();
	cp = (MaClient*) clients.getFirst();
	while (cp) {
		if (cp == (MaClient*) data) {
			break;
		}
		cp = (MaClient*) clients.getNext(cp);
	}

	if (cp == 0) {
		mprError(MPR_L, MPR_LOG, "Client deleted prematurely.");
		return;
	}
	cp->lock();
	mprGetMpr()->unlock();

	//
	//	If we are multi-threaded and called on a pool thread, we can block and
	//	read as much data as we can. If single threaded, just do 25 reads.
	//
	loopCount = 25;
	do {
		moreData = cp->readEvent();

		if (cp->getState() == MPR_HTTP_CLIENT_DONE) {
			cp->signalComplete();
			break;
		}

	} while (moreData > 0 && (isPoolThread || loopCount-- > 0));

	cp->unlock();
}
Example #25
0
void mprSetLogHandler(MprCtx ctx, MprLogHandler handler, void *handlerData)
{
    Mpr     *mpr;

    mpr = mprGetMpr(ctx);

    mpr->logHandler = handler;
    mpr->logHandlerData = handlerData;
}
Example #26
0
void mprConfigureSsl(MprSsl *ssl)
{
    MprSocketProvider   *provider;

    provider = mprGetMpr(ssl)->socketService->secureProvider;
    if (provider) {
        provider->configureSsl(ssl);
    }
}
Example #27
0
MprIdleCallback mprSetIdleCallback(MprCtx ctx, MprIdleCallback idleCallback)
{
    MprIdleCallback old;
    Mpr             *mpr;
    
    mpr = mprGetMpr(ctx);
    old = mpr->idleCallback;
    mpr->idleCallback = idleCallback;
    return old;
}
Example #28
0
bool mprIsExiting(MprCtx ctx)
{
    Mpr *mpr;

    mpr = mprGetMpr(ctx);
    if (mpr == 0) {
        return 1;
    }
    return mpr->flags & MPR_EXITING;
}
Example #29
0
/*
 *  Thread main for serviceEvents
 */
static void serviceEvents(void *data, MprThread *tp)
{
    Mpr     *mpr;

    mpr = mprGetMpr(tp);
    mpr->serviceThread = tp->osThread;
    mprServiceEvents(mpr->dispatcher, -1, MPR_SERVICE_EVENTS | MPR_SERVICE_IO);
    mpr->serviceThread = 0;
    mpr->hasDedicatedService = 1;
}
Example #30
0
bool mprIsComplete(MprCtx ctx)
{
    Mpr *mpr;

    mpr = mprGetMpr(ctx);
    if (mpr == 0) {
        return 1;
    }
    return (mpr->flags & MPR_EXITING) && mprIsIdle(ctx);
}