root/luci/trunk/contrib/package/uhttpd/src/uhttpd-lua.c @ 5898

/*
 * uhttpd - Tiny non-forking httpd - Lua handler
 *
 *   Copyright (C) 2010 Jo-Philipp Wich <xm@subsignal.org>
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

#include "uhttpd.h"
#include "uhttpd-utils.h"
#include "uhttpd-lua.h"


static int uh_lua_recv(lua_State *L)
{
    size_t length;
    char buffer[UH_LIMIT_MSGHEAD];
    ssize_t rlen = 0;
    fd_set reader;
    struct timeval timeout;
    struct client *cl;

    luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
    cl = (struct client *) lua_topointer(L, 1);
    length = luaL_checknumber(L, 2);

    if( (cl != NULL) && (length > 0) && (length <= sizeof(buffer)) )
    {
        FD_ZERO(&reader);
        FD_SET(cl->socket, &reader);

        /* fail after 0.1s */
        timeout.tv_sec  = 0;
        timeout.tv_usec = 100000;

        /* first return stuff from peek buffer */
        if( cl->peeklen > 0 )
        {
            /* receive data */
            rlen = uh_tcp_recv(cl, buffer, min(cl->peeklen, length));
            lua_pushnumber(L, rlen);
            lua_pushlstring(L, buffer, rlen);

            return 2;
        }

        /* check whether fd is readable */
        else if( select(cl->socket + 1, &reader, NULL, NULL, &timeout) > 0 )
        {
            /* receive data */
            rlen = uh_tcp_recv(cl, buffer, length);
            lua_pushnumber(L, rlen);

            if( rlen > 0 )
            {
                lua_pushlstring(L, buffer, rlen);
                return 2;
            }

            return 1;
        }

        /* no, timeout and actually no data */
        lua_pushnumber(L, -2);
        return 1;
    }

    /* parameter error */
    lua_pushnumber(L, -3);
    return 1;
}

static int uh_lua_send_common(lua_State *L, int chunked)
{
    size_t length;
    const char *buffer;
    ssize_t slen = 0;
    struct client *cl;

    luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
    cl = (struct client *) lua_topointer(L, 1);
    buffer = luaL_checklstring(L, 2, &length);

    if( (cl != NULL) && (length > 0) )
    {
        if( chunked )
            slen = uh_http_sendc(cl, buffer, length);
        else
            slen = uh_tcp_send(cl, buffer, length);

        lua_pushnumber(L, slen);
        return 1;
    }

    lua_pushnumber(L, -1);
    return 1;
}

static int uh_lua_send(lua_State *L)
{
    return uh_lua_send_common(L, 0);
}

static int uh_lua_sendc(lua_State *L)
{
    return uh_lua_send_common(L, 1);
}

static int uh_lua_urldecode(lua_State *L)
{
    size_t inlen, outlen;
    const char *inbuf;
    char outbuf[UH_LIMIT_MSGHEAD];

    inbuf = luaL_checklstring(L, 1, &inlen);
    outlen = uh_urldecode(outbuf, sizeof(outbuf), inbuf, inlen);

    lua_pushlstring(L, outbuf, outlen);
    return 1;
}


lua_State * uh_lua_init(const char *handler)
{
    lua_State *L = lua_open();
    const luaL_reg *lib;
    const char *err_str = NULL;

    /* Declare the Lua libraries we wish to use. */
    /* Note: If you are opening and running a file containing Lua code */
    /* using 'lua_dofile(l, "myfile.lua") - you must delcare all the libraries */
    /* used in that file here also. */
    static const luaL_reg lualibs[] =
    {
            { "base",       luaopen_base },
            { "string",     luaopen_string },
            { NULL,         NULL }
    };

    /* preload libraries */
    for (lib = lualibs; lib->func != NULL; lib++)
    {
            lib->func(L);
            lua_settop(L, 0);
    }

    /* build uhttpd api table */
    lua_newtable(L);

    /* register global send and receive functions */
    lua_pushcfunction(L, uh_lua_recv);
    lua_setfield(L, -2, "recv");

    lua_pushcfunction(L, uh_lua_send);
    lua_setfield(L, -2, "send");

    lua_pushcfunction(L, uh_lua_sendc);
    lua_setfield(L, -2, "sendc");

    lua_pushcfunction(L, uh_lua_urldecode);
    lua_setfield(L, -2, "urldecode");

    /* _G.uhttpd = { ... } */
    lua_setfield(L, LUA_GLOBALSINDEX, "uhttpd");


    /* load Lua handler */
    switch( luaL_loadfile(L, handler) )
    {
        case LUA_ERRSYNTAX:
            fprintf(stderr,
                "Lua handler contains syntax errors, unable to continue\n");
            exit(1);

        case LUA_ERRMEM:
            fprintf(stderr,
                "Lua handler ran out of memory, unable to continue\n");
            exit(1);

        case LUA_ERRFILE:
            fprintf(stderr,
                "Lua cannot open the handler script, unable to continue\n");
            exit(1);

        default:
            /* compile Lua handler */
            switch( lua_pcall(L, 0, 0, 0) )
            {
                case LUA_ERRRUN:
                    err_str = luaL_checkstring(L, -1);
                    fprintf(stderr,
                        "Lua handler had runtime error, unable to continue\n"
                        "Error: %s\n", err_str
                    );
                    exit(1);

                case LUA_ERRMEM:
                    err_str = luaL_checkstring(L, -1);
                    fprintf(stderr,
                        "Lua handler ran out of memory, unable to continue\n"
                        "Error: %s\n", err_str
                    );
                    exit(1);

                default:
                    /* test handler function */
                    lua_getglobal(L, UH_LUA_CALLBACK);

                    if( ! lua_isfunction(L, -1) )
                    {
                        fprintf(stderr,
                            "Lua handler provides no " UH_LUA_CALLBACK "(), unable to continue\n");
                        exit(1);
                    }

                    lua_pop(L, 1);
                    break;
            }

            break;
    }

    return L;
}

void uh_lua_request(struct client *cl, struct http_request *req, lua_State *L)
{
    int i;
    char *query_string;
    const char *prefix = cl->server->conf->lua_prefix;
    const char *err_str = NULL;

    /* put handler callback on stack */
    lua_getglobal(L, UH_LUA_CALLBACK);


    /* build env table */
    lua_newtable(L);

    /* client object */
    lua_pushlightuserdata(L, (void *)cl);
    lua_setfield(L, -2, "client");

    /* request method */
    switch(req->method)
    {
        case UH_HTTP_MSG_GET:
            lua_pushstring(L, "get");
            break;

        case UH_HTTP_MSG_HEAD:
            lua_pushstring(L, "head");
            break;

        case UH_HTTP_MSG_POST:
            lua_pushstring(L, "post");
            break;
    }

    lua_setfield(L, -2, "request_method");

    /* request url */
    lua_pushstring(L, req->url);
    lua_setfield(L, -2, "request_url");

    /* query string, path info */
    if( (query_string = strchr(req->url, '?')) != NULL )
    {
        lua_pushstring(L, query_string + 1);
        lua_setfield(L, -2, "query_string");

        if( (int)(query_string - req->url) > strlen(prefix) )
        {
            lua_pushlstring(L,
                &req->url[strlen(prefix)],
                (int)(query_string - req->url) - strlen(prefix)
            );

            lua_setfield(L, -2, "path_info");
        }
    }
    else if( strlen(req->url) > strlen(prefix) )
    {
        lua_pushstring(L, &req->url[strlen(prefix)]);
        lua_setfield(L, -2, "path_info");
    }

    /* http protcol version */
    lua_pushnumber(L, floor(req->version * 10) / 10);
    lua_setfield(L, -2, "http_version");


    /* address information */
    lua_pushstring(L, sa_straddr(&cl->peeraddr));
    lua_setfield(L, -2, "remote_addr");

    lua_pushinteger(L, sa_port(&cl->peeraddr));
    lua_setfield(L, -2, "remote_port");

    lua_pushstring(L, sa_straddr(&cl->servaddr));
    lua_setfield(L, -2, "server_addr");

    lua_pushinteger(L, sa_port(&cl->servaddr));
    lua_setfield(L, -2, "server_port");


    /* headers */
    lua_newtable(L);

    foreach_header(i, req->headers)
    {
        lua_pushstring(L, req->headers[i+1]);
        lua_setfield(L, -2, req->headers[i]);
    }

    lua_setfield(L, -2, "headers");


    /* call */
    switch( lua_pcall(L, 1, 0, 0) )
    {
        case LUA_ERRRUN:
            err_str = luaL_checkstring(L, -1);
            uh_http_sendhf(cl, 500, "Lua runtime error",
                "Lua raised an error:\n%s\n", err_str);
            break;

        case LUA_ERRMEM:
            err_str = luaL_checkstring(L, -1);
            uh_http_sendhf(cl, 500, "Lua out of memory",
                "Lua raised an error:\n%s\n", err_str);
            break;

        default:
            break;
    }
}