/*
http.c -- GoAhead HTTP engine
This module implements an embedded HTTP/1.1 web server. It supports
loadable URL handlers that define the nature of URL processing performed.
Copyright (c) All Rights Reserved. See details at the end of the file.
*/
/********************************* Includes ***********************************/
#include "goahead.h"
/********************************* Defines ************************************/
#define WEBS_TIMEOUT (ME_GOAHEAD_LIMIT_TIMEOUT * 1000)
#define PARSE_TIMEOUT (ME_GOAHEAD_LIMIT_PARSE_TIMEOUT * 1000)
#define CHUNK_LOW 128 /* Low water mark for chunking */
#define TOKEN_HEADER_KEY 0x1 /* Validate token as a header key */
#define TOKEN_HEADER_VALUE 0x2 /* Validate token as a header value */
#define TOKEN_URI_VALUE 0x4 /* Validate token as a URI value */
#define TOKEN_NUMBER 0x8 /* Validate token as a number */
#define TOKEN_WORD 0x10 /* Validate token as single word with no spaces */
#define TOKEN_LINE 0x20 /* Validate token as line with no newlines */
/************************************ Locals **********************************/
static int websBackground; /* Run as a daemon */
static int websDebug; /* Run in debug mode and defeat timeouts */
static int defaultHttpPort; /* Default port number for http */
static int defaultSslPort; /* Default port number for https */
static int listens[WEBS_MAX_LISTEN]; /* Listen endpoints */;
static int listenMax; /* Max entry in listens */
static Webs **webs; /* Open connection list head */
static WebsHash websMime; /* Set of mime types */
static int websMax; /* List size */
static char websHost[ME_MAX_IP]; /* Host name for the server */
static char websIpAddr[ME_MAX_IP]; /* IP address for the server */
static char *websHostUrl = NULL; /* URL to access server */
static char *websIpAddrUrl = NULL; /* URL to access server */
#define WEBS_ENCODE_HTML 0x1 /* Bit setting in charMatch[] */
#define WEBS_ENCODE_URI 0x4 /* Encode URI characters */
/*
Character escape/descape matching codes. Generated by mprEncodeGenerate in appweb.
*/
static uchar charMatch[256] = {
0x00,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x7e,0x3c,0x3c,0x7c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x7c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x00,0x7f,0x28,0x2a,0x3c,0x2b,0x43,0x02,0x02,0x02,0x28,0x28,0x00,0x00,0x28,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x28,0x2a,0x3f,0x28,0x3f,0x2a,
0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3a,0x7e,0x3a,0x3e,0x00,
0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x3e,0x3e,0x02,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,
0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c,0x3c
};
/*
Add entries to the MimeList as required for your content
*/
static WebsMime websMimeList[] = {
{ "application/java", ".class" },
{ "application/java", ".jar" },
{ "text/html", ".asp" },
{ "text/html", ".htm" },
{ "text/html", ".html" },
{ "text/xml", ".xml" },
{ "image/gif", ".gif" },
{ "image/jpeg", ".jpg" },
{ "image/png", ".png" },
{ "image/svg+xml", ".svg" },
{ "image/vnd.microsoft.icon", ".ico" },
{ "text/css", ".css" },
{ "text/plain", ".txt" },
{ "application/x-javascript", ".js" },
{ "application/x-shockwave-flash", ".swf" },
{ "application/json", ".json" },
{ "application/binary", ".exe" },
{ "application/compress", ".z" },
{ "application/gzip", ".gz" },
{ "application/octet-stream", ".bin" },
{ "application/oda", ".oda" },
{ "application/pdf", ".pdf" },
{ "application/postscript", ".ai" },
{ "application/postscript", ".eps" },
{ "application/postscript", ".ps" },
{ "application/rtf", ".rtf" },
{ "application/x-bcpio", ".bcpio" },
{ "application/x-cpio", ".cpio" },
{ "application/x-csh", ".csh" },
{ "application/x-dvi", ".dvi" },
{ "application/x-gtar", ".gtar" },
{ "application/x-hdf", ".hdf" },
{ "application/x-latex", ".latex" },
{ "application/x-mif", ".mif" },
{ "application/x-netcdf", ".nc" },
{ "application/x-netcdf", ".cdf" },
{ "application/x-ns-proxy-autoconfig", ".pac" },
{ "application/x-patch", ".patch" },
{ "application/x-sh", ".sh" },
{ "application/x-shar", ".shar" },
{ "application/x-sv4cpio", ".sv4cpio" },
{ "application/x-sv4crc", ".sv4crc" },
{ "application/x-tar", ".tar" },
{ "application/x-tgz", ".tgz" },
{ "application/x-tcl", ".tcl" },
{ "application/x-tex", ".tex" },
{ "application/x-texinfo", ".texinfo" },
{ "application/x-texinfo", ".texi" },
{ "application/x-troff", ".t" },
{ "application/x-troff", ".tr" },
{ "application/x-troff", ".roff" },
{ "application/x-troff-man", ".man" },
{ "application/x-troff-me", ".me" },
{ "application/x-troff-ms", ".ms" },
{ "application/x-ustar", ".ustar" },
{ "application/x-wais-source", ".src" },
{ "application/zip", ".zip" },
{ "audio/basic", ".au snd" },
{ "audio/x-aiff", ".aif" },
{ "audio/x-aiff", ".aiff" },
{ "audio/x-aiff", ".aifc" },
{ "audio/x-wav", ".wav" },
{ "audio/x-wav", ".ram" },
{ "image/ief", ".ief" },
{ "image/jpeg", ".jpeg" },
{ "image/jpeg", ".jpe" },
{ "image/tiff", ".tiff" },
{ "image/tiff", ".tif" },
{ "image/x-cmu-raster", ".ras" },
{ "image/x-portable-anymap", ".pnm" },
{ "image/x-portable-bitmap", ".pbm" },
{ "image/x-portable-graymap", ".pgm" },
{ "image/x-portable-pixmap", ".ppm" },
{ "image/x-rgb", ".rgb" },
{ "image/x-xbitmap", ".xbm" },
{ "image/x-xpixmap", ".xpm" },
{ "image/x-xwindowdump", ".xwd" },
{ "text/html", ".cfm" },
{ "text/html", ".shtm" },
{ "text/html", ".shtml" },
{ "text/richtext", ".rtx" },
{ "text/tab-separated-values", ".tsv" },
{ "text/x-setext", ".etx" },
{ "video/mpeg", ".mpeg" },
{ "video/mpeg", ".mpg" },
{ "video/mpeg", ".mpe" },
{ "video/quicktime", ".qt" },
{ "video/quicktime", ".mov" },
{ "video/mp4", ".mp4" },
{ "video/x-msvideo", ".avi" },
{ "video/x-sgi-movie", ".movie" },
{ NULL, NULL},
};
/*
Standard HTTP error codes
*/
static WebsError websErrors[] = {
{ 200, "OK" },
{ 201, "Created" },
{ 204, "No Content" },
{ 205, "Reset Content" },
{ 206, "Partial Content" },
{ 301, "Redirect" },
{ 302, "Redirect" },
{ 304, "Not Modified" },
{ 400, "Bad Request" },
{ 401, "Unauthorized" },
{ 402, "Payment required" },
{ 403, "Forbidden" },
{ 404, "Not Found" },
{ 405, "Access Denied" },
{ 406, "Not Acceptable" },
{ 408, "Request Timeout" },
{ 413, "Request too large" },
{ 500, "Internal Server Error" },
{ 501, "Not Implemented" },
{ 503, "Service Unavailable" },
{ 0, NULL }
};
#if ME_GOAHEAD_ACCESS_LOG && !ME_ROM
static char accessLog[64] = "access.log"; /* Log filename */
static int accessFd; /* Log file handle */
#endif
static WebsHash sessions = -1;
static int sessionCount = 0;
static int pruneId; /* Callback ID */
/**************************** Forward Declarations ****************************/
static void checkTimeout(void *arg, int id);
static bool filterChunkData(Webs *wp);
static int getTimeSinceMark(Webs *wp);
static char *getToken(Webs *wp, char *delim, int validation);
static void parseFirstLine(Webs *wp);
static void parseHeaders(Webs *wp);
static bool processContent(Webs *wp);
static bool parseIncoming(Webs *wp);
static void pruneSessions(void);
static void freeSession(WebsSession *sp);
static void freeSessions(void);
static void readEvent(Webs *wp);
static void reuseConn(Webs *wp);
static void setFileLimits(void);
static int setLocalHost(void);
static void socketEvent(int sid, int mask, void *data);
static void writeEvent(Webs *wp);
static char *validateToken(char *token, char *endToken, int validation);
#if ME_GOAHEAD_ACCESS_LOG
static void logRequest(Webs *wp, int code);
#endif
/*********************************** Code *************************************/
PUBLIC int websOpen(cchar *documents, cchar *routeFile)
{
WebsMime *mt;
webs = NULL;
websMax = 0;
websOsOpen();
websRuntimeOpen();
websTimeOpen();
websFsOpen();
logOpen();
setFileLimits();
socketOpen();
if (setLocalHost() < 0) {
return -1;
}
#if ME_COM_SSL
if (sslOpen() < 0) {
return -1;
}
#endif
if ((sessions = hashCreate(-1)) < 0) {
return -1;
}
if (!websDebug) {
pruneId = websStartEvent(WEBS_SESSION_PRUNE, (WebsEventProc) pruneSessions, 0);
}
if (documents) {
websSetDocuments(documents);
}
if (websOpenRoute() < 0) {
return -1;
}
#if ME_GOAHEAD_CGI
websCgiOpen();
#endif
websOptionsOpen();
websActionOpen();
websFileOpen();
#if ME_GOAHEAD_UPLOAD
websUploadOpen();
#endif
#if ME_GOAHEAD_JAVASCRIPT
websJstOpen();
#endif
#if ME_GOAHEAD_AUTH
if (websOpenAuth(0) < 0) {
return -1;
}
#endif
if (routeFile && websLoad(routeFile) < 0) {
return -1;
}
/*
Create a mime type lookup table for quickly determining the content type
*/
websMime = hashCreate(WEBS_HASH_INIT * 4);
assert(websMime >= 0);
for (mt = websMimeList; mt->type; mt++) {
hashEnter(websMime, mt->ext, valueString(mt->type, 0), 0);
}
#if ME_GOAHEAD_ACCESS_LOG && !ME_ROM
if ((accessFd = open(accessLog, O_CREAT | O_TRUNC | O_APPEND | O_WRONLY, 0666)) < 0) {
error("Cannot open access log %s", accessLog);
return -1;
}
/* Some platforms don't implement O_APPEND (VXWORKS) */
lseek(accessFd, 0, SEEK_END);
#endif
return 0;
}
PUBLIC void websClose(void)
{
Webs *wp;
int i;
websCloseRoute();
#if ME_GOAHEAD_AUTH
websCloseAuth();
#endif
if (pruneId >= 0) {
websStopEvent(pruneId);
pruneId = -1;
}
if (sessions >= 0) {
freeSessions();
}
for (i = 0; i < listenMax; i++) {
if (listens[i] >= 0) {
socketCloseConnection(listens[i]);
listens[i] = -1;
}
}
listenMax = 0;
for (i = websMax; webs && i >= 0; i--) {
if ((wp = webs[i]) == NULL) {
continue;
}
if (wp->sid >= 0) {
socketCloseConnection(wp->sid);
wp->sid = -1;
}
websFree(wp);
}
wfree(websHostUrl);
wfree(websIpAddrUrl);
websIpAddrUrl = websHostUrl = NULL;
#if ME_COM_SSL
sslClose();
#endif
#if ME_GOAHEAD_ACCESS_LOG
if (accessFd >= 0) {
close(accessFd);
accessFd = -1;
}
#endif
websFsClose();
hashFree(websMime);
socketClose();
logClose();
websTimeClose();
websRuntimeClose();
websOsClose();
}
static void initWebs(Webs *wp, int flags, int reuse)
{
WebsBuf rxbuf;
WebsTime timestamp;
void *ssl;
char ipaddr[ME_MAX_IP], ifaddr[ME_MAX_IP];
int wid, sid, timeout, listenSid;
assert(wp);
if (reuse) {
rxbuf = wp->rxbuf;
wid = wp->wid;
sid = wp->sid;
timeout = wp->timeout;
ssl = wp->ssl;
listenSid = wp->listenSid;
trace(2, "http.c 381 the wp->ipaddr is changed to : %s++++++++++pppppppppppppppppp", wp->ipaddr);
trace(2, "http.c 382 the wp->ifaddr is changed to : %s++++++++++ffffffffffffffffff", wp->ifaddr);
scopy(ipaddr, sizeof(ipaddr), wp->ipaddr);
scopy(ifaddr, sizeof(ifaddr), wp->ifaddr);
timestamp = wp->timestamp;
} else {
wid = sid = -1;
timeout = -1;
ssl = 0;
listenSid = -1;
timestamp = 0;
}
memset(wp, 0, sizeof(Webs));
wp->flags = flags;
wp->state = WEBS_BEGIN;
wp->wid = wid;
wp->sid = sid;
wp->timeout = timeout;
wp->docfd = -1;
wp->txLen = -1;
wp->rxLen = -1;
wp->responseCookies = hashCreate(7);
wp->code = HTTP_CODE_OK;
wp->ssl = ssl;
wp->listenSid = listenSid;
wp->timestamp = timestamp;
#if !ME_ROM
wp->putfd = -1;
#endif
#if ME_GOAHEAD_CGI
wp->cgifd = -1;
#endif
#if ME_GOAHEAD_UPLOAD
wp->files = -1;
wp->upfd = -1;
#endif
if (reuse) {
trace(2, "http.c 416 the ipaddr is changed to : %s==========pppppppppppppppppp", ipaddr);
trace(2, "http.c 416 the ifaddr is changed to : %s==========ffffffffffffffffff", ifaddr);
scopy(wp->ipaddr, sizeof(wp->ipaddr), ipaddr);
scopy(wp->ifaddr, sizeof(wp->ifaddr), ifaddr);
} else {
wp->timeout = -1;
}
wp->vars = hashCreate(WEBS_HASH_INIT);
/*
Ring queues can never be totally full and are short one byte. Better to do even I/O and allocate
a little more memory than required. The chunkbuf has extra room to fit chunk headers and trailers.
*/
assert(ME_GOAHEAD_LIMIT_BUFFER >= 1024);
bufCreate(&wp->output, ME_GOAHEAD_LIMIT_BUFFER + 1, ME_GOAHEAD_LIMIT_BUFFER + 1);
bufCreate(&wp->chunkbuf, ME_GOAHEAD_LIMIT_BUFFER + 1, ME_GOAHEAD_LIMIT_BUFFER * 2);
bufCreate(&wp->input, ME_GOAHEAD_LIMIT_BUFFER + 1, ME_GOAHEAD_LIMIT_PUT + 1);
if (reuse) {
wp->rxbuf = rxbuf;
} else {
bufCreate(&wp->rxbuf, ME_GOAHEAD_LIMIT_HEADERS, ME_GOAHEAD_LIMIT_HEADERS + ME_GOAHEAD_LIMIT_PUT);
}
}
static void termWebs(Webs *wp, int reuse)
{
assert(wp);
/*
Some of this is done elsewhere, but keep this here for when a shutdown is done and there are open connections.
*/
bufFree(&wp->input);
bufFree(&wp->output);
bufFree(&wp->chunkbuf);
if (!reuse) {
bufFree(&wp->rxbuf);
if (wp->sid >= 0) {
#if ME_COM_SSL
sslFree(wp);
#endif
socketDeleteHandler(wp->sid);
socketCloseConnection(wp->sid);
wp->sid = -1;
}
}
#if !ME_ROM
if (wp->putfd >= 0) {
close(wp->putfd);
wp->putfd = -1;
assert(wp->putname && wp->filename);
if (rename(wp->putname, wp->filename) < 0) {
error("Cannot rename PUT file from %s to %s", wp->putname, wp->filename);
}
}
#endif
#if ME_GOAHEAD_CGI
if (wp->cgifd >= 0) {
close(wp->cgifd);
wp->cgifd = -1;
}
if (wp->cgiStdin) {
unlink(wp->cgiStdin);
wfree(wp->cgiStdin);
}
#endif
#if ME_GOAHEAD_UPLOAD
wfree(wp->clientFilename);
#endif
websPageClose(wp);
if (wp->timeout >= 0 && !reuse) {
websCancelTimeout(wp);
}
wfree(wp->authDetails);
wfree(wp->authResponse);
wfree(wp->authType);
wfree(wp->contentType);
wfree(wp->cookie);
wfree(wp->decodedQuery);
wfree(wp->digest);
wfree(wp->ext);
wfree(wp->filename);
wfree(wp->host);
wfree(wp->method);
wfree(wp->password);
wfree(wp->path);
wfree(wp->protoVersion);
wfree(wp->putname);
wfree(wp->query);
wfree(wp->realm);
wfree(wp->referrer);
wfree(wp->url);
wfree(wp->userAgent);
wfree(wp->username);
#if ME_GOAHEAD_UPLOAD
wfree(wp->boundary);
wfree(wp->uploadTmp);
wfree(wp->uploadVar);
#endif
#if ME_GOAHEAD_DIGEST
wfree(wp->cnonce);
wfree(wp->digestUri);
wfree(wp->opaque);
wfree(wp->nc);
wfree(wp->nonce);
wfree(wp->qop);
#endif
hashFree(wp->vars);
hashFree(wp->responseCookies);
#if ME_GOAHEAD_UPLOAD
if (wp->files >= 0) {
websFreeUpload(wp);
}
#endif
}
PUBLIC int websAlloc(int sid)
{
Webs *wp;
int wid;
if ((wid = wallocObject(&webs, &websMax, sizeof(Webs))) < 0) {
return -1;
}
wp = webs[wid];
assert(wp);
initWebs(wp, 0, 0);
wp->wid = wid;
wp->sid = sid;
wp->timestamp = time(0);
return wid;
}
static void reuseConn(Webs *wp)
{
assert(wp);
assert(websValid(wp));
bufCompact(&wp->rxbuf);
if (bufLen(&wp->rxbuf)) {
socketReservice(wp->sid);
}
termWebs(wp, 1);
initWebs(wp, wp->flags & (WEBS_KEEP_ALIVE | WEBS_SECURE | WEBS_HTTP11), 1);
}
PUBLIC void websFree(Webs *wp)
{
assert(wp);
assert(websValid(wp));
termWebs(wp, 0);
websMax = wfreeHandle(&webs, wp->wid);
wfree(wp);
assert(websMax >= 0);
}
/*
Called when the request is complete. Note: it may not have fully drained from the tx buffer.
*/
PUBLIC void websDone(Webs *wp)
{
WebsSocket *sp;
assert(wp);
assert(websValid(wp));
if (wp->finalized) {
return;
}
assert(WEBS_BEGIN <= wp->state && wp->state <= WEBS_COMPLETE);
#if DEPRECATED || 1
wp->flags |= WEBS_FINALIZED;
#endif
wp->finalized = 1;
/*
Once running, it is the handlers responsibility to conclude the request.
*/
if (wp->connError && wp->state < WEBS_RUNNING) {
wp->state = WEBS_COMPLETE;
}
if (wp->state < WEBS_COMPLETE) {
/*
Initiate flush. If not all flushed, wait for output to drain via a socket event.
*/
if (websFlush(wp, 0) == 0) {
sp = socketPtr(wp->sid);
socketCreateHandler(wp->sid, sp->handlerMask | SOCKET_WRITABLE, socketEvent, wp);
}
}
#if ME_GOAHEAD_ACCESS_LOG
logRequest(wp, wp->code);
#endif
if (!(wp->flags & WEBS_RESPONSE_TRACED)) {
trace(3 | WEBS_RAW_MSG, "Request complete: code %d", wp->code);
}
}
static int complete(Webs *wp, int reuse)
{
assert(wp);
assert(websValid(wp));
assert(wp->state == WEBS_BEGIN || wp->state == WEBS_COMPLETE);
if (reuse && wp->flags & WEBS_KEEP_ALIVE && wp->rxRemaining == 0) {
reuseConn(wp);
socketCreateHandler(wp->sid, SOCKET_READABLE, socketEvent, wp);
trace(5, "Keep connection alive");
return 1;
}
trace(5, "Close connection");
wp->state = WEBS_BEGIN;
wp->flags |= WEBS_CLOSED;
return 0;
}
PUBLIC int websListen(cchar *endpoint)
{
WebsSocket *sp;
char *ip, *ipaddr;
int port, secure, sid;
assert(endpoint && *endpoint);
if (listenMax >= WEBS_MAX_LISTEN) {
error("Too many listen endpoints");
return -1;
}
socketParseAddress(endpoint, &ip, &port, &secure, 80);
if ((sid = socketListen(ip, port, websAccept, 0)) < 0) {
error("Unable to open socket on port %d.", port);
return -1;
}
sp = socketPtr(sid);
sp->secure = secure;
if (sp->secure) {
if (!defaultSslPort) {
defaultSslPort = port;
}
} else if (!defaultHttpPort) {
defaultHttpPort = port;
}
listens[listenMax++] = sid;
if (ip) {
ipaddr = smatch(ip, "::") ? "[::]" : ip;
} else {
ipaddr = "*";
}
logmsg(2, "Started %s://%s:%d", secure ? "https" : "http", ipaddr, port);
if (!websIpAddrUrl) {
if (port == 80) {
websIpAddrUrl = sclone(websIpAddr);
} else {
websIpAddrUrl = sfmt("%s:%d", websIpAddr, port);
}
}
wfree(ip);
return sid;
}
/*
Accept a new connection from ipaddr:port
接受来自ipaddr:port的新连接
*/
PUBLIC int websAccept(int sid, cchar *ipaddr, int port, int listenSid)
{
Webs *wp;
WebsSocket *lp;
struct sockaddr_storage ifAddr;
int wid, len;
assert(sid >= 0);
assert(ipaddr && *ipaddr);
assert(listenSid >= 0);
assert(port >= 0);
/*
Allocate a new handle for this accepted connection. This will allocate a Webs structure in the webs[] list
为这个已接受的连接分配一个新句柄。这将在web[]列表中分配一个web结构
*/
if ((wid = websAlloc(sid)) < 0) {
return -1;
}
wp = webs[wid];
assert(wp);
wp->listenSid = listenSid;
trace(2, "http.c 713 the ipaddr is %s", ipaddr);
trace(2, "http.c 715 the wp->ipaddr is %s", wp->ipaddr);
strncpy(wp->ipaddr, ipaddr, min(sizeof(wp->ipaddr) - 1, strlen(ipaddr)));
trace(2, "http.c 717 the wp->ipaddr is %s", wp->ipaddr);
/*
Get the ip address of the interface that accept the connection.
*/
len = sizeof(ifAddr);
if (getsockname(socketPtr(sid)->sock, (struct sockaddr*) &ifAddr, (Socklen*) &len) < 0) {
error("Cannot get sockname");
websFree(wp);
return -1;
}
/*socketAddress为给定的套接字信息提取数字IP地址和端口*/
trace(2, "http.c 728 the ifAddr is %s", ifAddr);
trace(2, "http.c 729 the wp->ifaddr is %s", wp->ifaddr);
socketAddress((struct sockaddr*) &ifAddr, (int) len, wp->ifaddr, sizeof(wp->ifaddr), NULL);
trace(2, "http.c 731 the wp->ifaddr is %s", wp->ifaddr);
#if ME_GOAHEAD_LEGACY
/*
Check if this is a request from a browser on this system. This is useful to know for permitting administrative
operations only for local access
检查这是否是来自本系统上的浏览器的请求。这对于只允许本地访问的管理操作很有用
*/
if (strcmp(wp->ipaddr, "127.0.0.1") == 0 || strcmp(wp->ipaddr, websIpAddr) == 0 ||
strcmp(wp->ipaddr, websHost) == 0) {
wp->flags |= WEBS_LOCAL;
}
#endif
/*
Arrange for socketEvent to be called when read data is available
安排在读取数据可用时调用socketEvent
*/
lp = socketPtr(listenSid);
trace(2, "New connection from %s:%d to %s:%d", ipaddr, port, wp->ifaddr, lp->port);
#if ME_COM_SSL
if (lp->secure) {
wp->flags |= WEBS_SECURE;
trace(4, "Upgrade connection to TLS");
if (sslUpgrade(wp) < 0) {
error("Cannot upgrade to TLS");
websFree(wp);
return -1;
}
}
#endif
assert(wp->timeout == -1);
wp->timeout = websStartEvent(PARSE_TIMEOUT, checkTimeout, (void*) wp);
socketEvent(sid, SOCKET_READABLE, wp);
return 0;
}
/*
The webs socket handler. Called in response to I/O. We just pass control to the relevant read or write handler. A
pointer to the webs structure is passed as a (void*) in wptr.
web套接字处理器。为响应I/O而调用。我们只是将控制传递给相关的读或写处理程序。指向web结构的指针在wptr中作为(void*)传递。
*/
static void socketEvent(int sid, int mask, void *wptr)
{
Webs *wp;
wp = (Webs*) wptr;
assert(wp);
assert(websValid(wp));
if (! websValid(wp)) {
return;
}
if (mask & SOCKET_READABLE) {
readEvent(wp);
}
if (mask & SOCKET_WRITABLE) {
writeEvent(wp);
}
if (wp->flags & WEBS_CLOSED) {
websFree(wp);
/* WARNING: wp not valid here */
}
}
/*
Read from a connection. Return the number of bytes read if successful. This may be less than the requested "len" and
may be zero. Return -1 for errors or EOF. Distinguish between error and EOF via socketEof().
*/
static ssize websRead(Webs *wp, char *buf, ssize len)
{
assert(wp);
assert(buf);
assert(len > 0);
#if ME_COM_SSL
if (wp->flags & WEBS_SECURE) {
return sslRead(wp, buf, len);
}
#endif
return socketRead(wp->sid, buf, len);
}
/*
The webs read handler. This is the primary read event loop. It uses a state machine to track progress while parsing
the HTTP request. Note: we never block as the socket is always in non-blocking mode.
web读取处理程序。这是主读事件循环。它使用状态机在解析时跟踪进度.HTTP请求。注意:我们从不阻塞，因为套接字总是处于非阻塞模式。
*/
static void readEvent(Webs *wp)
{
WebsBuf *rxbuf;
WebsSocket *sp;
ssize nbytes;
assert(wp);
assert(websValid(wp));
if (!websValid(wp)) {
return;
}
websNoteRequestActivity(wp);
rxbuf = &wp->rxbuf;/*缓冲区的数据结构*/
if (bufRoom(rxbuf) < (ME_GOAHEAD_LIMIT_BUFFER + 1)) {//缓冲区不够了增加缓冲区的大小
if (!bufGrow(rxbuf, ME_GOAHEAD_LIMIT_BUFFER + 1)) {
websError(wp, HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot grow rxbuf");
websPump(wp);
return;
}
}
if ((nbytes = websRead(wp, (char*) rxbuf->endp, ME_GOAHEAD_LIMIT_BUFFER)) > 0) {//调用socketRead,读HTTP请求.rxbuf->endp是上一次的数据尾，每次读之后接上
wp->lastRead = nbytes;
bufAdjustEnd(rxbuf, nbytes);//读了多少字节，数据的尾指针就加多少字节
bufAddNull(rxbuf);//写字符串结束符
}
if (nbytes > 0 || wp->state > WEBS_BEGIN) {//读到数据了，进来处理
websPump(wp);
}
if (wp->flags & WEBS_CLOSED) {
return;//通过websPump处理完请求，需要关闭连接，return返回readEvent.数据结构依然保留。如果是非keep alive 什么时候清除本链接的数据结构？
} else if (nbytes < 0 && socketEof(wp->sid)) {
/* EOF or error. Allow running requests to continue. */
if (wp->state < WEBS_READY) {
if (wp->state > WEBS_BEGIN) {
websError(wp, HTTP_CODE_COMMS_ERROR | WEBS_CLOSE, "Read error: connection lost");
websPump(wp);
} else {
complete(wp, 0);
}
} else {
socketDeleteHandler(wp->sid);
}
} else if (wp->state < WEBS_READY) {//如果是keep alive的请求，继续监听。
sp = socketPtr(wp->sid);
socketCreateHandler(wp->sid, sp->handlerMask | SOCKET_READABLE, socketEvent, wp);
}
}
/*websPump是处理WEB请求的主要函数，里面根据不同状态机来处理HTTP请求。HTTP请求的解析，响应，完成对应状态机中的几个状态*/
PUBLIC void websPump(Webs *wp)
{
bool canProceed;
for (canProceed = 1; canProceed; ) {//只到conProceed = 0 ,才退出循环，否则按状态顺序循环执行
switch (wp->state) {
case WEBS_BEGIN://最初都是BEGIN状态
canProceed = parseIncoming(wp);//除了请求头之外有额外的数据输入到服务器,parseIncoming() 解析HTTP头的内容,确定是何种请求，从而才能知道怎么去响应:
break;
case WEBS_CONTENT:
canProceed = processContent(wp);
break;
case WEBS_READY:
if (!websRunRequest(wp)) {//接受数据已经完成，开始响应HTTP请求。调用注册的各个handler，有jstHandler,fileHandler,actionHandler等。
//默认是fileHandler，即普通的文档传输。handler执行过程中将state置为COMPLETE
/* Reroute if the handler re-wrote the request */
websRouteRequest(wp);
wp->state = WEBS_READY;
canProceed = 1;
continue;
}
canProceed = (wp->state != WEBS_RUNNING);
break;
case WEBS_RUNNING:
/* Nothing to do until websDone is called */
return;
case WEBS_COMPLETE:
canProceed = complete(wp, 1);//此处退出webPump,最终退出readEvent,等待select下一次返回
break;
}
}
}
/*parseIncoming() 解析HTTP头的内容,确定是何种请求，从而才能知道怎么去响应*/
static bool parseIncoming(Webs *wp)
{
WebsBuf *rxbuf;
char *end, c;
rxbuf = &wp->rxbuf;
while (*rxbuf->servp == '\r' || *rxbuf->servp == '\n') {
if (bufGetc(rxbuf) < 0) {
break;
}
}//找到非\r\n的第一个字节
if ((end = strstr((char*) wp->rxbuf.servp, "\r\n\r\n")) == 0) {//“\r\n\r\n”是协议规定请求头的结束符，实际上就是两个连续换行
if (bufLen(&wp->rxbuf) >= ME_GOAHEAD_LIMIT_HEADER) {//没读完请求的话，继续读，但是也不能读太长
websError(wp, HTTP_CODE_REQUEST_TOO_LARGE | WEBS_CLOSE, "Header too large");
return 1;
}
return 0;
}
trace(3 | WEBS_RAW_MSG, "\n<<< Request\n");
c = *end;
*end = '\0';
trace(3 | WEBS_RAW_MSG, "%s\n", wp->rxbuf.servp);
*end = c;
//读完了请求了，开始解析
/*
Parse the first line of the Http header
*/
parseFirstLine(wp);//解析第一行信息
if (wp->state == WEBS_COMPLETE) {
return 1;
}
parseHeaders(wp);//解析整个请求，把请求每一个属性记录下来，存在WP中
if (wp->state == WEBS_COMPLETE) {
return 1;
}
wp->state = (wp->rxChunkState || wp->rxLen > 0) ? WEBS_CONTENT : WEBS_READY;
websRouteRequest(wp);//route的意思是将这个wp与route.txt中每一行相匹配，如果能匹配，wp-route = route
if (wp->state == WEBS_COMPLETE) {
return 1;
}
#if ME_GOAHEAD_CGI
if (wp->route && wp->route->handler && wp->route->handler->service == cgiHandler) {
if (smatch(wp->method, "POST")) {
wp->cgiStdin = websGetCgiCommName();
if ((wp->cgifd = open(wp->cgiStdin, O_CREAT | O_WRONLY | O_BINARY | O_TRUNC, 0666)) < 0) {
websError(wp, HTTP_CODE_NOT_FOUND | WEBS_CLOSE, "Cannot open CGI file");
return 1;
}
}
}
#endif
#if !ME_ROM
if (smatch(wp->method, "PUT")) {
WebsStat sbuf;
wp->code = (stat(wp->filename, &sbuf) == 0 && sbuf.st_mode & S_IFDIR) ? HTTP_CODE_NO_CONTENT : HTTP_CODE_CREATED;
wfree(wp->putname);
wp->putname = websTempFile(ME_GOAHEAD_PUT_DIR, "put");
if ((wp->putfd = open(wp->putname, O_BINARY | O_WRONLY | O_CREAT | O_BINARY, 0644)) < 0) {
error("Cannot create PUT filename %s", wp->putname);
websError(wp, HTTP_CODE_INTERNAL_SERVER_ERROR, "Cannot create the put URI");
wfree(wp->putname);
return 1;
}
}
#endif
return 1;
}
/*
Parse the first line of a HTTP request
*/
static void parseFirstLine(Webs *wp)
{
char *op, *protoVer, *url, *host, *query, *path, *port, *ext, *buf;
int listenPort;
assert(wp);
assert(websValid(wp));
/*
Determine the request type: GET, HEAD or POST
*/
op = getToken(wp, NULL, TOKEN_WORD);
if (op == NULL || *op == '\0') {
websError(wp, HTTP_CODE_NOT_FOUND | WEBS_CLOSE, "Bad HTTP request");
return;
}
wp->method = supper(sclone(op));
url = getToken(wp, NULL, TOKEN_URI_VALUE);
trace(2, "http.c 983 The url is %s", url);
if (url == NULL || *url == '\0') {
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE, "Bad HTTP request");
return;
}
if (strlen(url) > ME_GOAHEAD_LIMIT_URI) {
websError(wp, HTTP_CODE_REQUEST_URL_TOO_LARGE | WEBS_CLOSE, "URI too big");
return;
}
protoVer = getToken(wp, "\r\n", TOKEN_WORD);
if (protoVer == NULL || *protoVer == '\0') {
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE, "Bad HTTP request");
return;
}
if (websGetLogLevel() == 2) {
trace(2, "%s %s %s", wp->method, url, protoVer);
}
/*
Parse the URL and store all the various URL components. websUrlParse returns an allocated buffer in buf which we
must free. We support both proxied and non-proxied requests. Proxied requests will have http://host/ at the
start of the URL. Non-proxied will just be local path names.
*/
host = path = port = query = ext = NULL;
if (websUrlParse(url, &buf, NULL, &host, &port, &path, NULL, NULL, &query) < 0) {
error("Cannot parse URL: %s", url);
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE | WEBS_NOLOG, "Bad URL");
return;
}
// Decode the path and save. This includes the extension.
if ((wp->path = websValidateUriPath(path)) == 0) {
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE | WEBS_NOLOG, "Bad URL");
wfree(buf);
return;
}
wp->url = sclone(url);
if ((ext = strrchr(wp->path, '.')) != NULL) {
wp->ext = sclone(slower(ext));
}
wp->filename = sfmt("%s%s", websGetDocuments(), wp->path);
wp->query = sclone(query);
wp->host = sclone(host);
wp->protocol = wp->flags & WEBS_SECURE ? "https" : "http";
if (smatch(protoVer, "HTTP/1.1")) {
wp->flags |= WEBS_KEEP_ALIVE | WEBS_HTTP11;
} else if (smatch(protoVer, "HTTP/1.0")) {
wp->flags &= ~(WEBS_HTTP11);
} else {
protoVer = "HTTP/1.1";
websError(wp, WEBS_CLOSE | HTTP_CODE_NOT_ACCEPTABLE, "Unsupported HTTP protocol");
}
wp->protoVersion = sclone(protoVer);
if ((listenPort = socketGetPort(wp->listenSid)) >= 0) {
wp->port = listenPort;
} else {
wp->port = atoi(port);
}
trace(2, "http.c 1041 The protoVer is %s", protoVer);
trace(2, "http.c 1042 The wp->filename is %s", wp->filename);
trace(2, "http.c 1043 The wp->query is %s", wp->query);
trace(2, "http.c 1044 The wp->host is %s", wp->host);
trace(2, "http.c 1045 The wp->url is %s", wp->url);
trace(2, "http.c 1045 The wp->path is %s", wp->path);
wfree(buf);
}
/*
Parse a full request
*/
static void parseHeaders(Webs *wp)
{
cchar *prior;
char *combined, *upperKey, *cp, *key, *value, *tok;
int count;
assert(websValid(wp));
/*
Parse the header and create the Http header keyword variables
We rewrite the header as we go for non-local requests. NOTE: this
modifies the header string directly and tokenizes each line with '\0'.
解析报头并创建Http报头关键字变量
我们在处理非本地请求时重写头文件。注意:这个
直接修改头字符串并用'\0'标记每行。
*/
for (count = 0; wp->rxbuf.servp[0] != '\r'; count++) {
if (count >= ME_GOAHEAD_LIMIT_NUM_HEADERS) {
websError(wp, HTTP_CODE_REQUEST_TOO_LARGE | WEBS_CLOSE, "Too many headers");
return;
}
key = getToken(wp, ":", TOKEN_HEADER_KEY);
trace(2, "http.c 1091 The key is %s", key);
if (key == NULL || *key == '\0' || bufLen(&wp->rxbuf) == 0) {
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE, "Bad header format");
return;
}
value = getToken(wp, "\r\n", TOKEN_HEADER_VALUE);
trace(2, "http.c 1093 The value is %s", value);
if (value == NULL || bufLen(&wp->rxbuf) == 0 || wp->rxbuf.servp[0] == '\0') {
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE, "Bad header format");
return;
}
slower(key);
/*
Create a header variable for each line in the header
*/
upperKey = sfmt("HTTP_%s", key);
for (cp = upperKey; *cp; cp++) {
if (*cp == '-') {
*cp = '_';
}
}
supper(upperKey);
if ((prior = websGetVar(wp, upperKey, 0)) != 0) {
combined = sfmt("%s, %s", prior, value);
websSetVar(wp, upperKey, combined);
wfree(combined);
} else {
websSetVar(wp, upperKey, value);
}
wfree(upperKey);
/*
Track the requesting agent (browser) type
*/
if (strcmp(key, "user-agent") == 0) {
wfree(wp->userAgent);
wp->userAgent = sclone(value);
} else if (scaselesscmp(key, "authorization") == 0) {
wfree(wp->authType);
wp->authType = sclone(value);
ssplit(wp->authType, " \t", &tok);
wfree(wp->authDetails);
wp->authDetails = sclone(tok);
slower(wp->authType);
} else if (strcmp(key, "connection") == 0) {
slower(value);
if (strcmp(value, "keep-alive") == 0) {
wp->flags |= WEBS_KEEP_ALIVE;
} else if (strcmp(value, "close") == 0) {
wp->flags &= ~WEBS_KEEP_ALIVE;
}
} else if (strcmp(key, "content-length") == 0) {
if ((wp->rxLen = atoi(value)) < 0) {
websError(wp, HTTP_CODE_REQUEST_TOO_LARGE | WEBS_CLOSE, "Invalid content length");
return;
}
if (smatch(wp->method, "PUT")) {
if (wp->rxLen > ME_GOAHEAD_LIMIT_PUT) {
websError(wp, HTTP_CODE_REQUEST_TOO_LARGE | WEBS_CLOSE, "Too big");
return;
}
} else {
if (wp->rxLen > ME_GOAHEAD_LIMIT_POST) {
websError(wp, HTTP_CODE_REQUEST_TOO_LARGE | WEBS_CLOSE, "Too big");
return;
}
}
if (!smatch(wp->method, "HEAD")) {
wp->rxRemaining = wp->rxLen;
}
} else if (strcmp(key, "content-type") == 0) {
wfree(wp->contentType);
wp->contentType = sclone(value);
if (strstr(value, "application/x-www-form-urlencoded")) {
wp->flags |= WEBS_FORM;
} else if (strstr(value, "application/json")) {
wp->flags |= WEBS_JSON;
} else if (strstr(value, "multipart/form-data")) {
wp->flags |= WEBS_UPLOAD;
}
} else if (strcmp(key, "cookie") == 0) {
/* Should be only one cookie header really with semicolon delimmited key/value pairs */
wp->flags |= WEBS_COOKIE;
if (wp->cookie) {
char *prior = wp->cookie;
wp->cookie = sfmt("%s; %s", prior, value);
wfree(prior);
} else {
wp->cookie = sclone(value);
}
} else if (strcmp(key, "host") == 0) {
if ((int) strspn(value, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-.[]:")
< (int) slen(value)) {
websError(wp, WEBS_CLOSE | HTTP_CODE_BAD_REQUEST, "Bad host header");
return;
}
wfree(wp->host);
wp->host = sclone(value);
} else if (strcmp(key, "if-modified-since") == 0) {
if ((cp = strchr(value, ';')) != NULL) {
*cp = '\0';
}
websParseDateTime(&wp->since, value, 0);
/*
Yes Veronica, the HTTP spec does misspell Referrer
*/
} else if (strcmp(key, "referer") == 0) {
wfree(wp->referrer);
trace(2, "http.c 1203 The value is %s------------",value);
wp->referrer = sclone(value);
} else if (strcmp(key, "transfer-encoding") == 0) {
if (scaselesscmp(value, "chunked") == 0) {
wp->rxChunkState = WEBS_CHUNK_START;
wp->rxRemaining = MAXINT;
}
}
}
if (!wp->rxChunkState) {
/*
Step over "\r\n" after headers.
Don't do this if chunked so that chunking can parse a single chunk delimiter of "\r\nSIZE ...\r\n"
*/
if (bufLen(&wp->rxbuf) < 2 || wp->rxbuf.servp[0] != '\r' || wp->rxbuf.servp[1] != '\n') {
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE, "Bad header termination");
return;
}
wp->rxbuf.servp += 2;
}
wp->eof = (wp->rxRemaining == 0);
trace(2, "http.c 1214 The wp->host is %s------------", wp->host);
trace(2, "http.c 1215 The wp->userAgent is %s------------", wp->userAgent);
trace(2, "http.c 1216 The wp->rxbuf.servp is %s------------", wp->rxbuf.servp);
trace(2, "http.c 1217 The wp->referrer is %s------------", wp->referrer);
trace(2, "http.c 1218 The upperKey is %s------------",upperKey);
}
static bool processContent(Webs *wp)
{
bool canProceed;
if (!wp->eof) {
canProceed = filterChunkData(wp);
if (!canProceed || wp->finalized) {
return canProceed;
}
#if ME_GOAHEAD_UPLOAD
if (wp->flags & WEBS_UPLOAD) {
canProceed = websProcessUploadData(wp);
if (!canProceed || wp->finalized) {
return canProceed;
}
}
#endif
#if !ME_ROM
if (wp->putfd >= 0) {
canProceed = websProcessPutData(wp);
if (!canProceed || wp->finalized) {
return canProceed;
}
}
#endif
#if ME_GOAHEAD_CGI
if (wp->cgifd >= 0) {
canProceed = websProcessCgiData(wp);
if (!canProceed || wp->finalized) {
return canProceed;
}
}
#endif
}
if (wp->eof) {
wp->state = WEBS_READY;
/*
Prevent reading content from the next request
The handler may not have been created if all the content was read in the initial read. No matter.
*/
socketDeleteHandler(wp->sid);
canProceed = 1;
}
return canProceed;
}
/*
Always called after data is consumed from the input buffer
*/
PUBLIC void websConsumeInput(Webs *wp, ssize nbytes)
{
assert(wp);
assert(nbytes >= 0);
assert(bufLen(&wp->input) >= nbytes);
if (nbytes <= 0) {
return;
}
bufAdjustStart(&wp->input, nbytes);
if (bufLen(&wp->input) == 0) {
bufReset(&wp->input);
}
}
static bool filterChunkData(Webs *wp)
{
WebsBuf *rxbuf;
ssize chunkSize;
char *start, *cp;
ssize len, nbytes;
int bad;
assert(wp);
assert(wp->rxbuf.buf);
rxbuf = &wp->rxbuf;
while (bufLen(rxbuf) > 0) {
switch (wp->rxChunkState) {
case WEBS_CHUNK_UNCHUNKED:
len = min(wp->rxRemaining, bufLen(rxbuf));
bufPutBlk(&wp->input, rxbuf->servp, len);
bufAddNull(&wp->input);
bufAdjustStart(rxbuf, len);
bufCompact(rxbuf);
wp->rxRemaining -= len;
if (wp->rxRemaining <= 0) {
wp->eof = 1;
}
assert(wp->rxRemaining >= 0);
return 1;
case WEBS_CHUNK_START:
/*
Expect: "\r\nSIZE.*\r\n"
*/
if (bufLen(rxbuf) < 5) {
return 0;
}
start = rxbuf->servp;
bad = (start[0] != '\r' || start[1] != '\n');
for (cp = &start[2]; cp < rxbuf->endp && *cp != '\n'; cp++) {}
if (*cp != '\n' && (cp - start) < 80) {
/* Insufficient data */
return 0;
}
bad += (cp[-1] != '\r' || cp[0] != '\n');
if (bad) {
websError(wp, WEBS_CLOSE | HTTP_CODE_BAD_REQUEST, "Bad chunk specification");
return 1;
}
chunkSize = hextoi(&start[2]);
if (!isxdigit((uchar) start[2]) || chunkSize < 0) {
websError(wp, WEBS_CLOSE | HTTP_CODE_BAD_REQUEST, "Bad chunk specification");
return 1;
}
if (chunkSize == 0) {
/* On the last chunk, consume the final "\r\n" */
if ((cp + 2) >= rxbuf->endp) {
/* Insufficient data */
return 0;
}
cp += 2;
bad += (cp[-1] != '\r' || cp[0] != '\n');
if (bad) {
websError(wp, WEBS_CLOSE | HTTP_CODE_BAD_REQUEST, "Bad final chunk specification");
return 1;
}
}
bufAdjustStart(rxbuf, cp - start + 1);
wp->rxChunkSize = chunkSize;
wp->rxRemaining = chunkSize;
if (chunkSize == 0) {
#if ME_GOAHEAD_LEGACY
wfree(wp->query);
wp->query = sclone(bufStart(&wp->input));
#endif
wp->eof = 1;
return 1;
}
trace(7, "chunkFilter: start incoming chunk of %d bytes", chunkSize);
wp->rxChunkState = WEBS_CHUNK_DATA;
break;
case WEBS_CHUNK_DATA:
len = min(bufLen(rxbuf), wp->rxRemaining);
nbytes = min(bufRoom(&wp->input), len);
if (len > 0 && (nbytes = bufPutBlk(&wp->input, rxbuf->servp, nbytes)) == 0) {
websError(wp, HTTP_CODE_REQUEST_TOO_LARGE | WEBS_CLOSE, "Too big");
return 1;
}
bufAddNull(&wp->input);
bufAdjustStart(rxbuf, nbytes);
wp->rxRemaining -= nbytes;
if (wp->rxRemaining <= 0) {
wp->rxChunkState = WEBS_CHUNK_START;
bufCompact(rxbuf);
}
break;
}
}
return 0;
}
/*
Basic event loop. SocketReady returns true when a socket is ready for service. SocketSelect will block until an
event occurs. SocketProcess will actually do the servicing.
*/
PUBLIC void websServiceEvents(int *finished)
{
int delay, nextEvent;
if (finished) {
*finished = 0;
}
delay = 0;
while (!finished || !*finished) {
if (socketSelect(-1, delay)) {
socketProcess();
}
#if ME_GOAHEAD_CGI
delay = websCgiPoll();
#else
delay = MAXINT;
#endif
nextEvent = websRunEvents();
delay = min(delay, nextEvent);
}
}
/*
NOTE: the vars variable is modified
*/
static void addFormVars(Webs *wp, char *vars)
{
WebsKey *sp;
cchar *prior;
char *keyword, *value, *tok;
assert(wp);
assert(vars);
keyword = stok(vars, "&", &tok);
while (keyword != NULL) {
if ((value = strchr(keyword, '=')) != NULL) {
*value++ = '\0';
websDecodeUrl(keyword, keyword, strlen(keyword));
websDecodeUrl(value, value, strlen(value));
} else {
value = "";
}
if (*keyword) {
/*
If keyword has already been set, append the new value to what has been stored.
*/
if ((prior = websGetVar(wp, keyword, NULL)) != 0) {
sp = websSetVarFmt(wp, keyword, "%s %s", prior, value);
} else {
sp = websSetVar(wp, keyword, value);
}
/* Flag as untrusted keyword by setting arg to 1. This is used by CGI to prefix this keyword */
sp->arg = 1;
}
keyword = stok(NULL, "&", &tok);
}
}
/*
Set the variable (CGI) environment for this request. Create variables for all standard CGI variables. Also decode
the query string and create a variable for each name=value pair.
*/
PUBLIC void websSetEnv(Webs *wp)
{
assert(wp);
assert(websValid(wp));
websSetVar(wp, "AUTH_TYPE", wp->authType);
websSetVarFmt(wp, "CONTENT_LENGTH", "%d", wp->rxLen);
websSetVar(wp, "CONTENT_TYPE", wp->contentType);
if (wp->route && wp->route->dir) {
websSetVar(wp, "DOCUMENT_ROOT", wp->route->dir);
}
websSetVar(wp, "GATEWAY_INTERFACE", "CGI/1.1");
websSetVar(wp, "PATH_INFO", wp->path);
websSetVar(wp, "PATH_TRANSLATED", wp->filename);
websSetVar(wp, "QUERY_STRING", wp->query);
websSetVar(wp, "REMOTE_ADDR", wp->ipaddr);
websSetVar(wp, "REMOTE_USER", wp->username);
websSetVar(wp, "REMOTE_HOST", wp->ipaddr);
websSetVar(wp, "REQUEST_METHOD", wp->method);
websSetVar(wp, "REQUEST_TRANSPORT", wp->protocol);
websSetVar(wp, "REQUEST_URI", wp->path);
websSetVar(wp, "SERVER_ADDR", wp->ifaddr);
websSetVar(wp, "SERVER_HOST", websHost);
websSetVar(wp, "SERVER_NAME", websHost);
websSetVarFmt(wp, "SERVER_PORT", "%d", wp->port);
websSetVar(wp, "SERVER_PROTOCOL", wp->protoVersion);
websSetVar(wp, "SERVER_URL", websHostUrl);
websSetVarFmt(wp, "SERVER_SOFTWARE", "GoAhead/%s", ME_VERSION);
}
PUBLIC void websSetFormVars(Webs *wp)
{
char *data;
if (wp->rxLen > 0 && bufLen(&wp->input) > 0) {
if (wp->flags & WEBS_FORM) {
data = sclone(wp->input.servp);
addFormVars(wp, data);
wfree(data);
}
}
}
PUBLIC void websSetQueryVars(Webs *wp)
{
/*
Decode and create an environment query variable for each query keyword. We split into pairs at each '&', then
split pairs at the '='. Note: we rely on wp->decodedQuery preserving the decoded values in the symbol table.
*/
if (wp->query && *wp->query) {
wfree(wp->decodedQuery);
wp->decodedQuery = sclone(wp->query);
addFormVars(wp, wp->decodedQuery);
}
}
/*
Define a webs (CGI) variable for this connection. Also create in relevant scripting engines. Note: the incoming
value may be volatile.
*/
PUBLIC WebsKey *websSetVarFmt(Webs *wp, cchar *var, cchar *fmt, ...)
{
WebsValue v;
va_list args;
assert(websValid(wp));
assert(var && *var);
if (fmt) {
va_start(args, fmt);
v = valueString(sfmtv(fmt, args), 0);
v.allocated = 1;
va_end(args);
} else {
v = valueString("", 0);
}
return hashEnter(wp->vars, var, v, 0);
}
PUBLIC WebsKey *websSetVar(Webs *wp, cchar *var, cchar *value)
{
WebsValue v;
assert(websValid(wp));
assert(var && *var);
if (value) {
v = valueString(value, VALUE_ALLOCATE);
} else {
v = valueString("", 0);
}
return hashEnter(wp->vars, var, v, 0);
}
/*
Return TRUE if a webs variable exists for this connection.
*/
PUBLIC bool websTestVar(Webs *wp, cchar *var)
{
WebsKey *sp;
assert(websValid(wp));
assert(var && *var);
if (var == NULL || *var == '\0') {
return 0;
}
if ((sp = hashLookup(wp->vars, var)) == NULL) {
return 0;
}
return 1;
}
/*
Get a webs variable but return a default value if string not found. Note, defaultGetValue can be NULL to permit
testing existence.
*/
PUBLIC cchar *websGetVar(Webs *wp, cchar *var, cchar *defaultGetValue)
{
WebsKey *sp;
assert(websValid(wp));
assert(var && *var);
if ((sp = hashLookup(wp->vars, var)) != NULL) {
assert(sp->content.type == string);
if (sp->content.value.string) {
return sp->content.value.string;
} else {
return "";
}
}
return defaultGetValue;
}
/*
Return TRUE if a webs variable is set to a given value
*/
PUBLIC int websCompareVar(Webs *wp, cchar *var, cchar *value)
{
assert(websValid(wp));
assert(var && *var);
if (strcmp(value, websGetVar(wp, var, " __UNDEF__ ")) == 0) {
return 1;
}
return 0;
}
/*
Cancel the request timeout. Note may be called multiple times.
*/
PUBLIC void websCancelTimeout(Webs *wp)
{
assert(websValid(wp));
if (wp->timeout >= 0) {
websStopEvent(wp->timeout);
wp->timeout = -1;
}
}
/*
Output a HTTP response back to the browser. If redirect is set to a URL, the browser will be sent to this location.
*/
PUBLIC void websResponse(Webs *wp, int code, cchar *message)
{
ssize len;
assert(websValid(wp));
websSetStatus(wp, code);
if (!smatch(wp->method, "HEAD") && message && *message) {
len = slen(message);
websWriteHeaders(wp, len + 2, 0);
websWriteEndHeaders(wp);
websWriteBlock(wp, message, len);
websWriteBlock(wp, "\r\n", 2);
websFlush(wp, 1);
} else {
websWriteHeaders(wp, 0, 0);
websWriteEndHeaders(wp);
}
websDone(wp);
}
static char *makeUri(cchar *scheme, cchar *host, int port, cchar *path)
{
if (port <= 0) {
port = smatch(scheme, "https") ? defaultSslPort : defaultHttpPort;
}
if (port == 80 || port == 443) {
return sfmt("%s://%s%s", scheme, host, path);
}
return sfmt("%s://%s:%d%s", scheme, host, port, path);
}
/*
Redirect the user to another webs page
*/
PUBLIC void websRedirect(Webs *wp, cchar *uri)
{
char *encoded, *message, *location, *scheme, *host, *pstr;
bool secure, fullyQualified;
ssize len;
int originalPort, port;
assert(websValid(wp));
assert(uri);
message = location = NULL;
originalPort = port = 0;
// host = websHostUrl ? websHostUrl : wp->ipaddr;
trace(2, "http.c 1698 the host is %s", host);
trace(2, "http.c 1699 the websHostUrl is %s", websHostUrl);
host = websHostUrl ? websHostUrl : wp->ifaddr;//将ipaddr改为ifaddr
trace(2, "http.c 1701 the host is %s", host);
pstr = strchr(host, ']');
pstr = pstr ? pstr : host;
trace(2, "http.c 1702 the pstr is %s", pstr);
if ((pstr = strchr(pstr, ':')) != 0) {
*pstr++ = '\0';
originalPort = atoi(pstr);
}
if (smatch(uri, "http://") || smatch(uri, "https://")) {
/* Protocol switch with existing Uri */
scheme = sncmp(uri, "https", 5) == 0 ? "https" : "http";
uri = location = makeUri(scheme, host, 0, wp->url);
trace(2, "http.c 1708 the location is %s", location);
}
secure = strstr(uri, "https://") != 0;
fullyQualified = strstr(uri, "http://") || strstr(uri, "https://");
if (!fullyQualified) {
port = originalPort;
if (wp->flags & WEBS_SECURE) {
secure = 1;
}
}
scheme = secure ? "https" : "http";
if (port <= 0) {
port = secure ? defaultSslPort : defaultHttpPort;
}
if (strstr(uri, "https:///")) {
/* Short-hand for redirect to https */
uri = location = makeUri(scheme, host, port, &uri[8]);
trace(2, "http.c 1725 the location is %s", location);
} else if (strstr(uri, "http:///")) {
uri = location = makeUri(scheme, host, port, &uri[7]);
trace(2, "http.c 1729 the location is %s", location);
} else if (!fullyQualified) {
uri = location = makeUri(scheme, host, port, uri);
trace(2, "http.c 1733 the location is %s", location);
}
encoded = websEscapeUri(uri);
message = sfmt("<html><head></head><body>\r\n\
This document has moved to a new <a href=\"%s\">location</a>.\r\n\
Please update your documents to reflect the new location.\r\n\
</body></html>\r\n", encoded);
len = slen(message);
websSetStatus(wp, HTTP_CODE_MOVED_TEMPORARILY);
websWriteHeaders(wp, len + 2, uri);
websWriteEndHeaders(wp);
websWriteBlock(wp, message, len);
websWriteBlock(wp, "\r\n", 2);
websDone(wp);
trace(2, "http.c 1743 the location is %s", location);
trace(2, "http.c 1744 the message is %s", message);
trace(2, "http.c 1745 the encoded is %s", encoded);
wfree(message);
wfree(location);
wfree(encoded);
}
PUBLIC int websRedirectByStatus(Webs *wp, int status)
{
WebsKey *key;
char code[16], *uri;
assert(wp);
assert(status >= 0);
if (wp->route && wp->route->redirects >= 0) {
itosbuf(code, sizeof(code), status, 10);
if ((key = hashLookup(wp->route->redirects, code)) != 0) {
uri = key->content.value.string;
} else {
return -1;
}
websRedirect(wp, uri);
} else {
if (status == HTTP_CODE_UNAUTHORIZED) {
websError(wp, status, "Access Denied. User not logged in.");
} else {
websError(wp, status, 0);
}
}
return 0;
}
/*
Escape HTML to escape defined characters (prevent cross-site scripting)
Returns an allocated string.
*/
PUBLIC char *websEscapeHtml(cchar *html)
{
cchar *ip;
char *result, *op;
int len;
if (!html) {
return sclone("");
}
for (len = 1, ip = html; *ip; ip++, len++) {
if (charMatch[(int) (uchar) *ip] & WEBS_ENCODE_HTML) {
len += 5;
}
}
if ((result = walloc(len)) == 0) {
return 0;
}
/*
Leave room for the biggest expansion
*/
op = result;
while (*html != '\0') {
if (charMatch[(uchar) *html] & WEBS_ENCODE_HTML) {
if (*html == '&') {
strcpy(op, "&");
op += 5;
} else if (*html == '<') {
strcpy(op, "<");
op += 4;
} else if (*html == '>') {
strcpy(op, ">");
op += 4;
} else if (*html == '#') {
strcpy(op, "#");
op += 5;
} else if (*html == '(') {
strcpy(op, "(");
op += 5;
} else if (*html == ')') {
strcpy(op, ")");
op += 5;
} else if (*html == '"') {
strcpy(op, """);
op += 6;
} else if (*html == '\'') {
strcpy(op, "'");
op += 5;
} else {
assert(0);
}
html++;
} else {
*op++ = *html++;
}
}
assert(op < &result[len]);
*op = '\0';
return result;
}
/*
Uri encode by encoding special characters with hex equivalents. Return an allocated string.
*/
PUBLIC char *websEscapeUri(cchar *uri)
{
static cchar hexTable[] = "0123456789ABCDEF";
uchar c;
cchar *ip;
char *result, *op;
int len;
assert(uri);
if (!uri) {
return sclone("");
}
for (len = 1, ip = uri; *ip; ip++, len++) {
if (charMatch[(uchar) *ip] & WEBS_ENCODE_URI) {
len += 2;
}
}
if ((result = walloc(len)) == 0) {
return 0;
}
op = result;
while ((c = (uchar) (*uri++)) != 0) {
if (charMatch[c] & WEBS_ENCODE_URI) {
*op++ = '%';
*op++ = hexTable[c >> 4];
*op++ = hexTable[c & 0xf];
} else {
*op++ = c;
}
}
assert(op < &result[len]);
*op = '\0';
return result;
}
PUBLIC int websWriteHeader(Webs *wp, cchar *key, cchar *fmt, ...)
{
va_list vargs;
char *buf;
assert(websValid(wp));
if (!(wp->flags & WEBS_RESPONSE_TRACED)) {
wp->flags |= WEBS_RESPONSE_TRACED;
trace(3 | WEBS_RAW_MSG, "\n>>> Response\n");
}
if (key) {
if (websWriteBlock(wp, key, strlen(key)) < 0) {
return -1;
}
if (websWriteBlock(wp, ": ", 2) < 0) {
return -1;
}
trace(3 | WEBS_RAW_MSG, "%s: ", key);
}
if (fmt) {
va_start(vargs, fmt);
if ((buf = sfmtv(fmt, vargs)) == 0) {
error("websWrite lost data, buffer overflow");
return -1;
}
va_end(vargs);
trace(3 | WEBS_RAW_MSG, "%s", buf);
if (websWriteBlock(wp, buf, strlen(buf)) < 0) {
return -1;
}
wfree(buf);
if (websWriteBlock(wp, "\r\n", 2) != 2) {
return -1;
}
}
trace(3 | WEBS_RAW_MSG, "\r\n");
return 0;
}
PUBLIC void websSetStatus(Webs *wp, int code)
{
wp->code = (code & WEBS_CODE_MASK);
if (code & WEBS_CLOSE) {
wp->flags &= ~WEBS_KEEP_ALIVE;
}
}
/*
Write a set of headers. Does not write the trailing blank line so callers can add more headers.
Set length to -1 if unknown and transfer-chunk-encoding will be employed.
*/
PUBLIC void websWriteHeaders(Webs *wp, ssize length, cchar *location)
{
WebsKey *cookie, *key, *next;
char *date, *protoVersion;
assert(websValid(wp));
if (!(wp->flags & WEBS_HEADERS_CREATED)) {
protoVersion = wp->protoVersion;
if (!protoVersion) {
protoVersion = "HTTP/1.0";
wp->flags &= ~WEBS_KEEP_ALIVE;
}
websWriteHeader(wp, NULL, "%s %d %s", protoVersion, wp->code, websErrorMsg(wp->code));
#if !ME_GOAHEAD_STEALTH
websWriteHeader(wp, "Server", "GoAhead-http");
#endif
if ((date = websGetDateString(NULL)) != NULL) {
websWriteHeader(wp, "Date", "%s", date);
wfree(date);
}
if (wp->authResponse) {
websWriteHeader(wp, "WWW-Authenticate", "%s", wp->authResponse);
}
if (length >= 0) {
if (smatch(wp->method, "HEAD")) {
websWriteHeader(wp, "Content-Length", "%d", (int) length);
} else if (!((100 <= wp->code && wp->code <= 199) || wp->code == 204 || wp->code == 304)) {
/* Server must not emit a content length header for 1XX, 204 and 304 status */
websWriteHeader(wp, "Content-Length", "%d", (int) length);
}
}
wp->txLen = length;
if (wp->txLen < 0) {
websWriteHeader(wp, "Transfer-Encoding", "chunked");
}
if (wp->flags & WEBS_KEEP_ALIVE) {
websWriteHeader(wp, "Connection", "keep-alive");
} else {
websWriteHeader(wp, "Connection", "close");
}
if (location) {
websWriteHeader(wp, "Location", "%s", location);
} else if ((key = hashLookup(websMime, wp->ext)) != 0) {
websWriteHeader(wp, "Content-Type", "%s", key->content.value.string);
}
for (cookie = hashFirst(wp->responseCookies); cookie; cookie = next) {
websWriteHeader(wp, "Set-Cookie", "%s", cookie->content.value.string);
websWriteHeader(wp, "Cache-Control", "%s", "no-cache=\"set-cookie\"");
next = hashNext(wp->responseCookies, cookie);
}
#if defined(ME_GOAHEAD_CLIENT_CACHE)
if (wp->ext) {
char *etok = sfmt("%s,", &wp->ext[1]);
if (strstr(ME_GOAHEAD_CLIENT_CACHE ",", etok)) {
websWriteHeader(wp, "Cache-Control", "public, max-age=%d", ME_GOAHEAD_CLIENT_CACHE_LIFESPAN);
}
wfree(etok);
}
#endif
#ifdef ME_GOAHEAD_XFRAME_HEADER
if (*ME_GOAHEAD_XFRAME_HEADER) {
websWriteHeader(wp, "X-Frame-Options", "%s", ME_GOAHEAD_XFRAME_HEADER);
}
#endif
}
}
PUBLIC void websWriteEndHeaders(Webs *wp)
{
assert(wp);
/*
By omitting the "\r\n" delimiter after the headers, chunks can emit "\r\nSize\r\n" as a single chunk delimiter
*/
if (wp->txLen >= 0) {
websWriteBlock(wp, "\r\n", 2);
}
wp->flags |= WEBS_HEADERS_CREATED;
if (wp->txLen < 0) {
wp->flags |= WEBS_CHUNKING;
}
}
PUBLIC void websSetTxLength(Webs *wp, ssize length)
{
assert(wp);
wp->txLen = length;
}
/*
Do formatted output to the browser. This is the public Javascript and form write procedure.
*/
PUBLIC ssize websWrite(Webs *wp, cchar *fmt, ...)
{
va_list vargs;
char *buf;
ssize rc;
assert(websValid(wp));
assert(fmt && *fmt);
va_start(vargs, fmt);
buf = NULL;
rc = 0;
if ((buf = sfmtv(fmt, vargs)) == 0) {
error("websWrite lost data, buffer overflow");
}
va_end(vargs);
assert(buf);
if (buf) {
rc = websWriteBlock(wp, buf, strlen(buf));
wfree(buf);
}
return rc;
}
/*
Non-blocking write to socket.
Returns number of bytes written. Returns -1 on errors. May return short.
*/
PUBLIC ssize websWriteSocket(Webs *wp, cchar *buf, ssize size)
{
ssize written;
assert(wp);
assert(buf);
assert(size >= 0);
if (wp->flags & WEBS_CLOSED) {
return -1;
}
#if ME_COM_SSL
if (wp->flags & WEBS_SECURE) {
if ((written = sslWrite(wp, (void*) buf, size)) < 0) {
return written;
}
} else
#endif
if ((written = socketWrite(wp->sid, (void*) buf, size)) < 0) {
return written;
}
wp->written += written;
websNoteRequestActivity(wp);
return written;
}
/*
Write some output using transfer chunk encoding if required.
Returns true if all the data was written. Otherwise return zero.
*/
static bool flushChunkData(Webs *wp)
{
ssize len, written, room;
assert(wp);
while (bufLen(&wp->chunkbuf) > 0) {
/*
Stop if there is not room for a reasonable size chunk.
Subtract 16 to allow for the final trailer.
*/
if ((room = bufRoom(&wp->output) - 16) <= CHUNK_LOW) {
bufGrow(&wp->output, CHUNK_LOW - room + 1);
if ((room = bufRoom(&wp->output) - 16) <= CHUNK_LOW) {
return 0;
}
}
switch (wp->txChunkState) {
default:
case WEBS_CHUNK_START:
/* Select the chunk size so that both the prefix and data will fit */
wp->txChunkLen = min(bufLen(&wp->chunkbuf), room - 16);
fmt(wp->txChunkPrefix, sizeof(wp->txChunkPrefix), "\r\n%x\r\n", wp->txChunkLen);
wp->txChunkPrefixLen = slen(wp->txChunkPrefix);
wp->txChunkPrefixNext = wp->txChunkPrefix;
wp->txChunkState = WEBS_CHUNK_HEADER;
break;
case WEBS_CHUNK_HEADER:
if ((written = bufPutBlk(&wp->output, wp->txChunkPrefixNext, wp->txChunkPrefixLen)) < 0) {
return 0;
} else {
wp->txChunkPrefixNext += written;
wp->txChunkPrefixLen -= written;
if (wp->txChunkPrefixLen <= 0) {
wp->txChunkState = WEBS_CHUNK_DATA;
} else {
return 0;
}
}
break;
case WEBS_CHUNK_DATA:
if (wp->txChunkLen > 0) {
len = min(room, wp->txChunkLen);
if ((written = bufPutBlk(&wp->output, wp->chunkbuf.servp, len)) != len) {
assert(0);
return -1;
}
bufAdjustStart(&wp->chunkbuf, written);
wp->txChunkLen -= written;
if (wp->txChunkLen <= 0) {
wp->txChunkState = WEBS_CHUNK_START;
bufCompact(&wp->chunkbuf);
}
bufAddNull(&wp->output);
}
}
}
return bufLen(&wp->chunkbuf) == 0;
}
/*
Initiate flushing output buffer. Returns true if all data is written to the socket and the buffer is empty.
Returns < 0 for errors
== 0 if there is output remaining to be flushed
== 1 if the output was fully written to the socket
*/
PUBLIC int websFlush(Webs *wp, bool block)
{
WebsBuf *op;
ssize nbytes, written;
int errCode, wasBlocking;
if (block) {
wasBlocking = socketSetBlock(wp->sid, 1);
}
op = &wp->output;
if (wp->flags & WEBS_CHUNKING) {
trace(6, "websFlush chunking finalized %d", wp->finalized);
if (flushChunkData(wp) && wp->finalized) {
trace(6, "websFlush: write chunk trailer");
bufPutStr(op, "\r\n0\r\n\r\n");
bufAddNull(op);
wp->flags &= ~WEBS_CHUNKING;
}
}
trace(6, "websFlush: buflen %d", bufLen(op));
written = 0;
while ((nbytes = bufLen(op)) > 0) {
if ((written = websWriteSocket(wp, op->servp, nbytes)) < 0) {
errCode = socketGetError(wp->sid);
if (errCode == EWOULDBLOCK || errCode == EAGAIN) {
/* Not an error */
written = 0;
break;
}
/*
Connection Error
*/
wp->flags &= ~WEBS_KEEP_ALIVE;
bufFlush(op);
wp->state = WEBS_COMPLETE;
break;
} else if (written == 0) {
break;
}
trace(6, "websFlush: wrote %d to socket", written);
bufAdjustStart(op, written);
bufCompact(op);
nbytes = bufLen(op);
}
assert(websValid(wp));
if (bufLen(op) == 0 && wp->finalized) {
wp->state = WEBS_COMPLETE;
}
if (block) {
socketSetBlock(wp->sid, wasBlocking);
}
if (written < 0) {
/* I/O Error */
return -1;
}
return bufLen(op) == 0;
}
/*
Respond to a writable event. First write any tx buffer by calling websFlush.
Then write body data if writeProc is defined. If all written, ensure transition to complete state.
Calls websPump() to advance state.
*/
static void writeEvent(Webs *wp)
{
WebsBuf *op;
op = &wp->output;
if (bufLen(op) > 0) {
websFlush(wp, 0);
}
if (bufLen(op) == 0 && wp->writeData) {
(wp->writeData)(wp);
}
if (wp->state != WEBS_RUNNING) {
websPump(wp);
}
}
PUBLIC void websSetBackgroundWriter(Webs *wp, WebsWriteProc proc)
{
WebsSocket *sp;
WebsBuf *op;
assert(proc);
wp->writeData = proc;
op = &wp->output;
if (bufLen(op) > 0) {
websFlush(wp, 0);
}
if (bufLen(op) == 0) {
(wp->writeData)(wp);
}
if (wp->sid >= 0 && wp->state < WEBS_COMPLETE) {
sp = socketPtr(wp->sid);
socketCreateHandler(wp->sid, sp->handlerMask | SOCKET_WRITABLE, socketEvent, wp);
}
}
/*
Write a block of data of length to the user's browser. Output is buffered and flushed via websFlush.
This routine will never return "short". i.e. it will return the requested size to write or -1.
Buffer data. Will flush as required. May return -1 on write errors.
*/
PUBLIC ssize websWriteBlock(Webs *wp, cchar *buf, ssize size)
{
WebsBuf *op;
ssize written, thisWrite, len, room;
assert(wp);
assert(websValid(wp));
assert(buf);
assert(size >= 0);
if (wp->state >= WEBS_COMPLETE) {
return -1;
}
op = (wp->flags & WEBS_CHUNKING) ? &wp->chunkbuf : &wp->output;
written = len = 0;
while (size > 0 && wp->state < WEBS_COMPLETE) {
if (bufRoom(op) < size) {
/*
This will do a blocking I/O write. Will only ever fail for I/O errors.
*/
if (websFlush(wp, 1) < 0) {
return -1;
}
}
if ((room = bufRoom(op)) == 0) {
break;
}
thisWrite = min(room, size);
bufPutBlk(op, buf, thisWrite);
size -= thisWrite;
buf += thisWrite;
written += thisWrite;
}
bufAddNull(op);
if (wp->state >= WEBS_COMPLETE && written == 0) {
return -1;
}
return written;
}
/*
Decode a URL (or part thereof). Allows insitu decoding.
*/
PUBLIC void websDecodeUrl(char *decoded, char *input, ssize len)
{
char *ip, *op;
int num, i, c;
assert(decoded);
assert(input);
if (!decoded) {
return;
}
if (!input) {
*decoded = '\0';
return;
}
if (len < 0) {
len = strlen(input);
}
op = decoded;
for (ip = input; *ip && len > 0; ip++, op++) {
if (*ip == '+') {
*op = ' ';
} else if (*ip == '%' && isxdigit((uchar) ip[1]) && isxdigit((uchar) ip[2]) &&
!(ip[1] == '0' && ip[2] == '0')) {
/*
Convert %nn to a single character
*/
ip++;
for (i = 0, num = 0; i < 2; i++, ip++) {
c = tolower((uchar) *ip);
if (c >= 'a' && c <= 'f') {
num = (num * 16) + 10 + c - 'a';
} else {
num = (num * 16) + c - '0';
}
}
*op = (char) num;
ip--;
} else {
*op = *ip;
}
len--;
}
*op = '\0';
}
#if ME_GOAHEAD_ACCESS_LOG && !ME_ROM
/*
Output a log message in Common Log Format: See http://httpd.apache.org/docs/1.3/logs.html#common
*/
static void logRequest(Webs *wp, int code)
{
char *buf, timeStr[28], zoneStr[6], dataStr[16];
ssize len;
WebsTime timer;
struct tm localt;
#if WINDOWS
DWORD dwRet;
TIME_ZONE_INFORMATION tzi;
#endif
assert(wp);
time(&timer);
#if WINDOWS
localtime_s(&localt, &timer);
#else
localtime_r(&timer, &localt);
#endif
strftime(timeStr, sizeof(timeStr), "%d/%b/%Y:%H:%M:%S", &localt);
timeStr[sizeof(timeStr) - 1] = '\0';
#if WINDOWS
dwRet = GetTimeZoneInformation(&tzi);
fmt(zoneStr, sizeof(zoneStr), "%+03d00", -(int) (tzi.Bias/60));
#elif !VXWORKS
fmt(zoneStr, sizeof(zoneStr), "%+03d00", (int) (localt.tm_gmtoff/3600));
#else
zoneStr[0] = '\0';
#endif
zoneStr[sizeof(zoneStr) - 1] = '\0';
if (wp->written != 0) {
fmt(dataStr, sizeof(dataStr), "%Ld", wp->written);
dataStr[sizeof(dataStr) - 1] = '\0';
} else {
dataStr[0] = '-'; dataStr[1] = '\0';
}
buf = NULL;
buf = sfmt("%s - %s [%s %s] \"%s %s %s\" %d %s\n",
wp->ipaddr, wp->username == NULL ? "-" : wp->username,
timeStr, zoneStr, wp->method, wp->path, wp->protoVersion, code, dataStr);
len = strlen(buf);
write(accessFd, buf, len);
wfree(buf);
}
#endif
/*
Request and connection timeout. The timeout triggers if we have not read any data from the
users browser in the last WEBS_TIMEOUT period. If we have heard from the browser, simply
re-issue the timeout.
*/
static void checkTimeout(void *arg, int id)
{
Webs *wp;
int elapsed, delay;
wp = (Webs*) arg;
assert(websValid(wp));
elapsed = getTimeSinceMark(wp) * 1000;
if (websDebug) {
websRestartEvent(id, (int) WEBS_TIMEOUT);
return;
}
if (elapsed >= WEBS_TIMEOUT) {
if (!(wp->flags & WEBS_HEADERS_CREATED)) {
if (wp->state > WEBS_BEGIN) {
websError(wp, HTTP_CODE_REQUEST_TIMEOUT, "Request exceeded timeout");
} else {
websError(wp, HTTP_CODE_REQUEST_TIMEOUT, "Idle connection closed");
}
}
wp->state = WEBS_COMPLETE;
complete(wp, 0);
websFree(wp);
/* WARNING: wp not valid here */
return;
}
delay = WEBS_TIMEOUT - elapsed;
assert(delay > 0);
websRestartEvent(id, delay);
}
static int setLocalHost(void)
{
struct in_addr intaddr;
char host[128], *ipaddr;
if (gethostname(host, sizeof(host)) < 0) {
error("Cannot get hostname: errno %d", errno);
return -1;
}
#if VXWORKS
intaddr.s_addr = (ulong) hostGetByName(host);
ipaddr = inet_ntoa(intaddr);
websSetIpAddr(ipaddr);
websSetHost(ipaddr);
#if _WRS_VXWORKS_MAJOR < 6
free(ipaddr);
#endif
#elif ECOS
ipaddr = inet_ntoa(eth0_bootp_data.bp_yiaddr);
websSetIpAddr(ipaddr);
websSetHost(ipaddr);
#elif TIDSP
{
struct hostent *hp;
if ((hp = gethostbyname(host)) == NULL) {
error("Cannot get host address for host %s: errno %d", host, errno);
return -1;
}
memcpy((char*) &intaddr, (char *) hp->h_addr[0], (size_t) hp->h_length);
ipaddr = inet_ntoa(intaddr);
websSetIpAddr(ipaddr);
websSetHost(ipaddr);
}
#elif MACOSX
{
struct hostent *hp;
if ((hp = gethostbyname(host)) == NULL) {
if ((hp = gethostbyname(sfmt("%s.local", host))) == NULL) {
error("Cannot get host address for host %s: errno %d", host, errno);
return -1;
}
}
memcpy((char*) &intaddr, (char *) hp->h_addr_list[0], (size_t) hp->h_length);
ipaddr = inet_ntoa(intaddr);
websSetIpAddr(ipaddr);
websSetHost(ipaddr);
}
#else
{
struct hostent *hp;
if ((hp = gethostbyname(host)) == NULL) {
error("Cannot get host address for host %s: errno %d", host, errno);
return -1;
}
memcpy((char*) &intaddr, (char *) hp->h_addr_list[0], (size_t) hp->h_length);
ipaddr = inet_ntoa(intaddr);
/* ipaddr="0.0.0.0";*/
websSetIpAddr(ipaddr);
websSetHost(ipaddr);
trace(2, "http.c 2482 the ipaddr is : %s", ipaddr);
}
#endif
trace(2, "http.c 2477 the hostname is : %s", host);
trace(2, "http.c 2478 the ipaddr is : %s", ipaddr);
trace(2, "http.c 2479 the websIpAddr is :%s", websIpAddr);
return 0;
}
PUBLIC void websSetHost(cchar *host)
{
scopy(websHost, sizeof(websHost), host);
}
PUBLIC void websSetHostUrl(cchar *url)
{
assert(url && *url);
wfree(websHostUrl);
websHostUrl = sclone(url);
}
PUBLIC void websSetIpAddr(cchar *ipaddr)
{
assert(ipaddr && *ipaddr);
scopy(websIpAddr, sizeof(websIpAddr), ipaddr);
}
#if ME_GOAHEAD_LEGACY
PUBLIC void websSetRequestFilename(Webs *wp, cchar *filename)
{
assert(websValid(wp));
assert(filename && *filename);
wfree(wp->filename);
wp->filename = sclone(filename);
websSetVar(wp, "PATH_TRANSLATED", wp->filename);
}
#endif
PUBLIC int websRewriteRequest(Webs *wp, cchar *url)
{
char *buf, *path;
wfree(wp->url);
wp->url = sclone(url);
wfree(wp->path);
wp->path = 0;
if (websUrlParse(url, &buf, NULL, NULL, NULL, &path, NULL, NULL, NULL) < 0) {
return -1;
}
wp->path = sclone(path);
wfree(wp->filename);
wp->filename = 0;
wp->flags |= WEBS_REROUTE;
wfree(buf);
return 0;
}
PUBLIC bool websValid(Webs *wp)
{
int wid;
for (wid = 0; wid < websMax; wid++) {
if (wp == webs[wid]) {
return 1;
}
}
return 0;
}
/*
Build an ASCII time string. If sbuf is NULL we use the current time, else we use the last modified time of sbuf;
*/
PUBLIC char *websGetDateString(WebsFileInfo *sbuf)
{
WebsTime now;
struct tm tm;
char *cp;
if (sbuf == NULL) {
time(&now);
} else {
now = sbuf->mtime;
}
#if ME_UNIX_LIKE
gmtime_r(&now, &tm);
#else
{
struct tm *tp;
tp = gmtime(&now);
tm = *tp;
}
#endif
if ((cp = asctime(&tm)) != NULL) {
cp[strlen(cp) - 1] = '\0';
return sclone(cp);
}
return NULL;
}
/*
Take not of the request activity and mark the time. Set a timestamp so that, later, we can return the number of seconds
since we made the mark.
*/
PUBLIC void websNoteRequestActivity(Webs *wp)
{
wp->timestamp = time(0);
}
/*
Get the number of seconds since the last mark.
*/
static int getTimeSinceMark(Webs *wp)
{
return (int) (time(0) - wp->timestamp);
}
PUBLIC bool websValidUriChars(cchar *uri)
{
ssize pos;
if (uri == 0 || *uri == 0) {
return 1;
}
pos = strspn(uri, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~:/?#[]@!$&'()*+,;=%");
if (pos < slen(uri)) {
error("Bad character in URI at \"%s\"", &uri[pos]);
return 0;
}
return 1;
}
/*
Parse the URL. A single buffer is allocated to store the parsed URL in *pbuf. This must be freed by the caller.
*/
PUBLIC int websUrlParse(cchar *url, char **pbuf, char **pscheme, char **phost, char **pport, char **ppath, char **pext,
char **preference, char **pquery)
{
char *tok, *delim, *host, *path, *port, *scheme, *reference, *query, *ext, *buf, *buf2;
ssize buflen, ulen, len;
int sep;
assert(pbuf);
if (url == 0) {
url = "";
}
/*
Allocate twice. Need to null terminate the host so have to copy the path.
*/
ulen = strlen(url);
len = ulen + 1;
buflen = len * 2;
if ((buf = walloc(buflen)) == NULL) {
return -1;
}
buf2 = &buf[ulen + 1];
sncopy(buf, len, url, ulen);
sncopy(buf2, len, url, ulen);
url = buf;
scheme = 0;
host = 0;
port = 0;
path = 0;
ext = 0;
query = 0;
reference = 0;
tok = buf;
sep = '/';
/*
[scheme://][hostname[:port]][/path[.ext]][#ref][?query]
First trim query and then reference from the end
*/
if ((query = strchr(tok, '?')) != NULL) {
*query++ = '\0';
}
if ((reference = strchr(tok, '#')) != NULL) {
*reference++ = '\0';
}
/*
[scheme://][hostname[:port]][/path]
*/
if ((delim = strstr(tok, "://")) != 0) {
scheme = tok;
*delim = '\0';
tok = &delim[3];
}
/*
[hostname[:port]][/path]
*/
if (*tok == '[' && ((delim = strchr(tok, ']')) != 0)) {
/* IPv6 [::] */
host = &tok[1];
*delim++ = '\0';
tok = delim;
} else if (*tok && *tok != '/' && *tok != ':' && (scheme || strchr(tok, ':'))) {
/*
Supported forms:
scheme://hostname
hostname[:port][/path]
*/
host = tok;
if ((tok = strpbrk(tok, ":/")) == 0) {
tok = "";
}
/* Don't terminate the hostname yet, need to see if tok is a ':' for a port. */
assert(tok);
}
/* [:port][/path] */
if (*tok == ':') {
/* Terminate hostname */
*tok++ = '\0';
port = tok;
if ((tok = strchr(tok, '/')) == 0) {
tok = "";
}
}
/* [/path] */
if (*tok) {
/*
Terminate hostname. This zeros the leading path slash.
This will be repaired before returning if ppath is set
*/
sep = *tok;
*tok++ = '\0';
path = tok;
/* path[.ext[/extra]] */
if ((tok = strrchr(path, '.')) != 0) {
if (tok[1]) {
if ((delim = strrchr(path, '/')) != 0) {
if (delim < tok) {
ext = tok;
}
} else {
ext = tok;
}
}
}
}
/*
Pass back the requested fields
*/
*pbuf = buf;
if (pscheme) {
if (scheme == 0) {
scheme = "http";
}
*pscheme = scheme;
}
if (phost) {
if (host == 0) {
host = "localhost";
}
*phost = host;
}
if (pport) {
*pport = port;
}
if (ppath) {
if (path == 0) {
scopy(buf2, 1, "/");
path = buf2;
} else {
/* Copy path to reinsert leading slash */
scopy(&buf2[1], len - 1, path);
path = buf2;
*path = sep;
}
// websDecodeUrl(path, path, -1);
*ppath = path;
}
if (pquery) {
*pquery = query;
}
if (preference) {
*preference = reference;
}
if (pext) {
if (ext) {
websDecodeUrl(ext, ext, -1);
#if ME_WIN_LIKE || MACOSX
slower(ext);
#endif
}
*pext = ext;
}
return 0;
}
/*
Normalize a URI path to remove "./", "../" and redundant separators.
Note: this does not make an abs path and does not map separators nor change case.
This validates the URI and expects it to begin with "/".
Returns an allocated path, caller must free.
*/
PUBLIC char *websNormalizeUriPath(cchar *pathArg)
{
char *dupPath, *path, *sp, *dp, *mark, **segments;
int firstc, j, i, nseg, len;
if (pathArg == 0 || *pathArg == '\0') {
return sclone("");
}
len = (int) slen(pathArg);
if ((dupPath = walloc(len + 2)) == 0) {
return NULL;
}
strcpy(dupPath, pathArg);
if ((segments = walloc(sizeof(char*) * (len + 1))) == 0) {
wfree(dupPath);
return NULL;
}
nseg = len = 0;
firstc = *dupPath;
for (mark = sp = dupPath; *sp; sp++) {
if (*sp == '/') {
*sp = '\0';
while (sp[1] == '/') {
sp++;
}
segments[nseg++] = mark;
len += (int) (sp - mark);
mark = sp + 1;
}
}
segments[nseg++] = mark;
len += (int) (sp - mark);
for (j = i = 0; i < nseg; i++, j++) {
sp = segments[i];
if (sp[0] == '.') {
if (sp[1] == '\0') {
if ((i+1) == nseg) {
/* Trim trailing "." */
segments[j] = "";
} else {
j--;
}
} else if (sp[1] == '.' && sp[2] == '\0') {
j = max(j - 2, -1);
if ((i+1) == nseg) {
nseg--;
}
} else {
/* .more-chars */
segments[j] = segments[i];
}
} else {
segments[j] = segments[i];
}
}
nseg = j;
assert(nseg >= 0);
if ((path = walloc(len + nseg + 1)) != 0) {
for (i = 0, dp = path; i < nseg; ) {
strcpy(dp, segments[i]);
len = (int) slen(segments[i]);
dp += len;
if (++i < nseg || (nseg == 1 && *segments[0] == '\0' && firstc == '/')) {
*dp++ = '/';
}
}
*dp = '\0';
}
wfree(dupPath);
wfree(segments);
return path;
}
/*
Validate a URI path for use in a HTTP request line
The URI must contain only valid characters and must being with "/" both before and after decoding.
A decoded, normalized URI path is returned.
The uri is modified. Returns an allocated path. Caller must free.
*/
PUBLIC char *websValidateUriPath(cchar *uri)
{
char *decoded, *normalized;
if (uri == 0 || *uri != '/') {
return 0;
}
if (!websValidUriChars(uri)) {
return 0;
}
decoded = walloc(slen(uri) + 1);
websDecodeUrl(decoded, (char*) uri, -1);
normalized = websNormalizeUriPath(decoded);
wfree(decoded);
if (normalized == 0) {
return 0;
}
if (*normalized != '/' || strchr(normalized, '\\')) {
wfree(normalized);
return 0;
}
return normalized;
}
/*
Open a web page. filename is the local filename. path is the URL path name.
*/
PUBLIC int websPageOpen(Webs *wp, int mode, int perm)
{
assert(websValid(wp));
return (wp->docfd = websOpenFile(wp->filename, mode, perm));
}
PUBLIC void websPageClose(Webs *wp)
{
assert(websValid(wp));
if (wp->docfd >= 0) {
websCloseFile(wp->docfd);
wp->docfd = -1;
}
}
PUBLIC int websPageStat(Webs *wp, WebsFileInfo *sbuf)
{
return websStatFile(wp->filename, sbuf);
}
PUBLIC int websPageIsDirectory(Webs *wp)
{
WebsFileInfo sbuf;
if (websStatFile(wp->filename, &sbuf) >= 0) {
return(sbuf.isDir);
}
return 0;
}
/*
Read a web page. Returns the number of _bytes_ read. len is the size of buf, in bytes.
*/
PUBLIC ssize websPageReadData(Webs *wp, char *buf, ssize nBytes)
{
assert(websValid(wp));
return websReadFile(wp->docfd, buf, nBytes);
}
/*
Move file pointer offset bytes.
*/
PUBLIC void websPageSeek(Webs *wp, Offset offset, int origin)
{
assert(websValid(wp));
websSeekFile(wp->docfd, offset, origin);
}
PUBLIC void websSetCookie(Webs *wp, cchar *name, cchar *value, cchar *path, cchar *cookieDomain, int lifespan, int flags)
{
WebsTime when;
char *cp, *expiresAtt, *expires, *domainAtt, *domain, *secure, *httponly, *cookie, *old, *sameSite;
assert(wp);
assert(name && *name);
if (path == 0) {
path = "/";
}
if (!cookieDomain) {
domain = sclone(wp->host);
if ((cp = strchr(domain, ':')) != 0) {
/* Strip port */
*cp = '\0';
}
if (*domain && domain[strlen(domain) - 1] == '.') {
/* Cleanup bonjour addresses with trailing dot */
domain[strlen(domain) - 1] = '\0';
}
} else {
domain = sclone(cookieDomain);
}
domainAtt = "";
if (smatch(domain, "localhost")) {
wfree(domain);
domain = sclone("");
} else {
domainAtt = "; domain=";
if (!strchr(domain, '.')) {
old = domain;
domain = sfmt(".%s", domain);
wfree(old);
}
}
if (lifespan > 0) {
expiresAtt = "; expires=";
when = time(0) + lifespan;
if ((expires = ctime(&when)) != NULL) {
expires[strlen(expires) - 1] = '\0';
}
} else {
expiresAtt = "";
expires = "";
}
/*
Allow multiple cookie headers. Even if the same name. Later definitions take precedence
*/
secure = (flags & WEBS_COOKIE_SECURE) ? "; secure" : "";
httponly = (flags & WEBS_COOKIE_HTTP) ? "; httponly" : "";
sameSite = "";
if (flags & WEBS_COOKIE_SAME_LAX) {
sameSite = "; SameSite=Lax";
} else if (flags & WEBS_COOKIE_SAME_STRICT) {
sameSite = "; SameSite=Strict";
}
cookie = sfmt("%s=%s; path=%s%s%s%s%s%s%s%s", name, value, path, domainAtt, domain, expiresAtt, expires, secure,
httponly, sameSite);
hashEnter(wp->responseCookies, name, valueString(cookie, 0), 0);
wfree(domain);
}
/*
Return the next token in the input stream. Does not allocate.
The content buffer is advanced to the next token.
The delimiter is a string to match and not a set of characters.
If the delimeter null, it means use white space (space or tab) as a delimiter.
*/
static char *getToken(Webs *wp, char *delim, int validation)
{
WebsBuf *buf;
char *token, *endToken;
assert(wp);
buf = &wp->rxbuf;
/* Already null terminated but for safety */
bufAddNull(buf);
token = (char*) buf->servp;
endToken = (char*) buf->endp;
/*
Eat white space before token
*/
for (; token < (char*) buf->endp && (*token == ' ' || *token == '\t'); token++) {}
if (delim) {
if ((endToken = strstr(token, delim)) == NULL) {
return NULL;
}
/* Only eat one occurrence of the delimiter */
buf->servp = endToken + strlen(delim);
*endToken = '\0';
} else {
delim = " \t";
if ((endToken = strpbrk(token, delim)) == NULL) {
return NULL;
}
buf->servp = endToken + strspn(endToken, delim);
*endToken = '\0';
}
token = validateToken(token, endToken, validation);
return token;
}
static char *validateToken(char *token, char *endToken, int validation)
{
char *t;
if (validation == TOKEN_HEADER_KEY) {
if (token == NULL || *token == '\0') {
return NULL;
}
if (strpbrk(token, "\"\\/ \t\r\n(),:;<=>?@[]{}")) {
return NULL;
}
for (t = token; *t; t++) {
if (!isprint(*t)) {
return NULL;
}
}
} else if (validation == TOKEN_HEADER_VALUE) {
if (token < endToken) {
/* Trim white space */
for (t = &token[slen(token) - 1]; t >= token; t--) {
if (isspace((uchar) *t)) {
*t = '\0';
} else {
break;
}
}
}
while (isspace((uchar) *token)) {
token++;
}
for (t = token; *t; t++) {
if (!isprint(*t)) {
return NULL;
}
}
} else if (validation == TOKEN_URI_VALUE) {
if (!websValidUriChars(token)) {
return NULL;
}
} else if (validation == TOKEN_NUMBER) {
if (!snumber(token)) {
return NULL;
}
} else if (validation == TOKEN_WORD) {
if (strpbrk(token, " \t\r\n") != NULL) {
return NULL;
}
} else {
if (strpbrk(token, "\r\n") != NULL) {
return NULL;
}
}
return token;
}
PUBLIC int websGetBackground(void)
{
return websBackground;
}
PUBLIC void websSetBackground(int on)
{
websBackground = on;
}
PUBLIC int websGetDebug(void)
{
return websDebug;
}
PUBLIC void websSetDebug(int on)
{
websDebug = on;
}
static char *makeSessionID(Webs *wp)
{
char idBuf[64];
static int nextSession = 0;
assert(wp);
fmt(idBuf, sizeof(idBuf), "%08x%08x%d", PTOI(wp) + PTOI(wp->url), (int) time(0), nextSession++);
return websMD5Block(idBuf, slen(idBuf), "::webs.session::");
}
PUBLIC void websDestroySession(Webs *wp)
{
websGetSession(wp, 0);
if (wp->session) {
hashDelete(sessions, wp->session->id);
sessionCount--;
freeSession(wp->session);
wp->session = 0;
}
}
PUBLIC WebsSession *websCreateSession(Webs *wp)
{
websDestroySession(wp);
return websGetSession(wp, 1);
}
WebsSession *websAllocSession(Webs *wp, cchar *id, int lifespan)
{
WebsSession *sp;
assert(wp);
if ((sp = walloc(sizeof(WebsSession))) == 0) {
return 0;
}
sp->lifespan = lifespan;
sp->expires = time(0) + lifespan;
if (id == 0) {
sp->id = makeSessionID(wp);
} else {
sp->id = sclone(id);
}
if ((sp->cache = hashCreate(WEBS_SESSION_HASH)) == 0) {
wfree(sp->id);
wfree(sp);
return 0;
}
if (hashEnter(sessions, sp->id, valueSymbol(sp), 0) == 0) {
wfree(sp->id);
wfree(sp);
return 0;
}
return sp;
}
static void freeSession(WebsSession *sp)
{
assert(sp);
if (sp->cache >= 0) {
hashFree(sp->cache);
sp->cache = -1;
}
wfree(sp->id);
wfree(sp);
}
WebsSession *websGetSession(Webs *wp, int create)
{
WebsKey *sym;
char *id;
int flags;
assert(wp);
if (!wp->session) {
id = websGetSessionID(wp);
if ((sym = hashLookup(sessions, id)) == 0) {
if (!create) {
wfree(id);
return 0;
}
if (sessionCount >= ME_GOAHEAD_LIMIT_SESSION_COUNT) {
error("Too many sessions %d/%d", sessionCount, ME_GOAHEAD_LIMIT_SESSION_COUNT);
wfree(id);
return 0;
}
sessionCount++;
if ((wp->session = websAllocSession(wp, id, ME_GOAHEAD_LIMIT_SESSION_LIFE)) == 0) {
wfree(id);
return 0;
}
flags = WEBS_COOKIE_SAME_LAX | WEBS_COOKIE_HTTP;
if (wp->flags & WEBS_SECURE) {
flags |= WEBS_COOKIE_SECURE;
}
websSetCookie(wp, WEBS_SESSION, wp->session->id, "/", NULL, 0, flags);
} else {
wp->session = (WebsSession*) sym->content.value.symbol;
}
wfree(id);
}
if (wp->session) {
wp->session->expires = time(0) + wp->session->lifespan;
}
return wp->session;
}
PUBLIC char *websParseCookie(Webs *wp, char *name)
{
char *buf, *cookie, *end, *key, *tok, *value, *vtok;
assert(wp);
if (wp->cookie == 0 || name == 0 || *name == '\0') {
return 0;
}
buf = sclone(wp->cookie);
end = &buf[slen(buf)];
value = 0;
for (tok = buf; tok && tok < end; ) {
cookie = stok(tok, ";", &tok);
cookie = strim(cookie, " ", WEBS_TRIM_START);
key = stok(cookie, "=", &vtok);
if (smatch(key, name)) {
// Remove leading spaces first, then double quotes. Spaces inside double quotes preserved.
value = sclone(strim(strim(vtok, " ", WEBS_TRIM_BOTH), "\"", WEBS_TRIM_BOTH));
break;
}
}
wfree(buf);
return value;
}
PUBLIC char *websGetSessionID(Webs *wp)
{
assert(wp);
if (wp->session) {
return wp->session->id;
}
return websParseCookie(wp, WEBS_SESSION);
}
PUBLIC cchar *websGetSessionVar(Webs *wp, cchar *key, cchar *defaultValue)
{
WebsSession *sp;
WebsKey *sym;
assert(wp);
assert(key && *key);
if ((sp = websGetSession(wp, 1)) != 0) {
if ((sym = hashLookup(sp->cache, key)) == 0) {
return defaultValue;
}
return (char*) sym->content.value.symbol;
}
return 0;
}
PUBLIC void websRemoveSessionVar(Webs *wp, cchar *key)
{
WebsSession *sp;
assert(wp);
assert(key && *key);
if ((sp = websGetSession(wp, 1)) != 0) {
hashDelete(sp->cache, key);
}
}
PUBLIC int websSetSessionVar(Webs *wp, cchar *key, cchar *value)
{
WebsSession *sp;
assert(wp);
assert(key && *key);
assert(value);
if ((sp = websGetSession(wp, 1)) == 0) {
return 0;
}
if (hashEnter(sp->cache, key, valueString(value, VALUE_ALLOCATE), 0) == 0) {
return -1;
}
return 0;
}
static void pruneSessions(void)
{
WebsSession *sp;
WebsTime when;
WebsKey *sym, *next;
int oldCount;
if (sessions >= 0) {
oldCount = sessionCount;
when = time(0);
for (sym = hashFirst(sessions); sym; sym = next) {
next = hashNext(sessions, sym);
sp = (WebsSession*) sym->content.value.symbol;
if (sp->expires <= when) {
hashDelete(sessions, sp->id);
sessionCount--;
freeSession(sp);
}
}
if (oldCount != sessionCount || sessionCount) {
trace(4, "Prune %d sessions. Remaining: %d", oldCount - sessionCount, sessionCount);
}
}
websRestartEvent(pruneId, WEBS_SESSION_PRUNE);
}
static void freeSessions(void)
{
WebsSession *sp;
WebsKey *sym, *next;
if (sessions >= 0) {
for (sym = hashFirst(sessions); sym; sym = next) {
next = hashNext(sessions, sym);
sp = (WebsSession*) sym->content.value.symbol;
hashDelete(sessions, sp->id);
freeSession(sp);
}
hashFree(sessions);
sessions = -1;
sessionCount = 0;
}
}
/*
One line embedding
*/
PUBLIC int websServer(cchar *endpoint, cchar *documents)
{
int finished = 0;
if (websOpen(documents, "route.txt") < 0) {
error("Cannot initialize server. Exiting.");
return -1;
}
if (websLoad("auth.txt") < 0) {
error("Cannot load auth.txt");
return -1;
}
if (websListen(endpoint) < 0) {
return -1;
}
websServiceEvents(&finished);
websClose();
return 0;
}
static void setFileLimits(void)
{
#if ME_UNIX_LIKE
struct rlimit r;
int limit;
limit = ME_GOAHEAD_LIMIT_FILES;
if (limit) {
r.rlim_cur = r.rlim_max = limit;
if (setrlimit(RLIMIT_NOFILE, &r) < 0) {
error("Cannot set file limit to %d", limit);
}
}
getrlimit(RLIMIT_NOFILE, &r);
trace(6, "Max files soft %d, max %d", r.rlim_cur, r.rlim_max);
#endif
}
/*
Output an error message and cleanup
*/
PUBLIC void websError(Webs *wp, int code, cchar *fmt, ...)
{
va_list args;
char *msg, *buf;
char *encoded;
int status;
assert(wp);
wp->error = 1;
if (code & WEBS_CLOSE) {
wp->flags &= ~WEBS_KEEP_ALIVE;
wp->connError++;
}
status = code & WEBS_CODE_MASK;
#if !ME_ROM
if (wp->putfd >= 0) {
close(wp->putfd);
wp->putfd = -1;
}
#endif
if (wp->rxRemaining && status != 200 && status != 301 && status != 302 && status != 401) {
/* Close connection so we don't have to consume remaining content */
wp->flags &= ~WEBS_KEEP_ALIVE;
}
encoded = websEscapeHtml(wp->url);
wfree(wp->url);
wp->url = encoded;
if (fmt) {
if (!(code & WEBS_NOLOG)) {
va_start(args, fmt);
msg = sfmtv(fmt, args);
va_end(args);
trace(2, "%s", msg);
wfree(msg);
}
buf = sfmt("\
<html>\r\n\
<head><title>Document Error: %s</title></head>\r\n\
<body>\r\n\
<h2>Access Error: %s</h2>\r\n\
</body>\r\n\
</html>\r\n", websErrorMsg(code), websErrorMsg(code));
} else {
buf = 0;
}
websResponse(wp, code, buf);
wfree(buf);
}
/*
Return the error message for a given code
*/
PUBLIC cchar *websErrorMsg(int code)
{
WebsError *ep;
assert(code >= 0);
code &= WEBS_CODE_MASK;
for (ep = websErrors; ep->code; ep++) {
if (code == ep->code) {
return ep->msg;
}
}
return websErrorMsg(HTTP_CODE_INTERNAL_SERVER_ERROR);
}
/*
Accessors
*/
PUBLIC cchar *websGetCookie(Webs *wp) { return wp->cookie; }
PUBLIC cchar *websGetDir(Webs *wp) { return wp->route && wp->route->dir ? wp->route->dir : websGetDocuments(); }
PUBLIC int websGetEof(Webs *wp) { return wp->eof; }
PUBLIC cchar *websGetExt(Webs *wp) { return wp->ext; }
PUBLIC cchar *websGetFilename(Webs *wp) { return wp->filename; }
PUBLIC cchar *websGetHost(Webs *wp) { return wp->host; }
PUBLIC cchar *websGetIfaddr(Webs *wp) { return wp->ifaddr; }
PUBLIC cchar *websGetIpaddr(Webs *wp) { return wp->ipaddr; }
PUBLIC cchar *websGetMethod(Webs *wp) { return wp->method; }
PUBLIC cchar *websGetPassword(Webs *wp) { return wp->password; }
PUBLIC cchar *websGetPath(Webs *wp) { return wp->path; }
PUBLIC int websGetPort(Webs *wp) { return wp->port; }
PUBLIC cchar *websGetProtocol(Webs *wp) { return wp->protocol; }
PUBLIC cchar *websGetQuery(Webs *wp) { return wp->query; }
PUBLIC cchar *websGetServer(void) { return websHost; }
PUBLIC cchar *websGetServerAddress(void) {
return websIpAddr;
}
PUBLIC cchar *websGetServerAddressUrl(void) { return websIpAddrUrl; }
PUBLIC cchar *websGetServerUrl(void) { return websHostUrl; }
PUBLIC cchar *websGetUrl(Webs *wp) { return wp->url; }
PUBLIC cchar *websGetUserAgent(Webs *wp) { return wp->userAgent; }
PUBLIC cchar *websGetUsername(Webs *wp) { return wp->username; }
/*
Copyright (c) Embedthis Software. All Rights Reserved.
This software is distributed under a commercial license. Consult the LICENSE.md
distributed with this software for full details and copyrights.
*/
goahead4.0.3---http.c代码解析
最新推荐文章于 2024-10-31 16:57:32 发布
扫一扫
998
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
