int mprPuts(MprFile *file, const char *writeBuf, uint count)
{
MprBuf *bp;
char *buf;
int total, bytes, len;
mprAssert(file);
/*
* Buffer output and flush when full.
*/
if (file->buf == 0) {
file->buf = mprCreateBuf(file, MPR_BUFSIZE, 0);
if (file->buf == 0) {
return MPR_ERR_CANT_ALLOCATE;
}
}
bp = file->buf;
if (mprGetBufLength(bp) > 0 && mprGetBufSpace(bp) < (int) count) {
len = mprGetBufLength(bp);
if (mprWrite(file, mprGetBufStart(bp), len) != len) {
return MPR_ERR_CANT_WRITE;
}
mprFlushBuf(bp);
}
total = 0;
buf = (char*) writeBuf;
while (count > 0) {
bytes = mprPutBlockToBuf(bp, buf, count);
if (bytes <= 0) {
return MPR_ERR_CANT_ALLOCATE;
}
count -= bytes;
buf += bytes;
total += bytes;
mprAddNullToBuf(bp);
if (count > 0) {
len = mprGetBufLength(bp);
if (mprWrite(file, mprGetBufStart(bp), len) != len) {
return MPR_ERR_CANT_WRITE;
}
mprFlushBuf(bp);
}
}
return total;
}
/*
* Remove all data from non-header packets in the queue. Don't worry about freeing. Will happen automatically at
* the request end. See also maCleanQueue above.
*/
void maDiscardData(MaQueue *q, bool removePackets)
{
MaPacket *packet;
int len;
if (q->first) {
/*
* Skip the header packet
*/
if (q->first->flags & MA_PACKET_HEADER) {
packet = q->first->next;
} else {
packet = q->first;
}
/*
* Just flush each packet. Don't remove so the EOF packet is preserved
*/
for (; packet; packet = packet->next) {
if (packet->content) {
len = maGetPacketLength(packet);
q->conn->response->length -= len;
q->count -= len;
mprFlushBuf(packet->content);
}
}
maCheckQueueCount(q);
}
}
PUBLIC int mprFlushFile(MprFile *file)
{
MprFileSystem *fs;
MprBuf *bp;
ssize len, rc;
assert(file);
if (file == 0) {
return MPR_ERR_BAD_HANDLE;
}
if (file->buf == 0) {
return 0;
}
if (file->mode & (O_WRONLY | O_RDWR)) {
fs = file->fileSystem;
bp = file->buf;
while (mprGetBufLength(bp) > 0) {
len = mprGetBufLength(bp);
rc = fs->writeFile(file, mprGetBufStart(bp), len);
if (rc < 0) {
return (int) rc;
}
mprAdjustBufStart(bp, rc);
}
mprFlushBuf(bp);
}
return 0;
}
/*
function form(uri: String = null, formData: Object = null): Http
Issue a POST method with form data
*/
static EjsHttp *http_form(Ejs *ejs, EjsHttp *hp, int argc, EjsObj **argv)
{
EjsObj *data;
if (argc == 2 && !ejsIs(ejs, argv[1], Null)) {
/*
Prep here to reset the state. The ensures the current headers will be preserved.
Users may have called setHeader to define custom headers. Users must call reset if they want to clear
prior headers.
*/
httpPrepClientConn(hp->conn, 1);
mprFlushBuf(hp->requestContent);
data = argv[1];
if (ejsGetLength(ejs, data) > 0) {
prepForm(ejs, hp, NULL, data);
} else {
mprPutStringToBuf(hp->requestContent, ejsToMulti(ejs, data));
}
mprAddNullToBuf(hp->requestContent);
httpSetHeader(hp->conn, "Content-Type", "application/x-www-form-urlencoded");
/* Ensure this gets recomputed */
httpRemoveHeader(hp->conn, "Content-Length");
}
return startHttpRequest(ejs, hp, "POST", argc, argv);
}
void mprCompactBuf(MprBuf *bp)
{
if (mprGetBufLength(bp) == 0) {
mprFlushBuf(bp);
return;
}
if (bp->start > bp->data) {
memmove(bp->data, bp->start, (bp->end - bp->start));
bp->end -= (bp->start - bp->data);
bp->start = bp->data;
}
}
/*
* Flush all output and emit headers first if required
*/
static void flushOutput(MprBuf *buf)
{
int rc, len;
if (!headersEmitted && buf != headerOutput) {
emitHeaders();
}
while ((len = mprGetBufLength(buf)) > 0) {
rc = (int) write(1, mprGetBufStart(buf), len);
if (rc < 0) {
return;
}
mprAdjustBufStart(buf, rc);
}
mprFlushBuf(buf);
}
/*
Fill the read buffer. Return the new buffer length. Only called when the buffer is empty.
*/
static ssize fillBuf(MprFile *file)
{
MprFileSystem *fs;
MprBuf *bp;
ssize len;
bp = file->buf;
fs = file->fileSystem;
assert(mprGetBufLength(bp) == 0);
mprFlushBuf(bp);
len = fs->readFile(file, mprGetBufStart(bp), mprGetBufSpace(bp));
if (len <= 0) {
return len;
}
mprAdjustBufEnd(bp, len);
return len;
}
PUBLIC MprOff mprSeekFile(MprFile *file, int seekType, MprOff pos)
{
MprFileSystem *fs;
assert(file);
fs = file->fileSystem;
if (file->buf) {
if (! (seekType == SEEK_CUR && pos == 0)) {
/*
Discard buffering as we may be seeking outside the buffer.
OPT. Could be smarter about this and preserve the buffer.
*/
if (file->mode & (O_WRONLY | O_RDWR)) {
if (mprFlushFile(file) < 0) {
return MPR_ERR_CANT_WRITE;
}
}
if (file->buf) {
mprFlushBuf(file->buf);
}
}
}
if (seekType == SEEK_SET) {
file->pos = pos;
} else if (seekType == SEEK_CUR) {
file->pos += pos;
} else {
file->pos = fs->seekFile(file, SEEK_END, 0);
}
if (fs->seekFile(file, SEEK_SET, file->pos) != file->pos) {
return MPR_ERR;
}
if (file->mode & (O_WRONLY | O_RDWR)) {
if (file->pos > file->size) {
file->size = file->pos;
}
}
return file->pos;
}
char *mprGets(MprFile *file, char *buf, uint size)
{
MprBuf *bp;
int count, len, c;
mprAssert(file);
if (file == 0) {
return 0;
}
if (file->buf == 0) {
file->buf = mprCreateBuf(file, MPR_DEFAULT_ALLOC, MPR_MAX_STRING);
}
bp = file->buf;
/*
* Must leave room for null
*/
count = 0;
while (--size > 0) {
if (mprGetBufLength(bp) == 0) {
mprFlushBuf(bp);
len = mprRead(file, mprGetBufEnd(bp),
mprGetBufLinearSpace(bp));
if (len <= 0) {
return 0;
}
mprAdjustBufEnd(bp, len);
mprAddNullToBuf(bp);
}
if ((c = mprGetCharFromBuf(bp)) == '\n') {
buf[count] = '\0';
return buf;
}
buf[count++] = c;
}
buf[count] = '\0';
return buf;
}
/*
Get another character. We read and buffer blocks of data if we need more data to parse.
*/
static int getNextChar(MprXml *xp)
{
MprBuf *inBuf;
ssize l;
int c;
inBuf = xp->inBuf;
if (mprGetBufLength(inBuf) <= 0) {
/*
Flush to reset the servp/endp pointers to the start of the buffer so we can do a maximal read
*/
mprFlushBuf(inBuf);
l = (xp->readFn)(xp, xp->inputArg, mprGetBufStart(inBuf), mprGetBufSpace(inBuf));
if (l <= 0) {
return -1;
}
mprAdjustBufEnd(inBuf, l);
}
c = mprGetCharFromBuf(inBuf);
if (c == '\n') {
xp->lineNumber++;
}
return c;
}
/*
Remove all data in the queue. If removePackets is true, actually remove the packet too.
This preserves the header and EOT packets.
*/
PUBLIC void httpDiscardQueueData(HttpQueue *q, bool removePackets)
{
HttpPacket *packet, *prev, *next;
ssize len;
if (q == 0) {
return;
}
for (prev = 0, packet = q->first; packet; packet = next) {
next = packet->next;
if (packet->flags & (HTTP_PACKET_RANGE | HTTP_PACKET_DATA)) {
if (removePackets) {
if (prev) {
prev->next = next;
} else {
q->first = next;
}
if (packet == q->last) {
q->last = prev;
}
q->count -= httpGetPacketLength(packet);
assert(q->count >= 0);
continue;
} else {
len = httpGetPacketLength(packet);
q->conn->tx->length -= len;
q->count -= len;
assert(q->count >= 0);
if (packet->content) {
mprFlushBuf(packet->content);
}
}
}
prev = packet;
}
}
/*
This will be enabled when caching is enabled for the route and there is no acceptable cache data to use.
OR - manual caching has been enabled.
*/
static void outgoingCacheFilterService(HttpQueue *q)
{
HttpPacket *packet, *data;
HttpConn *conn;
HttpTx *tx;
MprKey *kp;
cchar *cachedData;
ssize size;
int foundDataPacket;
conn = q->conn;
tx = conn->tx;
foundDataPacket = 0;
cachedData = 0;
if (tx->status < 200 || tx->status > 299) {
tx->cacheBuffer = 0;
}
/*
This routine will save cached responses to tx->cacheBuffer.
It will also send cached data if the X-SendCache header is present. Normal caching is done by cacheHandler
*/
if (mprLookupKey(conn->tx->headers, "X-SendCache") != 0) {
if (fetchCachedResponse(conn)) {
mprLog(3, "cacheFilter: write cached content for '%s'", conn->rx->uri);
cachedData = setHeadersFromCache(conn, tx->cachedContent);
tx->length = slen(cachedData);
}
}
for (packet = httpGetPacket(q); packet; packet = httpGetPacket(q)) {
if (!httpWillNextQueueAcceptPacket(q, packet)) {
httpPutBackPacket(q, packet);
return;
}
if (packet->flags & HTTP_PACKET_HEADER) {
if (!cachedData && tx->cacheBuffer) {
/*
Add defined headers to the start of the cache buffer. Separate with a double newline.
*/
mprPutFmtToBuf(tx->cacheBuffer, "X-Status: %d\n", tx->status);
for (kp = 0; (kp = mprGetNextKey(tx->headers, kp)) != 0; ) {
mprPutFmtToBuf(tx->cacheBuffer, "%s: %s\n", kp->key, kp->data);
}
mprPutCharToBuf(tx->cacheBuffer, '\n');
}
} else if (packet->flags & HTTP_PACKET_DATA) {
if (cachedData) {
/*
Using X-SendCache. Replace the data with the cached response.
*/
mprFlushBuf(packet->content);
mprPutBlockToBuf(packet->content, cachedData, (ssize) tx->length);
} else if (tx->cacheBuffer) {
/*
Save the response packet to the cache buffer. Will write below in saveCachedResponse.
*/
size = mprGetBufLength(packet->content);
if ((tx->cacheBufferLength + size) < conn->limits->cacheItemSize) {
mprPutBlockToBuf(tx->cacheBuffer, mprGetBufStart(packet->content), mprGetBufLength(packet->content));
tx->cacheBufferLength += size;
} else {
tx->cacheBuffer = 0;
mprLog(3, "cacheFilter: Item too big to cache %d bytes, limit %d", tx->cacheBufferLength + size,
conn->limits->cacheItemSize);
}
}
foundDataPacket = 1;
} else if (packet->flags & HTTP_PACKET_END) {
if (cachedData && !foundDataPacket) {
/*
Using X-SendCache but there was no data packet to replace. So do the write here
*/
data = httpCreateDataPacket((ssize) tx->length);
mprPutBlockToBuf(data->content, cachedData, (ssize) tx->length);
httpPutPacketToNext(q, data);
} else if (tx->cacheBuffer) {
/*
Save the cache buffer to the cache store
*/
saveCachedResponse(conn);
}
}
httpPutPacketToNext(q, packet);
}
}
Token getNextJsonToken(MprBuf *buf, wchar **token, JsonState *js)
{
wchar *start, *cp, *end, *next;
wchar *src, *dest;
int quote, tid, c, isReg;
if (buf) {
mprFlushBuf(buf);
}
cp = js->next;
end = js->end;
cp = skipComments(cp, end);
next = cp + 1;
quote = -1;
isReg = 0;
if (*cp == '\0') {
tid = TOK_EOF;
} else if (*cp == '{') {
tid = TOK_LBRACE;
} else if (*cp == '[') {
tid = TOK_LBRACKET;
} else if (*cp == '}' || *cp == ']') {
tid = *cp == '}' ? TOK_RBRACE: TOK_RBRACKET;
while (*++cp && isspace((uchar) *cp)) ;
#if NEW || 1
/*
Detect missing comma after closing brace/bracket
*/
if (*cp && *cp != ',' && *cp != '}' && *cp != ']' && *cp != '/') {
js->error = cp;
return TOK_ERR;
}
#endif
if (*cp == ',' || *cp == ':') {
cp++;
}
next = cp;
} else {
if (*cp == '"' || *cp == '\'') {
tid = TOK_QID;
quote = *cp++;
for (start = cp; cp < end; cp++) {
if (*cp == '\\' && &cp[1] < end) {
cp++;
} else if (*cp == quote) {
break;
}
}
if (*cp != quote) {
js->error = cp;
return TOK_ERR;
}
if (buf) {
mprPutBlockToBuf(buf, (char*) start, (cp - start));
}
cp++;
} else if (*cp == '/') {
tid = TOK_ID;
isReg = 1;
for (start = cp++; cp < end; cp++) {
if (*cp == '\\') {
if (cp[1] == '/') {
cp++;
}
continue;
}
if (*cp == '/') {
break;
}
}
if (*cp != '/') {
js->error = cp;
return TOK_ERR;
}
if (buf) {
mprPutBlockToBuf(buf, (char*) start, (cp - start + 1));
}
cp++;
} else {
/*
Note: this is for keys and values
*/
tid = TOK_ID;
for (start = cp; cp < end; cp++) {
if (*cp == '\\') {
continue;
}
/*
Not an allowable character outside quotes (TODO - removed space
Should really keep state for parsing keys or values and not allow -,+,. in keys
*/
if (!(isalnum((uchar) *cp) || *cp == '_' || *cp == '-' || *cp == '+' || *cp == '.')) {
break;
}
}
if (buf) {
mprPutBlockToBuf(buf, (char*) start, (int) (cp - start));
}
}
if (buf) {
mprAddNullToBuf(buf);
}
while (*cp && isspace((int) *cp)) cp++;
if (*cp == ',' || *cp == ':') {
cp++;
} else if (*cp != '}' && *cp != ']' && *cp != '\0' && *cp != '\n' && *cp != '\r' && *cp != ' ') {
js->error = cp;
return TOK_ERR;
}
next = cp;
if (buf) {
for (dest = src = (wchar*) buf->start; src < (wchar*) buf->end; ) {
c = *src++;
if (c == '\\' && !isReg) {
c = *src++;
if (c == 'r') {
c = '\r';
} else if (c == 'n') {
c = '\n';
} else if (c == 'b') {
c = '\b';
}
}
*dest++ = c;
}
*dest = '\0';
*token = (wchar*) mprGetBufStart(buf);
}
}
js->next = next;
return tid;
}
/*
Get the next ESP input token. input points to the next input token.
parse->token will hold the parsed token. The function returns the token id.
*/
static int getEspToken(EspParse *parse)
{
char *start, *end, *next;
int tid, done, c;
start = next = parse->next;
end = &start[slen(start)];
mprFlushBuf(parse->token);
tid = ESP_TOK_LITERAL;
for (done = 0; !done && next < end; next++) {
c = *next;
switch (c) {
case '<':
if (next[1] == '%' && ((next == start) || next[-1] != '\\')) {
next += 2;
if (mprGetBufLength(parse->token) > 0) {
next -= 3;
} else {
next = eatSpace(parse, next);
if (*next == '=') {
/*
<%= directive
*/
tid = ESP_TOK_EXPR;
next = eatSpace(parse, ++next);
while (next < end && !(*next == '%' && next[1] == '>' && next[-1] != '\\')) {
if (*next == '\n') parse->lineNumber++;
if (!addChar(parse, *next++)) {
return ESP_TOK_ERR;
}
}
} else if (*next == '@') {
tid = ESP_TOK_CONTROL;
next = eatSpace(parse, ++next);
while (next < end && !(*next == '%' && next[1] == '>' && next[-1] != '\\')) {
if (*next == '\n') parse->lineNumber++;
if (!addChar(parse, *next++)) {
return ESP_TOK_ERR;
}
}
} else {
tid = ESP_TOK_CODE;
while (next < end && !(*next == '%' && next[1] == '>' && next[-1] != '\\')) {
if (*next == '\n') parse->lineNumber++;
if (!addChar(parse, *next++)) {
return ESP_TOK_ERR;
}
}
}
if (*next && next > start && next[-1] == '-') {
/* Remove "-" */
mprAdjustBufEnd(parse->token, -1);
mprAddNullToBuf(parse->token);
next = eatNewLine(parse, next + 2) - 1;
} else {
next++;
}
}
done++;
} else {
if (!addChar(parse, c)) {
return ESP_TOK_ERR;
}
}
break;
case '@':
if ((next == start) || next[-1] != '\\') {
if (next[1] == '@' || next[1] == '*') {
next += 2;
if (mprGetBufLength(parse->token) > 0) {
next -= 3;
} else {
tid = next[-1] == '@' ? ESP_TOK_VAR : ESP_TOK_FIELD;
next = eatSpace(parse, next);
while (isalnum((int) *next) || *next == '_') {
if (*next == '\n') parse->lineNumber++;
if (!addChar(parse, *next++)) {
return ESP_TOK_ERR;
}
}
next--;
}
done++;
}
}
break;
case '\n':
parse->lineNumber++;
/* Fall through */
case '\r':
default:
if (c == '\"' || c == '\\') {
if (!addChar(parse, '\\')) {
return ESP_TOK_ERR;
}
}
if (!addChar(parse, c)) {
return ESP_TOK_ERR;
}
break;
}
}
if (mprGetBufLength(parse->token) == 0) {
tid = ESP_TOK_EOF;
}
parse->next = next;
return tid;
}
Token getNextJsonToken(MprBuf *buf, MprChar **token, JsonState *js)
{
MprChar *start, *cp, *end, *next;
MprChar *src, *dest;
int quote, tid, c;
if (buf) {
mprFlushBuf(buf);
}
cp = js->next;
end = js->end;
cp = skipComments(cp, end);
next = cp + 1;
quote = -1;
if (*cp == '\0') {
tid = TOK_EOF;
} else if (*cp == '{') {
tid = TOK_LBRACE;
} else if (*cp == '[') {
tid = TOK_LBRACKET;
} else if (*cp == '}' || *cp == ']') {
tid = *cp == '}' ? TOK_RBRACE: TOK_RBRACKET;
while (*++cp && isspace((uchar) *cp)) ;
if (*cp == ',' || *cp == ':') {
cp++;
}
next = cp;
} else {
if (*cp == '"' || *cp == '\'') {
tid = TOK_QID;
quote = *cp++;
for (start = cp; cp < end; cp++) {
if (*cp == '\\') {
if (cp[1] == quote) {
cp++;
}
continue;
}
if (*cp == quote) {
break;
}
}
if (*cp != quote) {
js->error = cp;
return TOK_ERR;
}
if (buf) {
mprPutBlockToBuf(buf, (char*) start, (cp - start));
}
cp++;
} else if (*cp == '/') {
tid = TOK_ID;
for (start = cp++; cp < end; cp++) {
if (*cp == '\\') {
if (cp[1] == '/') {
cp++;
}
continue;
}
if (*cp == '/') {
break;
}
}
if (*cp != '/') {
js->error = cp;
return TOK_ERR;
}
if (buf) {
mprPutBlockToBuf(buf, (char*) start, (cp - start));
}
cp++;
} else {
tid = TOK_ID;
for (start = cp; cp < end; cp++) {
if (*cp == '\\') {
continue;
}
/* Not an allowable character outside quotes */
if (!(isalnum((uchar) *cp) || *cp == '_' || *cp == ' ' || *cp == '-' || *cp == '+' || *cp == '.')) {
break;
}
}
if (buf) {
mprPutBlockToBuf(buf, (char*) start, (int) (cp - start));
}
}
if (buf) {
mprAddNullToBuf(buf);
}
if (*cp == ',' || *cp == ':') {
cp++;
} else if (*cp != '}' && *cp != ']' && *cp != '\0' && *cp != '\n' && *cp != '\r' && *cp != ' ') {
js->error = cp;
return TOK_ERR;
}
next = cp;
if (buf) {
for (dest = src = (MprChar*) buf->start; src < (MprChar*) buf->end; ) {
c = *src++;
if (c == '\\') {
c = *src++;
if (c == 'r') {
c = '\r';
} else if (c == 'n') {
c = '\n';
} else if (c == 'b') {
c = '\b';
}
}
*dest++ = c;
}
*dest = '\0';
*token = (MprChar*) mprGetBufStart(buf);
}
}
js->next = next;
return tid;
}
static void discardOutput(void *handle)
{
mprFlushBuf(output);
}
/*
function [get|put|delete|post...](uri = null, ...data): Http
*/
static EjsHttp *startHttpRequest(Ejs *ejs, EjsHttp *hp, char *method, int argc, EjsObj **argv)
{
EjsArray *args;
EjsByteArray *data;
EjsNumber *written;
EjsUri *uriObj;
HttpConn *conn;
ssize nbytes;
conn = hp->conn;
hp->responseCache = 0;
hp->requestContentCount = 0;
mprFlushBuf(hp->responseContent);
if (argc >= 1 && !ejsIs(ejs, argv[0], Null)) {
uriObj = (EjsUri*) argv[0];
hp->uri = httpUriToString(uriObj->uri, HTTP_COMPLETE_URI);
}
if (argc == 2 && ejsIs(ejs, argv[1], Array)) {
args = (EjsArray*) argv[1];
if (args->length > 0) {
data = ejsCreateByteArray(ejs, -1);
written = ejsWriteToByteArray(ejs, data, 1, &argv[1]);
mprPutBlockToBuf(hp->requestContent, (char*) data->value, (int) written->value);
mprAddNullToBuf(hp->requestContent);
assert(written > 0);
}
}
if (hp->uri == 0) {
ejsThrowArgError(ejs, "URL is not defined");
return 0;
}
if (method && strcmp(hp->method, method) != 0) {
hp->method = sclone(method);
}
if (hp->method == 0) {
ejsThrowArgError(ejs, "HTTP Method is not defined");
return 0;
}
if (hp->certFile) {
if (!hp->ssl) {
hp->ssl = mprCreateSsl(0);
}
mprSetSslCertFile(hp->ssl, hp->certFile);
if (!hp->keyFile) {
ejsThrowStateError(ejs, "Must define a Http.key to use with a certificate");
}
mprSetSslKeyFile(hp->ssl, hp->keyFile);
}
if (hp->caFile) {
if (!hp->ssl) {
hp->ssl = mprCreateSsl(0);
}
mprSetSslCaFile(hp->ssl, hp->caFile);
}
if (httpConnect(conn, hp->method, hp->uri, hp->ssl) < 0) {
ejsThrowIOError(ejs, "Cannot issue request for \"%s\"", hp->uri);
return 0;
}
if (mprGetBufLength(hp->requestContent) > 0) {
nbytes = httpWriteBlock(conn->writeq, mprGetBufStart(hp->requestContent), mprGetBufLength(hp->requestContent),
HTTP_BLOCK);
if (nbytes < 0) {
ejsThrowIOError(ejs, "Cannot write request data for \"%s\"", hp->uri);
return 0;
} else if (nbytes > 0) {
assert(nbytes == mprGetBufLength(hp->requestContent));
mprAdjustBufStart(hp->requestContent, nbytes);
hp->requestContentCount += nbytes;
}
httpFinalize(conn);
}
httpNotify(conn, HTTP_EVENT_WRITABLE, 0);
if (conn->async) {
httpEnableConnEvents(hp->conn);
}
return hp;
}
void mprResetBufIfEmpty(MprBuf *bp)
{
if (mprGetBufLength(bp) == 0) {
mprFlushBuf(bp);
}
}
/*
Lexical analyser for XML. Return the next token reading input as required. It uses a one token look ahead and
push back mechanism (LAR1 parser). Text token identifiers are left in the tokBuf parser buffer on exit. This Lex
has special cases for the states MPR_XML_ELT_DATA where we have an optimized read of element data, and
MPR_XML_AFTER_LS where we distinguish between element names, processing instructions and comments.
*/
static MprXmlToken getXmlToken(MprXml *xp, int state)
{
MprBuf *tokBuf;
char *cp;
int c, rc;
mprAssert(state >= 0);
tokBuf = xp->tokBuf;
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
mprFlushBuf(tokBuf);
/*
Special case parsing for names and for element data. We do this for performance so we can return to the caller
the largest token possible.
*/
if (state == MPR_XML_ELT_DATA) {
/*
Read all the data up to the start of the closing element "<" or the start of a sub-element.
*/
if (c == '<') {
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
if (c == '/') {
return MPR_XMLTOK_LS_SLASH;
}
putLastChar(xp, c);
return MPR_XMLTOK_LS;
}
do {
if (mprPutCharToBuf(tokBuf, c) < 0) {
return MPR_XMLTOK_TOO_BIG;
}
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
} while (c != '<');
/*
Put back the last look-ahead character
*/
putLastChar(xp, c);
/*
If all white space, then zero the token buffer
*/
for (cp = tokBuf->start; *cp; cp++) {
if (!isspace((uchar) *cp & 0x7f)) {
return MPR_XMLTOK_TEXT;
}
}
mprFlushBuf(tokBuf);
return MPR_XMLTOK_TEXT;
}
while (1) {
switch (c) {
case ' ':
case '\n':
case '\t':
case '\r':
break;
case '<':
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
if (c == '/') {
return MPR_XMLTOK_LS_SLASH;
}
putLastChar(xp, c);
return MPR_XMLTOK_LS;
case '=':
return MPR_XMLTOK_EQ;
case '>':
return MPR_XMLTOK_GR;
case '/':
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
if (c == '>') {
return MPR_XMLTOK_SLASH_GR;
}
return MPR_XMLTOK_ERR;
case '\"':
case '\'':
xp->quoteChar = c;
/* Fall through */
default:
/*
We handle element names, attribute names and attribute values
here. We do NOT handle data between elements here. Read the
token. Stop on white space or a closing element ">"
*/
if (xp->quoteChar) {
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
while (c != xp->quoteChar) {
if (mprPutCharToBuf(tokBuf, c) < 0) {
return MPR_XMLTOK_TOO_BIG;
}
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
}
xp->quoteChar = 0;
} else {
while (!isspace((uchar) c) && c != '>' && c != '/' && c != '=') {
if (mprPutCharToBuf(tokBuf, c) < 0) {
return MPR_XMLTOK_TOO_BIG;
}
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
}
putLastChar(xp, c);
}
if (mprGetBufLength(tokBuf) < 0) {
return MPR_XMLTOK_ERR;
}
mprAddNullToBuf(tokBuf);
if (state == MPR_XML_AFTER_LS) {
/*
If we are just inside an element "<", then analyze what we have to see if we have an element name,
instruction or comment. Tokbuf will hold "?" for instructions or "!--" for comments.
*/
if (mprLookAtNextCharInBuf(tokBuf) == '?') {
/* Just ignore processing instructions */
rc = scanFor(xp, "?>");
if (rc < 0) {
return MPR_XMLTOK_TOO_BIG;
} else if (rc == 0) {
return MPR_XMLTOK_ERR;
}
return MPR_XMLTOK_INSTRUCTIONS;
} else if (mprLookAtNextCharInBuf(tokBuf) == '!') {
if (strncmp((char*) tokBuf->start, "![CDATA[", 8) == 0) {
mprAdjustBufStart(tokBuf, 8);
rc = scanFor(xp, "]]>");
if (rc < 0) {
return MPR_XMLTOK_TOO_BIG;
} else if (rc == 0) {
return MPR_XMLTOK_ERR;
}
return MPR_XMLTOK_CDATA;
} else {
mprFlushBuf(tokBuf);
rc = scanFor(xp, "-->");
if (rc < 0) {
return MPR_XMLTOK_TOO_BIG;
} else if (rc == 0) {
return MPR_XMLTOK_ERR;
}
return MPR_XMLTOK_COMMENT;
}
}
}
trimToken(xp);
return MPR_XMLTOK_TEXT;
}
if ((c = getNextChar(xp)) < 0) {
return MPR_XMLTOK_EOF;
}
}
/* Should never get here */
mprAssert(0);
return MPR_XMLTOK_ERR;
}