static EjsAny *coerceUriOperands(Ejs *ejs, EjsUri *lhs, int opcode, EjsAny *rhs)
{
HttpUri *uri;
char *ustr;
switch (opcode) {
/*
Binary operators
*/
case EJS_OP_ADD:
uri = lhs->uri;
ustr = httpFormatUri(uri->scheme, uri->host, uri->port, uri->path, uri->reference, uri->query, 0);
return ejsInvokeOperator(ejs, ejsCreateStringFromAsc(ejs, ustr), opcode, rhs);
case EJS_OP_COMPARE_EQ: case EJS_OP_COMPARE_NE:
case EJS_OP_COMPARE_LE: case EJS_OP_COMPARE_LT:
case EJS_OP_COMPARE_GE: case EJS_OP_COMPARE_GT:
if (!ejsIsDefined(ejs, rhs)) {
return ((opcode == EJS_OP_COMPARE_EQ) ? ESV(false): ESV(true));
}
uri = lhs->uri;
ustr = httpFormatUri(uri->scheme, uri->host, uri->port, uri->path, uri->reference, uri->query, 0);
return ejsInvokeOperator(ejs, ejsCreateStringFromAsc(ejs, ustr), opcode, rhs);
case EJS_OP_COMPARE_STRICTLY_NE:
return ESV(true);
case EJS_OP_COMPARE_STRICTLY_EQ:
return ESV(false);
case EJS_OP_COMPARE_NOT_ZERO:
case EJS_OP_COMPARE_TRUE:
return ESV(true);
case EJS_OP_COMPARE_ZERO:
case EJS_OP_COMPARE_FALSE:
return ESV(false);
case EJS_OP_COMPARE_UNDEFINED:
case EJS_OP_COMPARE_NULL:
return ESV(false);
default:
ejsThrowTypeError(ejs, "Opcode %d not valid for type %@", opcode, TYPE(lhs)->qname.name);
return ESV(undefined);
}
return 0;
}
PUBLIC char *httpUriToString(HttpUri *uri, int flags)
{
if (!uri) {
return "";
}
return httpFormatUri(uri->scheme, uri->host, uri->port, uri->path, uri->reference, uri->query, flags);
}
static char *uriToString(Ejs *ejs, EjsUri *up)
{
HttpUri *uri;
uri = up->uri;
return httpFormatUri(uri->scheme, uri->host, uri->port, uri->path, uri->reference, uri->query, 0);
}
/*
function toLocalString(): String
*/
static EjsString *uri_toLocalString(Ejs *ejs, EjsUri *up, int argc, EjsObj **argv)
{
HttpUri *uri;
uri = up->uri;
return ejsCreateStringFromAsc(ejs, httpFormatUri(NULL, NULL, 0, uri->path, uri->reference, uri->query, 0));
}
/*
Render a document by mapping a URL target to a document. The target is interpreted relative to route->documents.
If target exists, then serve that.
If target + extension exists, serve that.
If target is a directory and an index.esp, return the index.esp without a redirect.
If target is a directory without a trailing "/" but with an index.esp, do an external redirect to "URI/".
If target does not end with ".esp", then do not serve that.
*/
PUBLIC void espRenderDocument(HttpConn *conn, cchar *target)
{
HttpUri *up;
MprKey *kp;
cchar *dest;
assert(target);
for (ITERATE_KEYS(conn->rx->route->extensions, kp)) {
if (kp->key && *kp->key) {
if ((dest = checkView(conn, target, 0, kp->key)) != 0) {
espRenderView(conn, dest, 0);
return;
}
}
}
if ((dest = checkView(conn, target, 0, "esp")) != 0) {
espRenderView(conn, dest, 0);
return;
}
if ((dest = checkView(conn, target, "index", "esp")) != 0) {
/*
Must do external redirect first if URL does not end with "/"
*/
if (!sends(conn->rx->parsedUri->path, "/")) {
up = conn->rx->parsedUri;
httpRedirect(conn, HTTP_CODE_MOVED_PERMANENTLY, httpFormatUri(up->scheme, up->host,
up->port, sjoin(up->path, "/", NULL), up->reference, up->query, 0));
return;
}
espRenderView(conn, dest, 0);
return;
}
/*
Remove in version 6
*/
#if DEPRECATED || 1
if ((dest = checkView(conn, sjoin("app/", target, NULL), 0, "esp")) != 0) {
espRenderView(conn, dest, 0);
return;
}
#endif
/*
Last chance, forward to the file handler ... not an ESP request.
This enables static file requests within ESP routes.
*/
httpTrace(conn, "esp.handler", "context", "msg: 'Relay to the fileHandler");
conn->rx->target = &conn->rx->pathInfo[1];
httpMapFile(conn);
if (conn->tx->fileInfo.isDir) {
httpHandleDirectory(conn);
}
httpSetFileHandler(conn, 0);
}
/*
Test if the request matches. This may delegate the request to the dirHandler if a directory listing is required.
*/
static int matchFileHandler(HttpConn *conn, HttpRoute *route, int dir)
{
HttpRx *rx;
HttpTx *tx;
HttpUri *prior;
MprPath *info, zipInfo;
cchar *index;
char *path, *pathInfo, *uri, *zipfile;
int next;
printf("\n matchFileHandler \n");
rx = conn->rx;
tx = conn->tx;
rx = conn->rx;
prior = rx->parsedUri;
info = &tx->fileInfo;
httpMapFile(conn, route);
assure(info->checked);
if (rx->flags & (HTTP_DELETE | HTTP_PUT)) {
return HTTP_ROUTE_OK;
}
if (info->isDir) {
/*
Manage requests for directories
*/
if (!sends(rx->pathInfo, "/")) {
/*
Append "/" and do an external redirect
*/
pathInfo = sjoin(rx->pathInfo, "/", NULL);
uri = httpFormatUri(prior->scheme, prior->host, prior->port, pathInfo, prior->reference, prior->query, 0);
httpRedirect(conn, HTTP_CODE_MOVED_PERMANENTLY, uri);
return HTTP_ROUTE_OK;
}
if (route->indicies) {
/*
Ends with a "/" so do internal redirection to an index file
*/
for (ITERATE_ITEMS(route->indicies, index, next)) {
/*
Internal directory redirections. Transparently append index. Test indicies in order.
*/
path = mprJoinPath(tx->filename, index);
if (mprPathExists(path, R_OK)) {
pathInfo = sjoin(rx->scriptName, rx->pathInfo, index, NULL);
uri = httpFormatUri(prior->scheme, prior->host, prior->port, pathInfo, prior->reference,
prior->query, 0);
httpSetUri(conn, uri);
tx->filename = path;
tx->ext = httpGetExt(conn);
mprGetPathInfo(tx->filename, info);
return HTTP_ROUTE_REROUTE;
}
}
}
/*
If a directory, test if a directory listing should be rendered. If so, delegate to the dirHandler.
Cannot use the sendFile handler and must use the netConnector.
*/
if (info->isDir && maRenderDirListing(conn)) {
tx->handler = conn->http->dirHandler;
tx->connector = conn->http->netConnector;
return HTTP_ROUTE_OK;
}
}
if (!info->valid && (route->flags & HTTP_ROUTE_GZIP) && rx->acceptEncoding && strstr(rx->acceptEncoding, "gzip") != 0) {
/*
If the route accepts zipped data and a zipped file exists, then transparently respond with it.
*/
zipfile = sfmt("%s.gz", tx->filename);
if (mprGetPathInfo(zipfile, &zipInfo) == 0) {
tx->filename = zipfile;
tx->fileInfo = zipInfo;
httpSetHeader(conn, "Content-Encoding", "gzip");
}
}
if (rx->flags & (HTTP_GET | HTTP_HEAD | HTTP_POST) && info->valid && !info->isDir && tx->length < 0) {
/*
The sendFile connector is optimized on some platforms to use the sendfile() system call.
Set the entity length for the sendFile connector to utilize.
*/
httpSetEntityLength(conn, tx->fileInfo.size);
}
printf("\n-------------------------\n");
printf("tx->filename:\t%s",tx->filename);
printf("\n-------------------------\n");
return HTTP_ROUTE_OK;
}
static int handleDirectory(HttpConn *conn)
{
HttpRx *rx;
HttpTx *tx;
HttpRoute *route;
HttpUri *req;
MprPath *info;
cchar *index, *pathInfo, *uri;
char *path;
int next;
rx = conn->rx;
tx = conn->tx;
req = rx->parsedUri;
route = rx->route;
info = &tx->fileInfo;
/*
Manage requests for directories
*/
if (!sends(req->path, "/")) {
/*
Append "/" and do an external redirect. Use the original request URI.
*/
pathInfo = sjoin(req->path, "/", NULL);
uri = httpFormatUri(req->scheme, req->host, req->port, pathInfo, req->reference, req->query, 0);
httpRedirect(conn, HTTP_CODE_MOVED_PERMANENTLY, uri);
return HTTP_ROUTE_OK;
}
if (route->indexes) {
/*
Ends with a "/" so do internal redirection to an index file
*/
for (ITERATE_ITEMS(route->indexes, index, next)) {
/*
Internal directory redirections. Transparently append index. Test indexes in order.
*/
path = mprJoinPath(tx->filename, index);
if (mprPathExists(path, R_OK)) {
pathInfo = sjoin(rx->scriptName, rx->pathInfo, index, NULL);
uri = httpFormatUri(req->scheme, req->host, req->port, pathInfo, req->reference, req->query, 0);
httpSetUri(conn, uri);
tx->filename = path;
tx->ext = httpGetExt(conn);
mprGetPathInfo(tx->filename, info);
return HTTP_ROUTE_REROUTE;
}
}
}
#if ME_COM_DIR
/*
Directory Listing. If a directory, test if a directory listing should be rendered. If so, delegate to the
dirHandler. Cannot use the sendFile handler and must use the netConnector.
*/
if (info->isDir && httpRenderDirListing(conn)) {
tx->handler = conn->http->dirHandler;
tx->connector = conn->http->netConnector;
return HTTP_ROUTE_OK;
}
#endif
return HTTP_ROUTE_OK;
}
