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 Lua process */
 302                 len = uh_raw_send(state->wfd, buf, len,
 303                                                   cl->server->conf->script_timeout);
 304
 305                 /* explicit EOF notification for the child */
 306                 if (state->content_length <= 0)
 307                         close(state->wfd);
 308         }
 309
 310         /* try to read data from child */
 311         while ((len = uh_raw_recv(state->rfd, buf, sizeof(buf), -1)) > 0)
 312         {
 313                 /* pass through buffer to socket */
 314                 D("Lua: Child(%d) relaying %d normal bytes\n", state->cl->proc.pid, len);
 315                 ensure_out(uh_tcp_send(state->cl, buf, len));
 316                 state->data_sent = true;
 317         }
 318
 319         /* got EOF or read error from child */
 320         if ((len == 0) ||
 321                 ((errno != EAGAIN) && (errno != EWOULDBLOCK) && (len == -1)))
 322         {
 323                 D("Lua: Child(%d) presumed dead [%s]\n",
 324                   state->cl->proc.pid, strerror(errno));
 325
 326                 goto out;
 327         }
 328
 329         return true;
 330
 331 out:
 332         if (!state->data_sent)
 333         {
 334                 if (state->cl->timeout.pending)
 335                         uh_http_sendhf(state->cl, 502, "Bad Gateway",
 336                                                    "The Lua process did not produce any response\n");
 337                 else
 338                         uh_http_sendhf(state->cl, 504, "Gateway Timeout",
 339                                                    "The Lua process took too long to produce a "
 340                                                    "response\n");
 341         }
 342
 343         uh_lua_shutdown(state);
 344         return false;
 345 }
 346
 347 bool uh_lua_request(struct client *cl, lua_State *L)
 348 {
 349         int i;
 350         char *query_string;
 351         const char *prefix = cl->server->conf->lua_prefix;
 352         const char *err_str = NULL;
 353
 354         int rfd[2] = { 0, 0 };
 355         int wfd[2] = { 0, 0 };
 356
 357         pid_t child;
 358
 359         struct uh_lua_state *state;
 360         struct http_request *req = &cl->request;
 361
 362         int content_length = cl->httpbuf.len;
 363
 364
 365         /* allocate state */
 366         if (!(state = malloc(sizeof(*state))))
 367         {
 368                 uh_client_error(cl, 500, "Internal Server Error", "Out of memory");
 369                 return false;
 370         }
 371
 372         /* spawn pipes for me->child, child->me */
 373         if ((pipe(rfd) < 0) || (pipe(wfd) < 0))
 374         {
 375                 if (rfd[0] > 0) close(rfd[0]);
 376                 if (rfd[1] > 0) close(rfd[1]);
 377                 if (wfd[0] > 0) close(wfd[0]);
 378                 if (wfd[1] > 0) close(wfd[1]);
 379
 380                 uh_client_error(cl, 500, "Internal Server Error",
 381                                                 "Failed to create pipe: %s", strerror(errno));
 382
 383                 return false;
 384         }
 385
 386
 387         switch ((child = fork()))
 388         {
 389         case -1:
 390                 uh_client_error(cl, 500, "Internal Server Error",
 391                                                 "Failed to fork child: %s", strerror(errno));
 392
 393                 return false;
 394
 395         case 0:
 396 #ifdef DEBUG
 397                 sleep(atoi(getenv("UHTTPD_SLEEP_ON_FORK") ?: "0"));
 398 #endif
 399
 400                 /* close loose pipe ends */
 401                 close(rfd[0]);
 402                 close(wfd[1]);
 403
 404                 /* patch stdout and stdin to pipes */
 405                 dup2(rfd[1], 1);
 406                 dup2(wfd[0], 0);
 407
 408                 /* avoid leaking our pipe into child-child processes */
 409                 fd_cloexec(rfd[1]);
 410                 fd_cloexec(wfd[0]);
 411
 412                 /* put handler callback on stack */
 413                 lua_getglobal(L, UH_LUA_CALLBACK);
 414
 415                 /* build env table */
 416                 lua_newtable(L);
 417
 418                 /* request method */
 419                 switch(req->method)
 420                 {
 421                         case UH_HTTP_MSG_GET:
 422                                 lua_pushstring(L, "GET");
 423                                 break;
 424
 425                         case UH_HTTP_MSG_HEAD:
 426                                 lua_pushstring(L, "HEAD");
 427                                 break;
 428
 429                         case UH_HTTP_MSG_POST:
 430                                 lua_pushstring(L, "POST");
 431                                 break;
 432                 }
 433
 434                 lua_setfield(L, -2, "REQUEST_METHOD");
 435
 436                 /* request url */
 437                 lua_pushstring(L, req->url);
 438                 lua_setfield(L, -2, "REQUEST_URI");
 439
 440                 /* script name */
 441                 lua_pushstring(L, cl->server->conf->lua_prefix);
 442                 lua_setfield(L, -2, "SCRIPT_NAME");
 443
 444                 /* query string, path info */
 445                 if ((query_string = strchr(req->url, '?')) != NULL)
 446                 {
 447                         lua_pushstring(L, query_string + 1);
 448                         lua_setfield(L, -2, "QUERY_STRING");
 449
 450                         if ((int)(query_string - req->url) > strlen(prefix))
 451                         {
 452                                 lua_pushlstring(L,
 453                                         &req->url[strlen(prefix)],
 454                                         (int)(query_string - req->url) - strlen(prefix)
 455                                 );
 456
 457                                 lua_setfield(L, -2, "PATH_INFO");
 458                         }
 459                 }
 460                 else if (strlen(req->url) > strlen(prefix))
 461                 {
 462                         lua_pushstring(L, &req->url[strlen(prefix)]);
 463                         lua_setfield(L, -2, "PATH_INFO");
 464                 }
 465
 466                 /* http protcol version */
 467                 lua_pushnumber(L, floor(req->version * 10) / 10);
 468                 lua_setfield(L, -2, "HTTP_VERSION");
 469
 470                 if (req->version > 1.0)
 471                         lua_pushstring(L, "HTTP/1.1");
 472                 else
 473                         lua_pushstring(L, "HTTP/1.0");
 474
 475                 lua_setfield(L, -2, "SERVER_PROTOCOL");
 476
 477
 478                 /* address information */
 479                 lua_pushstring(L, sa_straddr(&cl->peeraddr));
 480                 lua_setfield(L, -2, "REMOTE_ADDR");
 481
 482                 lua_pushinteger(L, sa_port(&cl->peeraddr));
 483                 lua_setfield(L, -2, "REMOTE_PORT");
 484
 485                 lua_pushstring(L, sa_straddr(&cl->servaddr));
 486                 lua_setfield(L, -2, "SERVER_ADDR");
 487
 488                 lua_pushinteger(L, sa_port(&cl->servaddr));
 489                 lua_setfield(L, -2, "SERVER_PORT");
 490
 491                 /* essential env vars */
 492                 foreach_header(i, req->headers)
 493                 {
 494                         if (!strcasecmp(req->headers[i], "Content-Length"))
 495                         {
 496                                 content_length = atoi(req->headers[i+1]);
 497                         }
 498                         else if (!strcasecmp(req->headers[i], "Content-Type"))
 499                         {
 500                                 lua_pushstring(L, req->headers[i+1]);
 501                                 lua_setfield(L, -2, "CONTENT_TYPE");
 502                         }
 503                 }
 504
 505                 lua_pushnumber(L, content_length);
 506                 lua_setfield(L, -2, "CONTENT_LENGTH");
 507
 508                 /* misc. headers */
 509                 lua_newtable(L);
 510
 511                 foreach_header(i, req->headers)
 512                 {
 513                         if( strcasecmp(req->headers[i], "Content-Length") &&
 514                                 strcasecmp(req->headers[i], "Content-Type"))
 515                         {
 516                                 lua_pushstring(L, req->headers[i+1]);
 517                                 lua_setfield(L, -2, req->headers[i]);
 518                         }
 519                 }
 520
 521                 lua_setfield(L, -2, "headers");
 522
 523
 524                 /* call */
 525                 switch (lua_pcall(L, 1, 0, 0))
 526                 {
 527                         case LUA_ERRMEM:
 528                         case LUA_ERRRUN:
 529                                 err_str = luaL_checkstring(L, -1);
 530
 531                                 if (! err_str)
 532                                         err_str = "Unknown error";
 533
 534                                 printf("HTTP/%.1f 500 Internal Server Error\r\n"
 535                                            "Connection: close\r\n"
 536                                            "Content-Type: text/plain\r\n"
 537                                            "Content-Length: %i\r\n\r\n"
 538                                            "Lua raised a runtime error:\n  %s\n",
 539                                            req->version, 31 + strlen(err_str), err_str);
 540
 541                                 break;
 542
 543                         default:
 544                                 break;
 545                 }
 546
 547                 close(wfd[0]);
 548                 close(rfd[1]);
 549                 exit(0);
 550
 551                 break;
 552
 553         /* parent; handle I/O relaying */
 554         default:
 555                 memset(state, 0, sizeof(*state));
 556
 557                 state->cl = cl;
 558                 state->cl->proc.pid = child;
 559
 560                 /* close unneeded pipe ends */
 561                 close(rfd[1]);
 562                 close(wfd[0]);
 563
 564                 D("Lua: Child(%d) created: rfd(%d) wfd(%d)\n", child, rfd[0], wfd[1]);
 565
 566                 state->content_length = cl->httpbuf.len;
 567
 568                 /* find content length */
 569                 if (req->method == UH_HTTP_MSG_POST)
 570                 {
 571                         foreach_header(i, req->headers)
 572                         {
 573                                 if (!strcasecmp(req->headers[i], "Content-Length"))
 574                                 {
 575                                         state->content_length = atoi(req->headers[i+1]);
 576                                         break;
 577                                 }
 578                         }
 579                 }
 580
 581                 state->rfd = rfd[0];
 582                 fd_nonblock(state->rfd);
 583
 584                 state->wfd = wfd[1];
 585                 fd_nonblock(state->wfd);
 586
 587                 cl->cb = uh_lua_socket_cb;
 588                 cl->priv = state;
 589
 590                 break;
 591         }
 592
 593         return true;
 594 }
 595
 596 void uh_lua_close(lua_State *L)
 597 {
 598         lua_close(L);
 599 }