package/uhttpd/src/uhttpd-lua.c

   1 /*
   2  * uhttpd - Tiny single-threaded httpd - Lua handler
   3  *
   4  *   Copyright (C) 2010-2012 Jo-Philipp Wich <xm@subsignal.org>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License.
  17  */
  18
  19 #include "uhttpd.h"
  20 #include "uhttpd-utils.h"
  21 #include "uhttpd-lua.h"
  22
  23
  24 static int uh_lua_recv(lua_State *L)
  25 {
  26         size_t length;
  27
  28         char buffer[UH_LIMIT_MSGHEAD];
  29
  30         int to = 1;
  31         int fd = fileno(stdin);
  32         int rlen = 0;
  33
  34         length = luaL_checknumber(L, 1);
  35
  36         if ((length > 0) && (length <= sizeof(buffer)))
  37         {
  38                 /* receive data */
  39                 rlen = uh_raw_recv(fd, buffer, length, to);
  40
  41                 /* data read */
  42                 if (rlen > 0)
  43                 {
  44                         lua_pushnumber(L, rlen);
  45                         lua_pushlstring(L, buffer, rlen);
  46                         return 2;
  47                 }
  48
  49                 /* eof */
  50                 else if (rlen == 0)
  51                 {
  52                         lua_pushnumber(L, 0);
  53                         return 1;
  54                 }
  55
  56                 /* no, timeout and actually no data */
  57                 else
  58                 {
  59                         lua_pushnumber(L, -1);
  60                         return 1;
  61                 }
  62         }
  63
  64         /* parameter error */
  65         lua_pushnumber(L, -2);
  66         return 1;
  67 }
  68
  69 static int uh_lua_send_common(lua_State *L, int chunked)
  70 {
  71         size_t length;
  72
  73         char chunk[16];
  74         const char *buffer;
  75
  76         int rv;
  77         int to = 1;
  78         int fd = fileno(stdout);
  79         int slen = 0;
  80
  81         buffer = luaL_checklstring(L, 1, &length);
  82
  83         if (chunked)
  84         {
  85                 if (length > 0)
  86                 {
  87                         snprintf(chunk, sizeof(chunk), "%X\r\n", length);
  88
  89                         ensure_out(rv = uh_raw_send(fd, chunk, strlen(chunk), to));
  90                         slen += rv;
  91
  92                         ensure_out(rv = uh_raw_send(fd, buffer, length, to));
  93                         slen += rv;
  94
  95                         ensure_out(rv = uh_raw_send(fd, "\r\n", 2, to));
  96                         slen += rv;
  97                 }
  98                 else
  99                 {
 100                         slen = uh_raw_send(fd, "0\r\n\r\n", 5, to);
 101                 }
 102         }
 103         else
 104         {
 105                 slen = uh_raw_send(fd, buffer, length, to);
 106         }
 107
 108 out:
 109         lua_pushnumber(L, slen);
 110         return 1;
 111 }
 112
 113 static int uh_lua_send(lua_State *L)
 114 {
 115         return uh_lua_send_common(L, 0);
 116 }
 117
 118 static int uh_lua_sendc(lua_State *L)
 119 {
 120         return uh_lua_send_common(L, 1);
 121 }
 122
 123 static int uh_lua_str2str(lua_State *L, int (*xlate_func) (char *, int, const char *, int))
 124 {
 125         size_t inlen;
 126         int outlen;
 127         const char *inbuf;
 128         char outbuf[UH_LIMIT_MSGHEAD];
 129
 130         inbuf = luaL_checklstring(L, 1, &inlen);
 131         outlen = (* xlate_func)(outbuf, sizeof(outbuf), inbuf, inlen);
 132         if (outlen < 0)
 133                 luaL_error(L, "%s on URL-encode codec",
 134                                    (outlen==-1) ? "buffer overflow" : "malformed string");
 135
 136         lua_pushlstring(L, outbuf, outlen);
 137         return 1;
 138 }
 139
 140 static int uh_lua_urldecode(lua_State *L)
 141 {
 142         return uh_lua_str2str( L, uh_urldecode );
 143 }
 144
 145
 146 static int uh_lua_urlencode(lua_State *L)
 147 {
 148         return uh_lua_str2str( L, uh_urlencode );
 149 }
 150
 151
 152 lua_State * uh_lua_init(const struct config *conf)
 153 {
 154         lua_State *L = lua_open();
 155         const char *err_str = NULL;
 156
 157         /* Load standard libaries */
 158         luaL_openlibs(L);
 159
 160         /* build uhttpd api table */
 161         lua_newtable(L);
 162
 163         /* register global send and receive functions */
 164         lua_pushcfunction(L, uh_lua_recv);
 165         lua_setfield(L, -2, "recv");
 166
 167         lua_pushcfunction(L, uh_lua_send);
 168         lua_setfield(L, -2, "send");
 169
 170         lua_pushcfunction(L, uh_lua_sendc);
 171         lua_setfield(L, -2, "sendc");
 172
 173         lua_pushcfunction(L, uh_lua_urldecode);
 174         lua_setfield(L, -2, "urldecode");
 175
 176         lua_pushcfunction(L, uh_lua_urlencode);
 177         lua_setfield(L, -2, "urlencode");
 178
 179         /* Pass the document-root to the Lua handler by placing it in
 180         ** uhttpd.docroot.  It could alternatively be placed in env.DOCUMENT_ROOT
 181         ** which would more closely resemble the CGI protocol; but would mean that
 182         ** it is not available at the time when the handler-chunk is loaded but
 183         ** rather not until the handler is called, without any code savings. */
 184         lua_pushstring(L, conf->docroot);
 185         lua_setfield(L, -2, "docroot");
 186
 187         /* _G.uhttpd = { ... } */
 188         lua_setfield(L, LUA_GLOBALSINDEX, "uhttpd");
 189
 190
 191         /* load Lua handler */
 192         switch (luaL_loadfile(L, conf->lua_handler))
 193         {
 194                 case LUA_ERRSYNTAX:
 195                         fprintf(stderr,
 196                                         "Lua handler contains syntax errors, unable to continue\n");
 197                         exit(1);
 198
 199                 case LUA_ERRMEM:
 200                         fprintf(stderr,
 201                                         "Lua handler ran out of memory, unable to continue\n");
 202                         exit(1);
 203
 204                 case LUA_ERRFILE:
 205                         fprintf(stderr,
 206                                         "Lua cannot open the handler script, unable to continue\n");
 207                         exit(1);
 208
 209                 default:
 210                         /* compile Lua handler */
 211                         switch (lua_pcall(L, 0, 0, 0))
 212                         {
 213                                 case LUA_ERRRUN:
 214                                         err_str = luaL_checkstring(L, -1);
 215                                         fprintf(stderr,
 216                                                         "Lua handler had runtime error, "
 217                                                         "unable to continue\n"
 218                                                         "Error: %s\n", err_str);
 219                                         exit(1);
 220
 221                                 case LUA_ERRMEM:
 222                                         err_str = luaL_checkstring(L, -1);
 223                                         fprintf(stderr,
 224                                                         "Lua handler ran out of memory, "
 225                                                         "unable to continue\n"
 226                                                         "Error: %s\n", err_str);
 227                                         exit(1);
 228
 229                                 default:
 230                                         /* test handler function */
 231                                         lua_getglobal(L, UH_LUA_CALLBACK);
 232
 233                                         if (! lua_isfunction(L, -1))
 234                                         {
 235                                                 fprintf(stderr,
 236                                                                 "Lua handler provides no "UH_LUA_CALLBACK"(), "
 237                                                                 "unable to continue\n");
 238                                                 exit(1);
 239                                         }
 240
 241                                         lua_pop(L, 1);
 242                                         break;
 243                         }
 244
 245                         break;
 246         }
 247
 248         return L;
 249 }
 250
 251 static void uh_lua_shutdown(struct uh_lua_state *state)
 252 {
 253         close(state->rfd);
 254         close(state->wfd);
 255         free(state);
 256 }
 257
 258 static bool uh_lua_socket_cb(struct client *cl)
 259 {
 260         int len;
 261         char buf[UH_LIMIT_MSGHEAD];
 262
 263         struct uh_lua_state *state = (struct uh_lua_state *)cl->priv;
 264
 265         /* there is unread post data waiting */
 266         while (state->content_length > 0)
 267         {
 268                 /* remaining data in http head buffer ... */
 269                 if (state->cl->httpbuf.len > 0)
 270                 {
 271                         len = min(state->content_length, state->cl->httpbuf.len);
 272
 273                         D("Lua: Child(%d) feed %d HTTP buffer bytes\n",
 274                           state->cl->proc.pid, len);
 275
 276                         memcpy(buf, state->cl->httpbuf.ptr, len);
 277
 278                         state->cl->httpbuf.len -= len;
 279                         state->cl->httpbuf.ptr += len;
 280                 }
 281
 282                 /* read it from socket ... */
 283                 else
 284                 {
 285                         len = uh_tcp_recv(state->cl, buf,
 286                                                           min(state->content_length, sizeof(buf)));
 287
 288                         if ((len < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK)))
 289                                 break;
 290
 291                         D("Lua: Child(%d) feed %d/%d TCP socket bytes\n",
 292                           state->cl->proc.pid, len,
 293                           min(state->content_length, sizeof(buf)));
 294                 }
 295
 296                 if (len)
 297                         state->content_length -= len;
 298                 else
 299                         state->content_length = 0;
 300
 301                 /* ... write to CGI process */
 302                 len = uh_raw_send(state->wfd, buf, len,
 303                                                   cl->server->conf->script_timeout);
 304         }
 305
 306         /* try to read data from child */
 307         while ((len = uh_raw_recv(state->rfd, buf, sizeof(buf), -1)) > 0)
 308         {
 309                 /* pass through buffer to socket */
 310                 D("Lua: Child(%d) relaying %d normal bytes\n", state->cl->proc.pid, len);
 311                 ensure_out(uh_tcp_send(state->cl, buf, len));
 312                 state->data_sent = true;
 313         }
 314
 315         /* child has been marked dead by timeout or child handler, bail out */
 316         if (false && cl->dead)
 317         {
 318                 D("Lua: Child(%d) is marked dead, returning\n", state->cl->proc.pid);
 319                 goto out;
 320         }
 321
 322         if ((len == 0) ||
 323                 ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (len == -1)))
 324         {
 325                 D("Lua: Child(%d) presumed dead [%s]\n",
 326                   state->cl->proc.pid, strerror(errno));
 327
 328                 goto out;
 329         }
 330
 331         return true;
 332
 333 out:
 334         if (!state->data_sent)
 335         {
 336                 if (state->cl->timeout.pending)
 337                         uh_http_sendhf(state->cl, 502, "Bad Gateway",
 338                                                    "The Lua process did not produce any response\n");
 339                 else
 340                         uh_http_sendhf(state->cl, 504, "Gateway Timeout",
 341                                                    "The Lua process took too long to produce a "
 342                                                    "response\n");
 343         }
 344
 345         uh_lua_shutdown(state);
 346         return false;
 347 }
 348
 349 bool uh_lua_request(struct client *cl, lua_State *L)
 350 {
 351         int i;
 352         char *query_string;
 353         const char *prefix = cl->server->conf->lua_prefix;
 354         const char *err_str = NULL;
 355
 356         int rfd[2] = { 0, 0 };
 357         int wfd[2] = { 0, 0 };
 358
 359         pid_t child;
 360
 361         struct uh_lua_state *state;
 362         struct http_request *req = &cl->request;
 363
 364         int content_length = cl->httpbuf.len;
 365
 366
 367         /* allocate state */
 368         if (!(state = malloc(sizeof(*state))))
 369         {
 370                 uh_client_error(cl, 500, "Internal Server Error", "Out of memory");
 371                 return false;
 372         }
 373
 374         /* spawn pipes for me->child, child->me */
 375         if ((pipe(rfd) < 0) || (pipe(wfd) < 0))
 376         {
 377                 if (rfd[0] > 0) close(rfd[0]);
 378                 if (rfd[1] > 0) close(rfd[1]);
 379                 if (wfd[0] > 0) close(wfd[0]);
 380                 if (wfd[1] > 0) close(wfd[1]);
 381
 382                 uh_client_error(cl, 500, "Internal Server Error",
 383                                                 "Failed to create pipe: %s", strerror(errno));
 384
 385                 return false;
 386         }
 387
 388
 389         switch ((child = fork()))
 390         {
 391         case -1:
 392                 uh_client_error(cl, 500, "Internal Server Error",
 393                                                 "Failed to fork child: %s", strerror(errno));
 394
 395                 return false;
 396
 397         case 0:
 398 #ifdef DEBUG
 399                 sleep(atoi(getenv("UHTTPD_SLEEP_ON_FORK") ?: "0"));
 400 #endif
 401
 402                 /* close loose pipe ends */
 403                 close(rfd[0]);
 404                 close(wfd[1]);
 405
 406                 /* patch stdout and stdin to pipes */
 407                 dup2(rfd[1], 1);
 408                 dup2(wfd[0], 0);
 409
 410                 /* avoid leaking our pipe into child-child processes */
 411                 fd_cloexec(rfd[1]);
 412                 fd_cloexec(wfd[0]);
 413
 414                 /* put handler callback on stack */
 415                 lua_getglobal(L, UH_LUA_CALLBACK);
 416
 417                 /* build env table */
 418                 lua_newtable(L);
 419
 420                 /* request method */
 421                 switch(req->method)
 422                 {
 423                         case UH_HTTP_MSG_GET:
 424                                 lua_pushstring(L, "GET");
 425                                 break;
 426
 427                         case UH_HTTP_MSG_HEAD:
 428                                 lua_pushstring(L, "HEAD");
 429                                 break;
 430
 431                         case UH_HTTP_MSG_POST:
 432                                 lua_pushstring(L, "POST");
 433                                 break;
 434                 }
 435
 436                 lua_setfield(L, -2, "REQUEST_METHOD");
 437
 438                 /* request url */
 439                 lua_pushstring(L, req->url);
 440                 lua_setfield(L, -2, "REQUEST_URI");
 441
 442                 /* script name */
 443                 lua_pushstring(L, cl->server->conf->lua_prefix);
 444                 lua_setfield(L, -2, "SCRIPT_NAME");
 445
 446                 /* query string, path info */
 447                 if ((query_string = strchr(req->url, '?')) != NULL)
 448                 {
 449                         lua_pushstring(L, query_string + 1);
 450                         lua_setfield(L, -2, "QUERY_STRING");
 451
 452                         if ((int)(query_string - req->url) > strlen(prefix))
 453                         {
 454                                 lua_pushlstring(L,
 455                                         &req->url[strlen(prefix)],
 456                                         (int)(query_string - req->url) - strlen(prefix)
 457                                 );
 458
 459                                 lua_setfield(L, -2, "PATH_INFO");
 460                         }
 461                 }
 462                 else if (strlen(req->url) > strlen(prefix))
 463                 {
 464                         lua_pushstring(L, &req->url[strlen(prefix)]);
 465                         lua_setfield(L, -2, "PATH_INFO");
 466                 }
 467
 468                 /* http protcol version */
 469                 lua_pushnumber(L, floor(req->version * 10) / 10);
 470                 lua_setfield(L, -2, "HTTP_VERSION");
 471
 472                 if (req->version > 1.0)
 473                         lua_pushstring(L, "HTTP/1.1");
 474                 else
 475                         lua_pushstring(L, "HTTP/1.0");
 476
 477                 lua_setfield(L, -2, "SERVER_PROTOCOL");
 478
 479
 480                 /* address information */
 481                 lua_pushstring(L, sa_straddr(&cl->peeraddr));
 482                 lua_setfield(L, -2, "REMOTE_ADDR");
 483
 484                 lua_pushinteger(L, sa_port(&cl->peeraddr));
 485                 lua_setfield(L, -2, "REMOTE_PORT");
 486
 487                 lua_pushstring(L, sa_straddr(&cl->servaddr));
 488                 lua_setfield(L, -2, "SERVER_ADDR");
 489
 490                 lua_pushinteger(L, sa_port(&cl->servaddr));
 491                 lua_setfield(L, -2, "SERVER_PORT");
 492
 493                 /* essential env vars */
 494                 foreach_header(i, req->headers)
 495                 {
 496                         if (!strcasecmp(req->headers[i], "Content-Length"))
 497                         {
 498                                 content_length = atoi(req->headers[i+1]);
 499                         }
 500                         else if (!strcasecmp(req->headers[i], "Content-Type"))
 501                         {
 502                                 lua_pushstring(L, req->headers[i+1]);
 503                                 lua_setfield(L, -2, "CONTENT_TYPE");
 504                         }
 505                 }
 506
 507                 lua_pushnumber(L, content_length);
 508                 lua_setfield(L, -2, "CONTENT_LENGTH");
 509
 510                 /* misc. headers */
 511                 lua_newtable(L);
 512
 513                 foreach_header(i, req->headers)
 514                 {
 515                         if( strcasecmp(req->headers[i], "Content-Length") &&
 516                                 strcasecmp(req->headers[i], "Content-Type"))
 517                         {
 518                                 lua_pushstring(L, req->headers[i+1]);
 519                                 lua_setfield(L, -2, req->headers[i]);
 520                         }
 521                 }
 522
 523                 lua_setfield(L, -2, "headers");
 524
 525
 526                 /* call */
 527                 switch (lua_pcall(L, 1, 0, 0))
 528                 {
 529                         case LUA_ERRMEM:
 530                         case LUA_ERRRUN:
 531                                 err_str = luaL_checkstring(L, -1);
 532
 533                                 if (! err_str)
 534                                         err_str = "Unknown error";
 535
 536                                 printf("HTTP/%.1f 500 Internal Server Error\r\n"
 537                                            "Connection: close\r\n"
 538                                            "Content-Type: text/plain\r\n"
 539                                            "Content-Length: %i\r\n\r\n"
 540                                            "Lua raised a runtime error:\n  %s\n",
 541                                            req->version, 31 + strlen(err_str), err_str);
 542
 543                                 break;
 544
 545                         default:
 546                                 break;
 547                 }
 548
 549                 close(wfd[0]);
 550                 close(rfd[1]);
 551                 exit(0);
 552
 553                 break;
 554
 555         /* parent; handle I/O relaying */
 556         default:
 557                 memset(state, 0, sizeof(*state));
 558
 559                 state->cl = cl;
 560                 state->cl->proc.pid = child;
 561
 562                 /* close unneeded pipe ends */
 563                 close(rfd[1]);
 564                 close(wfd[0]);
 565
 566                 D("Lua: Child(%d) created: rfd(%d) wfd(%d)\n", child, rfd[0], wfd[1]);
 567
 568                 state->content_length = cl->httpbuf.len;
 569
 570                 /* find content length */
 571                 if (req->method == UH_HTTP_MSG_POST)
 572                 {
 573                         foreach_header(i, req->headers)
 574                         {
 575                                 if (!strcasecmp(req->headers[i], "Content-Length"))
 576                                 {
 577                                         state->content_length = atoi(req->headers[i+1]);
 578                                         break;
 579                                 }
 580                         }
 581                 }
 582
 583                 state->rfd = rfd[0];
 584                 fd_nonblock(state->rfd);
 585
 586                 state->wfd = wfd[1];
 587                 fd_nonblock(state->wfd);
 588
 589                 cl->cb = uh_lua_socket_cb;
 590                 cl->priv = state;
 591
 592                 break;
 593         }
 594
 595         return true;
 596 }
 597
 598 void uh_lua_close(lua_State *L)
 599 {
 600         lua_close(L);
 601 }