static bool expired(EjsHttp *hp)
{
int requestTimeout, inactivityTimeout, diff, inactivity;
requestTimeout = conn->limits->requestTimeout ? conn->limits->requestTimeout : MAXINT;
inactivityTimeout = conn->limits->inactivityTimeout ? conn->limits->inactivityTimeout : MAXINT;
/*
Workaround for a GCC bug when comparing two 64bit numerics directly. Need a temporary.
*/
diff = (conn->lastActivity + inactivityTimeout) - http->now;
inactivity = 1;
if (diff > 0 && conn->rx) {
diff = (conn->started + requestTimeout) - http->now;
inactivity = 0;
}
if (diff < 0) {
if (conn->rx) {
if (inactivity) {
mprTrace(4, "Inactive request timed out %s, exceeded inactivity timeout %d",
conn->rx->uri, inactivityTimeout);
} else {
mprTrace(4, "Request timed out %s, exceeded timeout %d", conn->rx->uri, requestTimeout);
}
} else {
mprTrace(4, "Idle connection timed out");
}
}
}
static int join(Ejs *ejs, EjsObj *workers, int timeout)
{
MprTicks mark;
int result, remaining;
mprTrace(5, "Worker.join: joining %d", ejs->joining);
mark = mprGetTicks();
remaining = timeout;
do {
ejs->joining = !reapJoins(ejs, workers);
if (!ejs->joining) {
break;
}
if (mprShouldAbortRequests()) {
ejsThrowStateError(ejs, "Program instructed to exit");
break;
}
mprWaitForEvent(ejs->dispatcher, remaining);
remaining = (int) mprGetRemainingTicks(mark, timeout);
} while (remaining > 0 && !ejs->exception);
if (ejs->exception) {
return 0;
}
result = (ejs->joining) ? MPR_ERR_TIMEOUT: 0;
ejs->joining = 0;
mprTrace(7, "Worker.join: result %d", result);
return result;
}
static void cgiToBrowserService(HttpQueue *q)
{
HttpConn *conn;
MprCmd *cmd;
Cgi *cgi;
if ((cgi = q->queueData) == 0) {
return;
}
conn = q->conn;
assert(q == conn->writeq);
cmd = cgi->cmd;
/*
This will copy outgoing packets downstream toward the network connector and on to the browser.
This may disable the CGI queue if the downstream net connector queue overflows because the socket
is full. In that case, httpEnableConnEvents will setup to listen for writable events. When the
socket is writable again, the connector will drain its queue which will re-enable this queue
and schedule it for service again.
*/
httpDefaultOutgoingServiceStage(q);
if (q->count < q->low) {
mprEnableCmdOutputEvents(cmd, 1);
mprTrace(6, "CGI: ENABLE CGI events: cgiToBrowserService");
} else if (q->count > q->max && conn->tx->writeBlocked) {
mprTrace(6, "CGI: SUSPEND WRITEQ: cgiToBrowserData writeq %d/%d", conn->writeq->count, conn->writeq->max);
httpSuspendQueue(conn->writeq);
}
mprTrace(6, "CGI: cgiToBrowserService pid %d, q->count %d, q->flags %x, blocked %d",
cmd->pid, q->count, q->flags, conn->tx->writeBlocked);
}
static int runCommand(HttpRoute *route, MprDispatcher *dispatcher, cchar *command, cchar *csource, cchar *module, char **errMsg)
{
MprCmd *cmd;
MprKey *var;
MprList *elist;
EspRoute *eroute;
cchar **env, *commandLine;
char *err, *out;
int rc;
*errMsg = 0;
eroute = route->eroute;
cmd = mprCreateCmd(dispatcher);
if ((commandLine = espExpandCommand(route, command, csource, module)) == 0) {
*errMsg = sfmt("Missing EspCompile directive for %s", csource);
return MPR_ERR_CANT_READ;
}
mprTrace(4, "ESP command: %s\n", commandLine);
if (eroute->env) {
elist = mprCreateList(0, MPR_LIST_STABLE);
for (ITERATE_KEYS(eroute->env, var)) {
mprAddItem(elist, sfmt("%s=%s", var->key, var->data));
}
mprAddNullItem(elist);
env = (cchar**) &elist->items[0];
} else {
/*
Open the handler for a new request
*/
static int openCgi(HttpQueue *q)
{
HttpConn *conn;
Cgi *cgi;
int nproc;
conn = q->conn;
mprTrace(5, "Open CGI handler");
if ((nproc = (int) httpMonitorEvent(conn, HTTP_COUNTER_ACTIVE_PROCESSES, 1)) >= conn->limits->processMax) {
mprLog(2, "Too many concurrent processes %d/%d", nproc, conn->limits->processMax);
httpError(conn, HTTP_CODE_SERVICE_UNAVAILABLE, "Server overloaded");
httpMonitorEvent(q->conn, HTTP_COUNTER_ACTIVE_PROCESSES, -1);
return MPR_ERR_CANT_OPEN;
}
if ((cgi = mprAllocObj(Cgi, manageCgi)) == 0) {
/* Normal mem handler recovery */
return MPR_ERR_MEMORY;
}
httpTrimExtraPath(conn);
httpMapFile(conn);
httpCreateCGIParams(conn);
q->queueData = q->pair->queueData = cgi;
cgi->conn = conn;
cgi->readq = httpCreateQueue(conn, conn->http->cgiConnector, HTTP_QUEUE_RX, 0);
cgi->writeq = httpCreateQueue(conn, conn->http->cgiConnector, HTTP_QUEUE_TX, 0);
cgi->readq->pair = cgi->writeq;
cgi->writeq->pair = cgi->readq;
cgi->writeq->queueData = cgi->readq->queueData = cgi;
return 0;
}
/*
Parse the CGI output first line
*/
static bool parseFirstCgiResponse(Cgi *cgi, HttpPacket *packet)
{
MprBuf *buf;
char *protocol, *status, *msg;
buf = packet->content;
protocol = getCgiToken(buf, " ");
if (protocol == 0 || protocol[0] == '\0') {
httpError(cgi->conn, HTTP_CODE_BAD_GATEWAY, "Bad CGI HTTP protocol response");
return 0;
}
if (strncmp(protocol, "HTTP/1.", 7) != 0) {
httpError(cgi->conn, HTTP_CODE_BAD_GATEWAY, "Unsupported CGI protocol");
return 0;
}
status = getCgiToken(buf, " ");
if (status == 0 || *status == '\0') {
httpError(cgi->conn, HTTP_CODE_BAD_GATEWAY, "Bad CGI header response");
return 0;
}
msg = getCgiToken(buf, "\n");
mprNop(msg);
mprTrace(4, "CGI: Status line: %s %s %s", protocol, status, msg);
return 1;
}
PUBLIC ssize espRenderError(HttpConn *conn, int status, cchar *fmt, ...)
{
va_list args;
HttpRx *rx;
ssize written;
cchar *msg, *title, *text;
va_start(args, fmt);
rx = conn->rx;
written = 0;
if (!httpIsFinalized(conn)) {
if (status == 0) {
status = HTTP_CODE_INTERNAL_SERVER_ERROR;
}
title = sfmt("Request Error for \"%s\"", rx->pathInfo);
msg = mprEscapeHtml(sfmtv(fmt, args));
if (rx->route->flags & HTTP_ROUTE_SHOW_ERRORS) {
text = sfmt(\
"<!DOCTYPE html>\r\n<html>\r\n<head><title>%s</title></head>\r\n" \
"<body>\r\n<h1>%s</h1>\r\n" \
" <pre>%s</pre>\r\n" \
" <p>To prevent errors being displayed in the browser, " \
" set <b>ShowErrors off</b> in the appweb.conf file.</p>\r\n", \
"</body>\r\n</html>\r\n", title, title, msg);
httpSetHeader(conn, "Content-Type", "text/html");
written += espRenderString(conn, text);
espFinalize(conn);
mprTrace(4, "Request error (%d) for: \"%s\"", status, rx->pathInfo);
}
}
va_end(args);
return written;
}
/*
Read the output data from the CGI script and return it to the client. This is called by the MPR in response to
I/O events from the CGI process for stdout/stderr data from the CGI script and for EOF from the CGI's stdin.
IMPORTANT: This event runs on the connection's dispatcher. (ie. single threaded and safe)
*/
static void cgiCallback(MprCmd *cmd, int channel, void *data)
{
HttpConn *conn;
Cgi *cgi;
int suspended;
if ((cgi = data) == 0) {
return;
}
if ((conn = cgi->conn) == 0) {
return;
}
conn->lastActivity = conn->http->now;
mprTrace(6, "CGI: cgiCallback event channel %d", channel);
switch (channel) {
case MPR_CMD_STDIN:
/* Stdin can absorb more data */
httpResumeQueue(cgi->writeq);
break;
case MPR_CMD_STDOUT:
case MPR_CMD_STDERR:
readFromCgi(cgi, channel);
break;
default:
/* Child death notification */
break;
}
if (cgi->location) {
httpRedirect(conn, conn->tx->status, cgi->location);
}
if (cmd->complete || cgi->location) {
cgi->location = 0;
httpFinalize(conn);
mprCreateEvent(conn->dispatcher, "cgiComplete", 0, httpIOEvent, conn, 0);
return;
}
suspended = httpIsQueueSuspended(conn->writeq);
mprTrace(6, "CGI: %s CGI: cgiCallback. Conn->writeq %d", suspended ? "DISABLE" : "ENABLE", conn->writeq->count);
assert(!suspended || conn->tx->writeBlocked);
mprEnableCmdOutputEvents(cmd, !suspended);
mprCreateEvent(conn->dispatcher, "cgi", 0, httpIOEvent, conn, 0);
}
static int reportResponse(HttpConn *conn, cchar *url, MprTicks elapsed)
{
HttpRx *rx;
MprOff bytesRead;
char *responseHeaders;
int status;
if (mprShouldAbortRequests(conn)) {
return 0;
}
app->status = status = httpGetStatus(conn);
bytesRead = httpGetContentLength(conn);
if (bytesRead < 0 && conn->rx) {
bytesRead = conn->rx->bytesRead;
}
mprTrace(6, "Response status %d, elapsed %Ld", status, elapsed);
if (conn->error) {
app->success = 0;
}
if (conn->rx) {
if (app->showHeaders) {
responseHeaders = httpGetHeaders(conn);
rx = conn->rx;
mprPrintf("%s %d %s\n", conn->protocol, status, rx->statusMessage);
if (responseHeaders) {
mprPrintf("%s\n", responseHeaders);
}
} else if (app->showStatus) {
mprPrintf("%d\n", status);
}
}
if (status < 0) {
mprError("Cannot process request for \"%s\" %s", url, httpGetError(conn));
return MPR_ERR_CANT_READ;
} else if (status == 0 && conn->protocol == 0) {
/* Ignore */;
} else if (!(200 <= status && status <= 206) && !(301 <= status && status <= 304)) {
if (!app->zeroOnErrors) {
app->success = 0;
}
if (!app->showStatus) {
mprError("Cannot process request for \"%s\" (%d) %s", url, status, httpGetError(conn));
return MPR_ERR_CANT_READ;
}
}
mprLock(app->mutex);
app->fetchCount++;
if (app->verbose && app->noout) {
trace(conn, url, app->fetchCount, app->method, status, bytesRead);
}
mprUnlock(app->mutex);
return 0;
}
static void browserToCgiService(HttpQueue *q)
{
HttpConn *conn;
HttpPacket *packet;
Cgi *cgi;
MprCmd *cmd;
MprBuf *buf;
ssize rc, len;
int err;
if ((cgi = q->queueData) == 0) {
return;
}
assert(q == cgi->writeq);
cmd = cgi->cmd;
assert(cmd);
conn = cgi->conn;
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if ((buf = packet->content) == 0) {
/* End packet */
continue;
}
len = mprGetBufLength(buf);
rc = mprWriteCmd(cmd, MPR_CMD_STDIN, mprGetBufStart(buf), len);
if (rc < 0) {
err = mprGetError();
if (err == EINTR) {
continue;
} else if (err == EAGAIN || err == EWOULDBLOCK) {
httpPutBackPacket(q, packet);
break;
}
mprLog(2, "CGI: write to gateway failed for %d bytes, rc %d, errno %d", len, rc, mprGetOsError());
mprCloseCmdFd(cmd, MPR_CMD_STDIN);
httpDiscardQueueData(q, 1);
httpError(conn, HTTP_CODE_BAD_GATEWAY, "Cannot write body data to CGI gateway");
break;
}
mprTrace(6, "CGI: browserToCgiService %d/%d, qmax %d", rc, len, q->max);
mprAdjustBufStart(buf, rc);
if (mprGetBufLength(buf) > 0) {
httpPutBackPacket(q, packet);
break;
}
}
if (q->count > 0) {
/* Wait for writable event so cgiCallback can recall this routine */
mprEnableCmdEvents(cmd, MPR_CMD_STDIN);
} else if (conn->rx->eof) {
mprCloseCmdFd(cmd, MPR_CMD_STDIN);
} else {
mprDisableCmdEvents(cmd, MPR_CMD_STDIN);
}
}
static void outgoingProxyService(HttpQueue *q)
{
HttpPacket *packet;
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (packet->flags & HTTP_PACKET_DATA) {
if (!httpWillNextQueueAcceptPacket(q, packet)) {
mprTrace(7, "OutgoingProxyService downstream full, putback");
httpPutBackPacket(q, packet);
return;
}
}
httpPutPacketToNext(q, packet);
}
}
static int doRequest(HttpConn *conn, cchar *url, MprList *files)
{
MprTicks mark, remaining;
HttpLimits *limits;
MprFile *outFile;
cchar *path;
assert(url && *url);
limits = conn->limits;
mprTrace(4, "fetch: %s %s", app->method, url);
mark = mprGetTicks();
if (issueRequest(conn, url, files) < 0) {
return MPR_ERR_CANT_CONNECT;
}
remaining = limits->requestTimeout;
if (app->outFilename) {
path = app->loadThreads > 1 ? sfmt("%s-%s.tmp", app->outFilename, mprGetCurrentThreadName()): app->outFilename;
if ((outFile = mprOpenFile(path, O_CREAT | O_WRONLY | O_TRUNC | O_TEXT, 0664)) == 0) {
mprError("Cannot open %s", path);
return MPR_ERR_CANT_OPEN;
}
} else {
outFile = mprGetStdout();
}
mprAddRoot(outFile);
while (!conn->tx->finalized && conn->state < HTTP_STATE_COMPLETE && remaining > 0) {
remaining = mprGetRemainingTicks(mark, limits->requestTimeout);
readBody(conn, outFile);
httpWait(conn, 0, remaining);
}
if (conn->state < HTTP_STATE_COMPLETE && !conn->error) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT,
"Inactive request timed out, exceeded request timeout %d", app->timeout);
} else {
readBody(conn, outFile);
}
if (app->outFilename) {
mprCloseFile(outFile);
}
mprRemoveRoot(outFile);
reportResponse(conn, url, mprGetTicks() - mark);
httpDestroyRx(conn->rx);
httpDestroyTx(conn->tx);
return 0;
}
static void closeCgi(HttpQueue *q)
{
Cgi *cgi;
MprCmd *cmd;
mprTrace(5, "CGI: close");
if ((cgi = q->queueData) != 0) {
cmd = cgi->cmd;
if (cmd) {
mprSetCmdCallback(cmd, NULL, NULL);
mprDestroyCmd(cmd);
cgi->cmd = 0;
}
httpMonitorEvent(q->conn, HTTP_COUNTER_ACTIVE_PROCESSES, -1);
}
}
static int scriptAliasDirective(MaState *state, cchar *key, cchar *value)
{
HttpRoute *route;
char *prefix, *path;
if (!maTokenize(state, value, "%S %S", &prefix, &path)) {
return MPR_ERR_BAD_SYNTAX;
}
route = httpCreateAliasRoute(state->route, prefix, path, 0);
httpSetRouteHandler(route, "cgiHandler");
httpSetRoutePattern(route, sfmt("^%s(.*)$", prefix), 0);
httpSetRouteTarget(route, "run", "$1");
httpFinalizeRoute(route);
mprTrace(4, "ScriptAlias \"%s\" for \"%s\"", prefix, path);
return 0;
}
/*
Start a worker thread. This is called by eval() and load(). Not by preload() or by Worker(). It always joins.
*/
static EjsObj *startWorker(Ejs *ejs, EjsWorker *outsideWorker, int timeout)
{
EjsWorker *insideWorker;
Ejs *inside;
EjsString *result;
assert(ejs);
assert(outsideWorker);
assert(!outsideWorker->inside);
assert(outsideWorker->state == EJS_WORKER_BEGIN);
assert(outsideWorker->pair);
assert(outsideWorker->pair->ejs);
mprTrace(5, "Worker.startWorker");
if (outsideWorker->state > EJS_WORKER_BEGIN) {
ejsThrowStateError(ejs, "Worker has already started");
return 0;
}
insideWorker = outsideWorker->pair;
assert(insideWorker->inside);
assert(insideWorker->state == EJS_WORKER_BEGIN);
inside = insideWorker->ejs;
outsideWorker->state = EJS_WORKER_STARTED;
if (mprCreateEvent(inside->dispatcher, "workerMain", 0, (MprEventProc) workerMain, insideWorker, 0) < 0) {
ejsThrowStateError(ejs, "Cannot create worker event");
return 0;
}
if (timeout == 0) {
return ESV(undefined);
}
if (timeout < 0) {
timeout = MAXINT;
}
if (join(ejs, (EjsObj*) outsideWorker, timeout) < 0) {
return ESV(undefined);
}
result = ejsToJSON(inside, inside->result, NULL);
if (result == 0) {
return ESV(null);
}
return ejsDeserialize(ejs, result);
}
/*
Configure the server. If the configFile is defined, use it. If not, then consider home, documents, ip and port.
*/
PUBLIC int maConfigureServer(MaServer *server, cchar *configFile, cchar *home, cchar *documents, cchar *ip, int port)
{
MaAppweb *appweb;
Http *http;
HttpEndpoint *endpoint;
HttpHost *host;
HttpRoute *route;
char *path;
appweb = server->appweb;
http = appweb->http;
if (configFile) {
path = mprGetAbsPath(configFile);
if (maParseConfig(server, path, 0) < 0) {
/* mprError("Cannot configure server using %s", path); */
return MPR_ERR_CANT_INITIALIZE;
}
return 0;
} else {
if ((endpoint = httpCreateConfiguredEndpoint(home, documents, ip, port)) == 0) {
return MPR_ERR_CANT_OPEN;
}
maAddEndpoint(server, endpoint);
host = mprGetFirstItem(endpoint->hosts);
assert(host);
route = mprGetFirstItem(host->routes);
assert(route);
#if BIT_PACK_CGI
maLoadModule(appweb, "cgiHandler", "mod_cgi");
if (httpLookupStage(http, "cgiHandler")) {
httpAddRouteHandler(route, "cgiHandler", "cgi cgi-nph bat cmd pl py");
/*
Add cgi-bin with a route for the /cgi-bin URL prefix.
*/
path = "cgi-bin";
if (mprPathExists(path, X_OK)) {
HttpRoute *cgiRoute;
cgiRoute = httpCreateAliasRoute(route, "/cgi-bin/", path, 0);
mprTrace(4, "ScriptAlias \"/cgi-bin/\":\"%s\"", path);
httpSetRouteHandler(cgiRoute, "cgiHandler");
httpFinalizeRoute(cgiRoute);
}
}
#endif
#if BIT_PACK_ESP
maLoadModule(appweb, "espHandler", "mod_esp");
if (httpLookupStage(http, "espHandler")) {
httpAddRouteHandler(route, "espHandler", "esp");
}
#endif
#if BIT_PACK_EJSCRIPT
maLoadModule(appweb, "ejsHandler", "mod_ejs");
if (httpLookupStage(http, "ejsHandler")) {
httpAddRouteHandler(route, "ejsHandler", "ejs");
}
#endif
#if BIT_PACK_PHP
maLoadModule(appweb, "phpHandler", "mod_php");
if (httpLookupStage(http, "phpHandler")) {
httpAddRouteHandler(route, "phpHandler", "php");
}
#endif
httpAddRouteHandler(route, "fileHandler", "");
httpFinalizeRoute(route);
if (home) {
httpSetRouteHome(route, home);
}
}
return 0;
}
/*
Start the CGI command program. This commences the CGI gateway program. This will be called after content for
form and upload requests (or if "RunHandler" before specified), otherwise it runs before receiving content data.
*/
static void startCgi(HttpQueue *q)
{
HttpRx *rx;
HttpTx *tx;
HttpRoute *route;
HttpConn *conn;
MprCmd *cmd;
Cgi *cgi;
cchar *baseName, **argv, *fileName, **envv;
ssize varCount;
int argc, count;
argv = 0;
argc = 0;
cgi = q->queueData;
conn = q->conn;
rx = conn->rx;
route = rx->route;
tx = conn->tx;
mprTrace(5, "CGI: Start");
/*
The command uses the conn dispatcher. This serializes all I/O for both the connection and the CGI gateway.
*/
if ((cmd = mprCreateCmd(conn->dispatcher)) == 0) {
return;
}
cgi->cmd = cmd;
if (conn->http->forkCallback) {
cmd->forkCallback = conn->http->forkCallback;
cmd->forkData = conn->http->forkData;
}
argc = 1; /* argv[0] == programName */
buildArgs(conn, cmd, &argc, &argv);
fileName = argv[0];
baseName = mprGetPathBase(fileName);
/*
nph prefix means non-parsed-header. Don't parse the CGI output for a CGI header
*/
if (strncmp(baseName, "nph-", 4) == 0 ||
(strlen(baseName) > 4 && strcmp(&baseName[strlen(baseName) - 4], "-nph") == 0)) {
/* Pretend we've seen the header for Non-parsed Header CGI programs */
cgi->seenHeader = 1;
tx->flags |= HTTP_TX_USE_OWN_HEADERS;
}
/*
Build environment variables
*/
varCount = mprGetHashLength(rx->headers) + mprGetHashLength(rx->svars) + mprGetJsonLength(rx->params);
if ((envv = mprAlloc((varCount + 1) * sizeof(char*))) != 0) {
count = copyParams(conn, envv, 0, rx->params, route->envPrefix);
count = copyVars(conn, envv, count, rx->svars, "");
count = copyVars(conn, envv, count, rx->headers, "HTTP_");
assert(count <= varCount);
}
#if !VXWORKS
/*
This will be ignored on VxWorks because there is only one global current directory for all tasks
*/
mprSetCmdDir(cmd, mprGetPathDir(fileName));
#endif
mprSetCmdCallback(cmd, cgiCallback, cgi);
if (mprStartCmd(cmd, argc, argv, envv, MPR_CMD_IN | MPR_CMD_OUT | MPR_CMD_ERR) < 0) {
httpError(conn, HTTP_CODE_NOT_FOUND, "Cannot run CGI process: %s, URI %s", fileName, rx->uri);
return;
}
#if ME_WIN_LIKE
mprCreateEvent(conn->dispatcher, "cgi-win", 10, waitForCgi, cgi, MPR_EVENT_CONTINUOUS);
#endif
}
static void readFromCgi(Cgi *cgi, int channel)
{
HttpConn *conn;
HttpPacket *packet;
HttpTx *tx;
HttpQueue *q, *writeq;
MprCmd *cmd;
ssize nbytes;
int err;
cmd = cgi->cmd;
conn = cgi->conn;
tx = conn->tx;
q = cgi->readq;
writeq = conn->writeq;
assert(conn->sock);
assert(conn->state > HTTP_STATE_BEGIN);
if (tx->finalized) {
mprCloseCmdFd(cmd, channel);
}
while (mprGetCmdFd(cmd, channel) >= 0 && !tx->finalized && writeq->count < writeq->max) {
if ((packet = cgi->headers) != 0) {
if (mprGetBufSpace(packet->content) < ME_MAX_BUFFER && mprGrowBuf(packet->content, ME_MAX_BUFFER) < 0) {
break;
}
} else if ((packet = httpCreateDataPacket(ME_MAX_BUFFER)) == 0) {
break;
}
nbytes = mprReadCmd(cmd, channel, mprGetBufEnd(packet->content), ME_MAX_BUFFER);
if (nbytes < 0) {
err = mprGetError();
if (err == EINTR) {
continue;
} else if (err == EAGAIN || err == EWOULDBLOCK) {
break;
}
mprTrace(6, "CGI: Gateway read error %d for %s", err, (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr");
mprCloseCmdFd(cmd, channel);
break;
} else if (nbytes == 0) {
mprTrace(6, "CGI: Gateway EOF for %s, pid %d", (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr", cmd->pid);
mprCloseCmdFd(cmd, channel);
break;
} else {
mprTrace(6, "CGI: Gateway read %d bytes from %s", nbytes, (channel == MPR_CMD_STDOUT) ? "stdout" : "stderr");
traceData(cmd, mprGetBufEnd(packet->content), nbytes);
mprAdjustBufEnd(packet->content, nbytes);
}
if (channel == MPR_CMD_STDERR) {
// FUTURE - should be an option to keep going despite stderr output
mprError("CGI: Error for \"%s\"\n\n%s", conn->rx->uri, mprGetBufStart(packet->content));
httpSetStatus(conn, HTTP_CODE_SERVICE_UNAVAILABLE);
cgi->seenHeader = 1;
}
if (!cgi->seenHeader) {
if (!parseCgiHeaders(cgi, packet)) {
cgi->headers = packet;
return;
}
cgi->headers = 0;
cgi->seenHeader = 1;
}
if (!tx->finalizedOutput && httpGetPacketLength(packet) > 0) {
/* Put the data to the CGI readq, then cgiToBrowserService will take care of it */
httpPutPacket(q, packet);
}
}
}
/*
Parse the CGI output headers. Sample CGI program output:
Content-type: text/html
<html.....
*/
static bool parseCgiHeaders(Cgi *cgi, HttpPacket *packet)
{
HttpConn *conn;
MprBuf *buf;
char *endHeaders, *headers, *key, *value, *junk;
ssize blen;
int len;
conn = cgi->conn;
value = 0;
buf = packet->content;
headers = mprGetBufStart(buf);
blen = mprGetBufLength(buf);
/*
Split the headers from the body. Add null to ensure we can search for line terminators.
*/
len = 0;
if ((endHeaders = sncontains(headers, "\r\n\r\n", blen)) == NULL) {
if ((endHeaders = sncontains(headers, "\n\n", blen)) == NULL) {
if (mprGetCmdFd(cgi->cmd, MPR_CMD_STDOUT) >= 0 && strlen(headers) < ME_MAX_HEADERS) {
/* Not EOF and less than max headers and have not yet seen an end of headers delimiter */
return 0;
}
}
len = 2;
} else {
len = 4;
}
if (endHeaders > buf->end) {
assert(endHeaders <= buf->end);
return 0;
}
if (endHeaders) {
endHeaders[len - 1] = '\0';
endHeaders += len;
}
/*
Want to be tolerant of CGI programs that omit the status line.
*/
if (strncmp((char*) buf->start, "HTTP/1.", 7) == 0) {
if (!parseFirstCgiResponse(cgi, packet)) {
/* httpError already called */
return 0;
}
}
if (endHeaders && strchr(mprGetBufStart(buf), ':')) {
while (mprGetBufLength(buf) > 0 && buf->start[0] && (buf->start[0] != '\r' && buf->start[0] != '\n')) {
if ((key = getCgiToken(buf, ":")) == 0) {
key = "Bad Header";
}
value = getCgiToken(buf, "\n");
while (isspace((uchar) *value)) {
value++;
}
mprTrace(4, "CGI: parseCgiHeader: key %s = %s", key, value);
len = (int) strlen(value);
while (len > 0 && (value[len - 1] == '\r' || value[len - 1] == '\n')) {
value[len - 1] = '\0';
len--;
}
key = slower(key);
if (strcmp(key, "location") == 0) {
cgi->location = value;
} else if (strcmp(key, "status") == 0) {
httpSetStatus(conn, atoi(value));
} else if (strcmp(key, "content-type") == 0) {
httpSetHeaderString(conn, "Content-Type", value);
} else if (strcmp(key, "content-length") == 0) {
httpSetContentLength(conn, (MprOff) stoi(value));
httpSetChunkSize(conn, 0);
} else {
/*
Now pass all other headers back to the client
*/
key = stok(key, ":\r\n\t ", &junk);
httpSetHeaderString(conn, key, value);
}
}
buf->start = endHeaders;
}
return 1;
}
static int issueRequest(HttpConn *conn, cchar *url, MprList *files)
{
HttpRx *rx;
HttpUri *target, *location;
char *redirect;
cchar *msg, *sep, *authType;
int count, redirectCount, rc;
httpSetRetries(conn, app->retries);
httpSetTimeout(conn, app->timeout, app->timeout);
authType = conn->authType;
for (redirectCount = count = 0; count <= conn->retries && redirectCount < 10 && !mprShouldAbortRequests(conn); count++) {
if (prepRequest(conn, files, count) < 0) {
return MPR_ERR_CANT_OPEN;
}
if (sendRequest(conn, app->method, url, files) < 0) {
return MPR_ERR_CANT_WRITE;
}
if ((rc = httpWait(conn, HTTP_STATE_PARSED, conn->limits->requestTimeout)) == 0) {
if (httpNeedRetry(conn, &redirect)) {
if (redirect) {
location = httpCreateUri(redirect, 0);
target = httpJoinUri(conn->tx->parsedUri, 1, &location);
url = httpUriToString(target, HTTP_COMPLETE_URI);
count = 0;
}
if (conn->rx && conn->rx->status == HTTP_CODE_UNAUTHORIZED && authType) {
/* Supplied authentication details and failed */
break;
}
redirectCount++;
count--;
} else {
break;
}
} else if (!conn->error) {
if (rc == MPR_ERR_TIMEOUT) {
httpError(conn, HTTP_ABORT | HTTP_CODE_REQUEST_TIMEOUT,
"Inactive request timed out, exceeded request timeout %d", app->timeout);
} else {
httpError(conn, HTTP_ABORT | HTTP_CODE_COMMS_ERROR, "Connection I/O error");
}
}
if ((rx = conn->rx) != 0) {
if (rx->status == HTTP_CODE_REQUEST_TOO_LARGE || rx->status == HTTP_CODE_REQUEST_URL_TOO_LARGE ||
(rx->status == HTTP_CODE_UNAUTHORIZED && conn->username == 0)) {
/* No point retrying */
break;
}
}
mprTrace(4, "retry %d of %d for: %s %s", count, conn->retries, app->method, url);
}
if (conn->error) {
msg = (conn->errorMsg) ? conn->errorMsg : "";
sep = (msg && *msg) ? "\n" : "";
mprError("http: failed \"%s\" request for %s after %d attempt(s).%s%s", app->method, url, count, sep, msg);
return MPR_ERR_CANT_CONNECT;
}
return 0;
}
/*
Write a block of data. This is the lowest level write routine for data. This will buffer the data and flush if
the queue buffer is full. Flushing is done by calling httpFlushQueue which will service queues as required. This
may call the queue outgoing service routine and disable downstream queues if they are overfull.
This routine will always accept the data and never return "short".
*/
PUBLIC ssize httpWriteBlock(HttpQueue *q, cchar *buf, ssize len, int flags)
{
HttpPacket *packet;
HttpConn *conn;
HttpTx *tx;
ssize totalWritten, packetSize, thisWrite;
assert(q == q->conn->writeq);
conn = q->conn;
tx = conn->tx;
if (flags == 0) {
flags = HTTP_BUFFER;
}
if (tx == 0 || tx->finalizedOutput) {
return MPR_ERR_CANT_WRITE;
}
tx->responded = 1;
for (totalWritten = 0; len > 0; ) {
mprTrace(7, "httpWriteBlock q_count %d, q_max %d", q->count, q->max);
if (conn->state >= HTTP_STATE_FINALIZED) {
return MPR_ERR_CANT_WRITE;
}
if (q->last && q->last != q->first && q->last->flags & HTTP_PACKET_DATA && mprGetBufSpace(q->last->content) > 0) {
packet = q->last;
} else {
packetSize = (tx->chunkSize > 0) ? tx->chunkSize : q->packetSize;
if ((packet = httpCreateDataPacket(packetSize)) == 0) {
return MPR_ERR_MEMORY;
}
httpPutForService(q, packet, HTTP_DELAY_SERVICE);
}
assert(mprGetBufSpace(packet->content) > 0);
thisWrite = min(len, mprGetBufSpace(packet->content));
if (flags & (HTTP_BLOCK | HTTP_NON_BLOCK)) {
thisWrite = min(thisWrite, q->max - q->count);
}
if (thisWrite > 0) {
if ((thisWrite = mprPutBlockToBuf(packet->content, buf, thisWrite)) == 0) {
return MPR_ERR_MEMORY;
}
buf += thisWrite;
len -= thisWrite;
q->count += thisWrite;
totalWritten += thisWrite;
}
if (q->count >= q->max) {
httpFlushQueue(q, 0);
if (q->count >= q->max) {
if (flags & HTTP_NON_BLOCK) {
break;
} else if (flags & HTTP_BLOCK) {
while (q->count >= q->max && !tx->finalized) {
if (!mprWaitForSingleIO((int) conn->sock->fd, MPR_WRITABLE, conn->limits->inactivityTimeout)) {
return MPR_ERR_TIMEOUT;
}
httpResumeQueue(conn->connectorq);
httpServiceQueues(conn);
}
}
}
}
}
if (conn->error) {
return MPR_ERR_CANT_WRITE;
}
return totalWritten;
}
/*
Parse the client 'Authorization' header and the server 'Www-Authenticate' header
*/
PUBLIC int httpDigestParse(HttpConn *conn, cchar **username, cchar **password)
{
HttpRx *rx;
DigestData *dp;
MprTime when;
char *value, *tok, *key, *cp, *sp;
cchar *secret, *realm;
int seenComma;
rx = conn->rx;
if (password) {
*password = NULL;
}
if (username) {
*username = NULL;
}
if (!rx->authDetails) {
return 0;
}
dp = conn->authData = mprAllocObj(DigestData, manageDigestData);
key = sclone(rx->authDetails);
while (*key) {
while (*key && isspace((uchar) *key)) {
key++;
}
tok = key;
while (*tok && !isspace((uchar) *tok) && *tok != ',' && *tok != '=') {
tok++;
}
*tok++ = '\0';
while (isspace((uchar) *tok)) {
tok++;
}
seenComma = 0;
if (*tok == '\"') {
value = ++tok;
while (*tok != '\"' && *tok != '\0') {
tok++;
}
} else {
value = tok;
while (*tok != ',' && *tok != '\0') {
tok++;
}
seenComma++;
}
*tok++ = '\0';
/*
Handle back-quoting
*/
if (strchr(value, '\\')) {
for (cp = sp = value; *sp; sp++) {
if (*sp == '\\') {
sp++;
}
*cp++ = *sp++;
}
*cp = '\0';
}
/*
user, response, oqaque, uri, realm, nonce, nc, cnonce, qop
*/
switch (tolower((uchar) *key)) {
case 'a':
if (scaselesscmp(key, "algorithm") == 0) {
dp->algorithm = sclone(value);
break;
} else if (scaselesscmp(key, "auth-param") == 0) {
break;
}
break;
case 'c':
if (scaselesscmp(key, "cnonce") == 0) {
dp->cnonce = sclone(value);
}
break;
case 'd':
if (scaselesscmp(key, "domain") == 0) {
dp->domain = sclone(value);
break;
}
break;
case 'n':
if (scaselesscmp(key, "nc") == 0) {
dp->nc = sclone(value);
} else if (scaselesscmp(key, "nonce") == 0) {
dp->nonce = sclone(value);
}
break;
case 'o':
if (scaselesscmp(key, "opaque") == 0) {
dp->opaque = sclone(value);
}
break;
case 'q':
if (scaselesscmp(key, "qop") == 0) {
dp->qop = sclone(value);
}
break;
case 'r':
if (scaselesscmp(key, "realm") == 0) {
dp->realm = sclone(value);
} else if (scaselesscmp(key, "response") == 0) {
/* Store the response digest in the password field. This is MD5(user:realm:password) */
if (password) {
*password = sclone(value);
}
conn->encoded = 1;
}
break;
case 's':
if (scaselesscmp(key, "stale") == 0) {
break;
}
case 'u':
if (scaselesscmp(key, "uri") == 0) {
dp->uri = sclone(value);
} else if (scaselesscmp(key, "username") == 0 || scaselesscmp(key, "user") == 0) {
if (username) {
*username = sclone(value);
}
}
break;
default:
/* Just ignore keywords we don't understand */
;
}
key = tok;
if (!seenComma) {
while (*key && *key != ',') {
key++;
}
if (*key) {
key++;
}
}
}
if (username && *username == 0) {
return MPR_ERR_BAD_FORMAT;
}
if (password && *password == 0) {
return MPR_ERR_BAD_FORMAT;
}
if (dp->realm == 0 || dp->nonce == 0 || dp->uri == 0) {
return MPR_ERR_BAD_FORMAT;
}
if (dp->qop && (dp->cnonce == 0 || dp->nc == 0)) {
return MPR_ERR_BAD_FORMAT;
}
if (conn->endpoint) {
realm = secret = 0;
when = 0;
parseDigestNonce(dp->nonce, &secret, &realm, &when);
if (!smatch(secret, secret)) {
mprTrace(2, "Access denied: Nonce mismatch\n");
return MPR_ERR_BAD_STATE;
} else if (!smatch(realm, rx->route->auth->realm)) {
mprTrace(2, "Access denied: Realm mismatch\n");
return MPR_ERR_BAD_STATE;
} else if (dp->qop && !smatch(dp->qop, "auth")) {
mprTrace(2, "Access denied: Bad qop\n");
return MPR_ERR_BAD_STATE;
} else if ((when + (5 * 60)) < time(0)) {
mprTrace(2, "Access denied: Nonce is stale\n");
return MPR_ERR_BAD_STATE;
}
rx->passwordDigest = calcDigest(conn, dp, *username);
} else {
if (dp->domain == 0 || dp->opaque == 0 || dp->algorithm == 0 || dp->stale == 0) {
return MPR_ERR_BAD_FORMAT;
}
}
return 0;
}
/*
Build the command arguments. NOTE: argv is untrusted input.
*/
static void buildArgs(HttpConn *conn, MprCmd *cmd, int *argcp, cchar ***argvp)
{
HttpRx *rx;
HttpTx *tx;
char **argv;
char *indexQuery, *cp, *tok;
cchar *actionProgram, *fileName;
size_t len;
int argc, argind, i;
rx = conn->rx;
tx = conn->tx;
fileName = tx->filename;
assert(fileName);
actionProgram = 0;
argind = 0;
argc = *argcp;
if (tx->ext) {
actionProgram = mprGetMimeProgram(rx->route->mimeTypes, tx->ext);
if (actionProgram != 0) {
argc++;
}
/*
This is an Apache compatible hack for PHP 5.3
*/
mprAddKey(rx->headers, "REDIRECT_STATUS", itos(HTTP_CODE_MOVED_TEMPORARILY));
}
/*
Count the args for ISINDEX queries. Only valid if there is not a "=" in the query.
If this is so, then we must not have these args in the query env also?
*/
indexQuery = rx->parsedUri->query;
if (indexQuery && !strchr(indexQuery, '=')) {
argc++;
for (cp = indexQuery; *cp; cp++) {
if (*cp == '+') {
argc++;
}
}
} else {
indexQuery = 0;
}
#if ME_WIN_LIKE || VXWORKS
{
char *bangScript, *cmdBuf, *program, *cmdScript;
/*
On windows we attempt to find an executable matching the fileName.
We look for *.exe, *.bat and also do unix style processing "#!/program"
*/
findExecutable(conn, &program, &cmdScript, &bangScript, fileName);
assert(program);
if (cmdScript) {
/*
Cmd/Batch script (.bat | .cmd)
Convert the command to the form where there are 4 elements in argv
that cmd.exe can interpret.
argv[0] = cmd.exe
argv[1] = /Q
argv[2] = /C
argv[3] = ""script" args ..."
*/
argc = 4;
len = (argc + 1) * sizeof(char*);
argv = (char**) mprAlloc(len);
memset(argv, 0, len);
argv[argind++] = program; /* Duped in findExecutable */
argv[argind++] = "/Q";
argv[argind++] = "/C";
len = strlen(cmdScript) + 2 + 1;
cmdBuf = mprAlloc(len);
fmt(cmdBuf, len, "\"%s\"", cmdScript);
argv[argind++] = cmdBuf;
mprSetCmdDir(cmd, cmdScript);
/* program will get freed when argv[] gets freed */
} else if (bangScript) {
/*
Script used "#!/program". NOTE: this may be overridden by a mime Action directive.
*/
argc++; /* Adding bangScript arg */
len = (argc + 1) * sizeof(char*);
argv = (char**) mprAlloc(len);
memset(argv, 0, len);
argv[argind++] = program; /* Will get freed when argv[] is freed */
argv[argind++] = bangScript; /* Will get freed when argv[] is freed */
mprSetCmdDir(cmd, bangScript);
} else {
/*
Either unknown extension or .exe (.out) program.
*/
len = (argc + 1) * sizeof(char*);
argv = (char**) mprAlloc(len);
memset(argv, 0, len);
if (actionProgram) {
argv[argind++] = sclone(actionProgram);
}
argv[argind++] = program;
}
}
#else
len = (argc + 1) * sizeof(char*);
argv = mprAlloc(len);
memset(argv, 0, len);
if (actionProgram) {
argv[argind++] = sclone(actionProgram);
}
// OPT - why clone all these string?
argv[argind++] = sclone(fileName);
#endif
/*
ISINDEX queries. Only valid if there is not a "=" in the query. If this is so, then we must not
have these args in the query env also?
FUTURE - should query vars be set in the env?
*/
if (indexQuery) {
indexQuery = sclone(indexQuery);
cp = stok(indexQuery, "+", &tok);
while (cp) {
argv[argind++] = mprEscapeCmd(mprUriDecode(cp), 0);
cp = stok(NULL, "+", &tok);
}
}
assert(argind <= argc);
argv[argind] = 0;
*argcp = argc;
*argvp = (cchar**) argv;
mprTrace(5, "CGI: command:");
for (i = 0; i < argind; i++) {
mprTrace(5, " argv[%d] = %s", i, argv[i]);
}
}
/*
Process a message sent from postMessage. This may run inside the worker or outside in the parent depending on the
direction of the message. But it ALWAYS runs in the appropriate thread for the interpreter.
*/
static int doMessage(Message *msg, MprEvent *mprEvent)
{
Ejs *ejs;
EjsObj *event, *frame;
EjsWorker *worker;
EjsFunction *callback;
EjsObj *argv[1];
worker = msg->worker;
worker->gotMessage = 1;
ejs = worker->ejs;
assert(!ejs->exception);
event = 0;
ejsBlockGC(ejs);
callback = ejsGetProperty(ejs, worker, msg->callbackSlot);
switch (msg->callbackSlot) {
case ES_Worker_onerror:
event = ejsCreateObj(ejs, ESV(ErrorEvent), 0);
break;
case ES_Worker_onclose:
case ES_Worker_onmessage:
event = ejsCreateObj(ejs, ESV(Event), 0);
break;
default:
assert(msg->callbackSlot == 0);
return 0;
}
worker->event = event;
if (msg->data) {
ejsSetProperty(ejs, event, ES_Event_data, ejsCreateStringFromAsc(ejs, msg->data));
}
if (msg->message) {
ejsSetProperty(ejs, event, ES_ErrorEvent_message, msg->message);
}
if (msg->stack) {
ejsSetProperty(ejs, event, ES_ErrorEvent_stack, msg->stack);
if ((frame = ejsGetProperty(ejs, msg->stack, 0)) != 0 && !ejsIs(ejs, frame, Void)) {
ejsSetProperty(ejs, event, ES_ErrorEvent_filename, ejsGetPropertyByName(ejs, frame, EN("filename")));
ejsSetProperty(ejs, event, ES_ErrorEvent_lineno, ejsGetPropertyByName(ejs, frame, EN("lineno")));
}
}
assert(!ejs->exception);
if (callback == 0 || ejsIs(ejs, callback, Null)) {
if (msg->callbackSlot == ES_Worker_onmessage) {
mprTrace(6, "Discard message as no onmessage handler defined for worker");
} else if (msg->callbackSlot == ES_Worker_onerror) {
if (ejsIs(ejs, msg->message, String)) {
ejsThrowError(ejs, "Exception in Worker: %@", ejsToString(ejs, msg->message));
} else {
ejsThrowError(ejs, "Exception in Worker: %s", ejsGetErrorMsg(worker->pair->ejs, 1));
}
} else {
/* Ignore onclose message */
}
} else if (!ejsIsFunction(ejs, callback)) {
ejsThrowTypeError(ejs, "Worker callback %s is not a function", msg->callback);
} else {
assert(!ejs->exception);
argv[0] = event;
ejsRunFunction(ejs, callback, worker, 1, argv);
}
if (msg->callbackSlot == ES_Worker_onclose) {
assert(!worker->inside);
worker->state = EJS_WORKER_COMPLETE;
mprTrace(5, "Worker.doMessage: complete");
/* Worker and insider interpreter are now eligible for garbage collection */
removeWorker(worker);
}
mprSignalDispatcher(ejs->dispatcher);
worker->event = 0;
return 0;
}
PUBLIC void httpSuspendQueue(HttpQueue *q)
{
mprTrace(7, "Suspend q %s", q->name);
q->flags |= HTTP_QUEUE_SUSPENDED;
}
PUBLIC void httpResumeQueue(HttpQueue *q)
{
mprTrace(7, "Resume q %s", q->name);
q->flags &= ~HTTP_QUEUE_SUSPENDED;
httpScheduleQueue(q);
}
/*
Connection callback
*/
static void webSocketNotify(HttpConn *conn, int event, int arg)
{
Ejs *ejs;
EjsWebSocket *ws;
EjsByteArray *ba;
EjsAny *data;
HttpPacket *packet;
MprBuf *content;
ssize len;
if ((ws = httpGetConnContext(conn)) == 0) {
return;
}
ejs = ws->ejs;
if (!ejs->service) {
/* Shutting down */
return;
}
switch (event) {
case HTTP_EVENT_STATE:
if (arg == HTTP_STATE_CONTENT) {
ws->protocol = (char*) httpGetHeader(conn, "Sec-WebSocket-Protocol");
mprTrace(3, "Web socket protocol %s", ws->protocol);
onWebSocketEvent(ws, HTTP_EVENT_APP_OPEN, 0, 0);
}
break;
case HTTP_EVENT_READABLE:
packet = httpGetPacket(conn->readq);
content = packet->content;
if (packet->type == WS_MSG_TEXT) {
data = ejsCreateStringFromBytes(ejs, mprGetBufStart(content), mprGetBufLength(content));
} else {
len = httpGetPacketLength(packet);
assert(len > 0);
if ((ba = ejsCreateByteArray(ejs, len)) == 0) {
return;
}
memcpy(ba->value, mprGetBufStart(content), len);
ejsSetByteArrayPositions(ejs, ba, -1, len);
data = ba;
}
onWebSocketEvent(ws, event, data, packet);
break;
case HTTP_EVENT_ERROR:
if (!ws->error && !ws->closed) {
ws->error = 1;
onWebSocketEvent(ws, event, 0, 0);
ws->closed = 1;
onWebSocketEvent(ws, HTTP_EVENT_APP_CLOSE, 0, 0);
}
break;
case HTTP_EVENT_APP_CLOSE:
if (!ws->closed) {
ws->closed = 1;
onWebSocketEvent(ws, event, 0, 0);
}
break;
}
}
/*
Set a property by name
There are 7 kinds of qname's: prop, @att, [prop], *, @*, .name, .@name
*/
static int setXmlPropertyByName(Ejs *ejs, EjsXML *xml, EjsName qname, EjsObj *value)
{
EjsXML *elt, *xvalue, *rp, *lastElt;
EjsObj *originalValue;
int index, last;
last = 0;
lastElt = 0;
mprTrace(9, "XMLSet %@.%@ = \"%@\"", xml->qname.name, qname.name, ejsCast(ejs, value, String));
if (isdigit((uchar) qname.name->value[0]) && allDigitsForXml(qname.name)) {
ejsThrowTypeError(ejs, "Integer indicies for set are not allowed");
return EJS_ERR;
}
if (xml->kind != EJS_XML_ELEMENT) {
// TODO spec requires this -- but why? -- surely throw?
return 0;
}
/*
Massage the value type.
*/
originalValue = value;
xvalue = (EjsXML*) value;
if (ejsIsXML(ejs, xvalue)) {
if (xvalue->kind == EJS_XML_LIST) {
value = cloneXml(ejs, xvalue, 1);
} else if (xvalue->kind == EJS_XML_TEXT || xvalue->kind == EJS_XML_ATTRIBUTE) {
value = ejsCast(ejs, originalValue, String);
} else {
value = cloneXml(ejs, xvalue, 1);
}
} else {
value = ejsCast(ejs, value, String);
}
if (qname.name->value[0] == '@') {
return setXmlPropertyAttributeByName(ejs, xml, qname, value);
}
/*
Delete redundant elements by the same name.
*/
if (xml->elements) {
for (last = -1, index = -1; (elt = mprGetPrevItem(xml->elements, &index)) != 0; ) {
if (qname.name->value[0] == '*' || (elt->kind == EJS_XML_ELEMENT && elt->qname.name == qname.name)) {
/*
Must remove all redundant elements of the same name except the first one
*/
if (last >= 0) {
rp = mprGetItem(xml->elements, last);
rp->parent = 0;
mprRemoveItemAtPos(xml->elements, last);
}
last = index;
lastElt = elt;
}
}
}
if (xml->elements == 0) {
// TODO - need routine to do this centrally so we can control the default number of elements in the list?
xml->elements = mprCreateList(-1, 0);
}
elt = lastElt;
index = last;
if (qname.name->value[0] == '*') {
/*
Special case when called from XMLList to update the value of an element
*/
xml = createValueNode(ejs, xml, value);
} else if (elt == 0) {
/*
Not found. New node required.
*/
elt = ejsCreateXML(ejs, EJS_XML_ELEMENT, qname, xml, NULL);
if (elt == 0) {
return 0;
}
index = mprGetListLength(xml->elements);
xml = ejsAppendToXML(ejs, xml, createValueNode(ejs, elt, value));
} else {
/*
Update existing element.
*/
xml = ejsSetXMLElement(ejs, xml, index, createValueNode(ejs, elt, value));
}
if (xml == 0) {
return EJS_ERR;
}
return index;
}
