package/uhttpd/src/uhttpd-lua.c

   1 /*
   2  * uhttpd - Tiny single-threaded httpd - Lua handler
   3  *
   4  *   Copyright (C) 2010 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         char buffer[UH_LIMIT_MSGHEAD];
  28         ssize_t rlen = 0;
  29         fd_set reader;
  30         struct timeval timeout;
  31
  32         length = luaL_checknumber(L, 1);
  33
  34         if( (length > 0) && (length <= sizeof(buffer)) )
  35         {
  36                 FD_ZERO(&reader);
  37                 FD_SET(fileno(stdin), &reader);
  38
  39                 /* fail after 0.1s */
  40                 timeout.tv_sec  = 0;
  41                 timeout.tv_usec = 100000;
  42
  43                 /* check whether fd is readable */
  44                 if( select(fileno(stdin) + 1, &reader, NULL, NULL, &timeout) > 0 )
  45                 {
  46                         /* receive data */
  47                         rlen = read(fileno(stdin), buffer, length);
  48                         lua_pushnumber(L, rlen);
  49
  50                         if( rlen > 0 )
  51                         {
  52                                 lua_pushlstring(L, buffer, rlen);
  53                                 return 2;
  54                         }
  55
  56                         return 1;
  57                 }
  58
  59                 /* no, timeout and actually no data */
  60                 lua_pushnumber(L, -2);
  61                 return 1;
  62         }
  63
  64         /* parameter error */
  65         lua_pushnumber(L, -3);
  66         return 1;
  67 }
  68
  69 static int uh_lua_send_common(lua_State *L, int chunked)
  70 {
  71         size_t length;
  72         const char *buffer;
  73         char chunk[16];
  74         ssize_t slen = 0;
  75
  76         buffer = luaL_checklstring(L, 1, &length);
  77
  78         if( chunked )
  79         {
  80                 if( length > 0 )
  81                 {
  82                         snprintf(chunk, sizeof(chunk), "%X\r\n", length);
  83                         slen =  write(fileno(stdout), chunk, strlen(chunk));
  84                         slen += write(fileno(stdout), buffer, length);
  85                         slen += write(fileno(stdout), "\r\n", 2);
  86                 }
  87                 else
  88                 {
  89                         slen = write(fileno(stdout), "0\r\n\r\n", 5);
  90                 }
  91         }
  92         else
  93         {
  94                 slen = write(fileno(stdout), buffer, length);
  95         }
  96
  97         lua_pushnumber(L, slen);
  98         return 1;
  99 }
 100
 101 static int uh_lua_send(lua_State *L)
 102 {
 103         return uh_lua_send_common(L, 0);
 104 }
 105
 106 static int uh_lua_sendc(lua_State *L)
 107 {
 108         return uh_lua_send_common(L, 1);
 109 }
 110
 111 static int uh_lua_urldecode(lua_State *L)
 112 {
 113         size_t inlen, outlen;
 114         const char *inbuf;
 115         char outbuf[UH_LIMIT_MSGHEAD];
 116
 117         inbuf = luaL_checklstring(L, 1, &inlen);
 118         outlen = uh_urldecode(outbuf, sizeof(outbuf), inbuf, inlen);
 119
 120         lua_pushlstring(L, outbuf, outlen);
 121         return 1;
 122 }
 123
 124
 125 lua_State * uh_lua_init(const char *handler)
 126 {
 127         lua_State *L = lua_open();
 128         const char *err_str = NULL;
 129
 130         /* Load standard libaries */
 131         luaL_openlibs(L);
 132
 133         /* build uhttpd api table */
 134         lua_newtable(L);
 135
 136         /* register global send and receive functions */
 137         lua_pushcfunction(L, uh_lua_recv);
 138         lua_setfield(L, -2, "recv");
 139
 140         lua_pushcfunction(L, uh_lua_send);
 141         lua_setfield(L, -2, "send");
 142
 143         lua_pushcfunction(L, uh_lua_sendc);
 144         lua_setfield(L, -2, "sendc");
 145
 146         lua_pushcfunction(L, uh_lua_urldecode);
 147         lua_setfield(L, -2, "urldecode");
 148
 149         /* _G.uhttpd = { ... } */
 150         lua_setfield(L, LUA_GLOBALSINDEX, "uhttpd");
 151
 152
 153         /* load Lua handler */
 154         switch( luaL_loadfile(L, handler) )
 155         {
 156                 case LUA_ERRSYNTAX:
 157                         fprintf(stderr,
 158                                 "Lua handler contains syntax errors, unable to continue\n");
 159                         exit(1);
 160
 161                 case LUA_ERRMEM:
 162                         fprintf(stderr,
 163                                 "Lua handler ran out of memory, unable to continue\n");
 164                         exit(1);
 165
 166                 case LUA_ERRFILE:
 167                         fprintf(stderr,
 168                                 "Lua cannot open the handler script, unable to continue\n");
 169                         exit(1);
 170
 171                 default:
 172                         /* compile Lua handler */
 173                         switch( lua_pcall(L, 0, 0, 0) )
 174                         {
 175                                 case LUA_ERRRUN:
 176                                         err_str = luaL_checkstring(L, -1);
 177                                         fprintf(stderr,
 178                                                 "Lua handler had runtime error, unable to continue\n"
 179                                                 "Error: %s\n", err_str
 180                                         );
 181                                         exit(1);
 182
 183                                 case LUA_ERRMEM:
 184                                         err_str = luaL_checkstring(L, -1);
 185                                         fprintf(stderr,
 186                                                 "Lua handler ran out of memory, unable to continue\n"
 187                                                 "Error: %s\n", err_str
 188                                         );
 189                                         exit(1);
 190
 191                                 default:
 192                                         /* test handler function */
 193                                         lua_getglobal(L, UH_LUA_CALLBACK);
 194
 195                                         if( ! lua_isfunction(L, -1) )
 196                                         {
 197                                                 fprintf(stderr,
 198                                                         "Lua handler provides no " UH_LUA_CALLBACK "(), unable to continue\n");
 199                                                 exit(1);
 200                                         }
 201
 202                                         lua_pop(L, 1);
 203                                         break;
 204                         }
 205
 206                         break;
 207         }
 208
 209         return L;
 210 }
 211
 212 void uh_lua_request(struct client *cl, struct http_request *req, lua_State *L)
 213 {
 214         int i, data_sent;
 215         int content_length = 0;
 216         int buflen = 0;
 217         int fd_max = 0;
 218         char *query_string;
 219         const char *prefix = cl->server->conf->lua_prefix;
 220         const char *err_str = NULL;
 221
 222         int rfd[2] = { 0, 0 };
 223         int wfd[2] = { 0, 0 };
 224
 225         char buf[UH_LIMIT_MSGHEAD];
 226
 227         pid_t child;
 228
 229         fd_set reader;
 230         fd_set writer;
 231
 232         struct sigaction sa;
 233         struct timeval timeout;
 234
 235
 236         /* spawn pipes for me->child, child->me */
 237         if( (pipe(rfd) < 0) || (pipe(wfd) < 0) )
 238         {
 239                 uh_http_sendhf(cl, 500, "Internal Server Error",
 240                         "Failed to create pipe: %s", strerror(errno));
 241
 242                 if( rfd[0] > 0 ) close(rfd[0]);
 243                 if( rfd[1] > 0 ) close(rfd[1]);
 244                 if( wfd[0] > 0 ) close(wfd[0]);
 245                 if( wfd[1] > 0 ) close(wfd[1]);
 246
 247                 return;
 248         }
 249
 250
 251         switch( (child = fork()) )
 252         {
 253                 case -1:
 254                         uh_http_sendhf(cl, 500, "Internal Server Error",
 255                                 "Failed to fork child: %s", strerror(errno));
 256                         break;
 257
 258                 case 0:
 259                         /* restore SIGTERM */
 260                         sa.sa_flags = 0;
 261                         sa.sa_handler = SIG_DFL;
 262                         sigemptyset(&sa.sa_mask);
 263                         sigaction(SIGTERM, &sa, NULL);
 264
 265                         /* close loose pipe ends */
 266                         close(rfd[0]);
 267                         close(wfd[1]);
 268
 269                         /* patch stdout and stdin to pipes */
 270                         dup2(rfd[1], 1);
 271                         dup2(wfd[0], 0);
 272
 273                         /* put handler callback on stack */
 274                         lua_getglobal(L, UH_LUA_CALLBACK);
 275
 276                         /* build env table */
 277                         lua_newtable(L);
 278
 279                         /* request method */
 280                         switch(req->method)
 281                         {
 282                                 case UH_HTTP_MSG_GET:
 283                                         lua_pushstring(L, "GET");
 284                                         break;
 285
 286                                 case UH_HTTP_MSG_HEAD:
 287                                         lua_pushstring(L, "HEAD");
 288                                         break;
 289
 290                                 case UH_HTTP_MSG_POST:
 291                                         lua_pushstring(L, "POST");
 292                                         break;
 293                         }
 294
 295                         lua_setfield(L, -2, "REQUEST_METHOD");
 296
 297                         /* request url */
 298                         lua_pushstring(L, req->url);
 299                         lua_setfield(L, -2, "REQUEST_URI");
 300
 301                         /* script name */
 302                         lua_pushstring(L, cl->server->conf->lua_prefix);
 303                         lua_setfield(L, -2, "SCRIPT_NAME");
 304
 305                         /* query string, path info */
 306                         if( (query_string = strchr(req->url, '?')) != NULL )
 307                         {
 308                                 lua_pushstring(L, query_string + 1);
 309                                 lua_setfield(L, -2, "QUERY_STRING");
 310
 311                                 if( (int)(query_string - req->url) > strlen(prefix) )
 312                                 {
 313                                         lua_pushlstring(L,
 314                                                 &req->url[strlen(prefix)],
 315                                                 (int)(query_string - req->url) - strlen(prefix)
 316                                         );
 317
 318                                         lua_setfield(L, -2, "PATH_INFO");
 319                                 }
 320                         }
 321                         else if( strlen(req->url) > strlen(prefix) )
 322                         {
 323                                 lua_pushstring(L, &req->url[strlen(prefix)]);
 324                                 lua_setfield(L, -2, "PATH_INFO");
 325                         }
 326
 327                         /* http protcol version */
 328                         lua_pushnumber(L, floor(req->version * 10) / 10);
 329                         lua_setfield(L, -2, "HTTP_VERSION");
 330
 331                         if( req->version > 1.0 )
 332                                 lua_pushstring(L, "HTTP/1.1");
 333                         else
 334                                 lua_pushstring(L, "HTTP/1.0");
 335
 336                         lua_setfield(L, -2, "SERVER_PROTOCOL");
 337
 338
 339                         /* address information */
 340                         lua_pushstring(L, sa_straddr(&cl->peeraddr));
 341                         lua_setfield(L, -2, "REMOTE_ADDR");
 342
 343                         lua_pushinteger(L, sa_port(&cl->peeraddr));
 344                         lua_setfield(L, -2, "REMOTE_PORT");
 345
 346                         lua_pushstring(L, sa_straddr(&cl->servaddr));
 347                         lua_setfield(L, -2, "SERVER_ADDR");
 348
 349                         lua_pushinteger(L, sa_port(&cl->servaddr));
 350                         lua_setfield(L, -2, "SERVER_PORT");
 351
 352                         /* essential env vars */
 353                         foreach_header(i, req->headers)
 354                         {
 355                                 if( !strcasecmp(req->headers[i], "Content-Length") )
 356                                 {
 357                                         lua_pushnumber(L, atoi(req->headers[i+1]));
 358                                         lua_setfield(L, -2, "CONTENT_LENGTH");
 359                                 }
 360                                 else if( !strcasecmp(req->headers[i], "Content-Type") )
 361                                 {
 362                                         lua_pushstring(L, req->headers[i+1]);
 363                                         lua_setfield(L, -2, "CONTENT_TYPE");
 364                                 }
 365                         }
 366
 367                         /* misc. headers */
 368                         lua_newtable(L);
 369
 370                         foreach_header(i, req->headers)
 371                         {
 372                                 if( strcasecmp(req->headers[i], "Content-Length") &&
 373                                         strcasecmp(req->headers[i], "Content-Type")
 374                                 ) {
 375                                         lua_pushstring(L, req->headers[i+1]);
 376                                         lua_setfield(L, -2, req->headers[i]);
 377                                 }
 378                         }
 379
 380                         lua_setfield(L, -2, "headers");
 381
 382
 383                         /* call */
 384                         switch( lua_pcall(L, 1, 0, 0) )
 385                         {
 386                                 case LUA_ERRMEM:
 387                                 case LUA_ERRRUN:
 388                                         err_str = luaL_checkstring(L, -1);
 389
 390                                         if( ! err_str )
 391                                                 err_str = "Unknown error";
 392
 393                                         printf(
 394                                                 "HTTP/%.1f 500 Internal Server Error\r\n"
 395                                                 "Connection: close\r\n"
 396                                                 "Content-Type: text/plain\r\n"
 397                                                 "Content-Length: %i\r\n\r\n"
 398                                                 "Lua raised a runtime error:\n  %s\n",
 399                                                         req->version, 31 + strlen(err_str), err_str
 400                                         );
 401
 402                                         break;
 403
 404                                 default:
 405                                         break;
 406                         }
 407
 408                         close(wfd[0]);
 409                         close(rfd[1]);
 410                         exit(0);
 411
 412                         break;
 413
 414                 /* parent; handle I/O relaying */
 415                 default:
 416                         /* close unneeded pipe ends */
 417                         close(rfd[1]);
 418                         close(wfd[0]);
 419
 420                         /* max watch fd */
 421                         fd_max = max(rfd[0], wfd[1]) + 1;
 422
 423                         /* find content length */
 424                         if( req->method == UH_HTTP_MSG_POST )
 425                         {
 426                                 foreach_header(i, req->headers)
 427                                 {
 428                                         if( ! strcasecmp(req->headers[i], "Content-Length") )
 429                                         {
 430                                                 content_length = atoi(req->headers[i+1]);
 431                                                 break;
 432                                         }
 433                                 }
 434                         }
 435
 436
 437 #define ensure(x) \
 438         do { if( x < 0 ) goto out; } while(0)
 439
 440                         data_sent = 0;
 441
 442                         timeout.tv_sec = cl->server->conf->script_timeout;
 443                         timeout.tv_usec = 0;
 444
 445                         /* I/O loop, watch our pipe ends and dispatch child reads/writes from/to socket */
 446                         while( 1 )
 447                         {
 448                                 FD_ZERO(&reader);
 449                                 FD_ZERO(&writer);
 450
 451                                 FD_SET(rfd[0], &reader);
 452                                 FD_SET(wfd[1], &writer);
 453
 454                                 /* wait until we can read or write or both */
 455                                 if( select_intr(fd_max, &reader,
 456                                     (content_length > -1) ? &writer : NULL, NULL,
 457                                         (data_sent < 1) ? &timeout : NULL) > 0
 458                                 ) {
 459                                         /* ready to write to Lua child */
 460                                         if( FD_ISSET(wfd[1], &writer) )
 461                                         {
 462                                                 /* there is unread post data waiting */
 463                                                 if( content_length > 0 )
 464                                                 {
 465                                                         /* read it from socket ... */
 466                                                         if( (buflen = uh_tcp_recv(cl, buf, min(content_length, sizeof(buf)))) > 0 )
 467                                                         {
 468                                                                 /* ... and write it to child's stdin */
 469                                                                 if( write(wfd[1], buf, buflen) < 0 )
 470                                                                         perror("write()");
 471
 472                                                                 content_length -= buflen;
 473                                                         }
 474
 475                                                         /* unexpected eof! */
 476                                                         else
 477                                                         {
 478                                                                 if( write(wfd[1], "", 0) < 0 )
 479                                                                         perror("write()");
 480
 481                                                                 content_length = 0;
 482                                                         }
 483                                                 }
 484
 485                                                 /* there is no more post data, close pipe to child's stdin */
 486                                                 else if( content_length > -1 )
 487                                                 {
 488                                                         close(wfd[1]);
 489                                                         content_length = -1;
 490                                                 }
 491                                         }
 492
 493                                         /* ready to read from Lua child */
 494                                         if( FD_ISSET(rfd[0], &reader) )
 495                                         {
 496                                                 /* read data from child ... */
 497                                                 if( (buflen = read(rfd[0], buf, sizeof(buf))) > 0 )
 498                                                 {
 499                                                         /* pass through buffer to socket */
 500                                                         ensure(uh_tcp_send(cl, buf, buflen));
 501                                                         data_sent = 1;
 502                                                 }
 503
 504                                                 /* looks like eof from child */
 505                                                 else
 506                                                 {
 507                                                         /* error? */
 508                                                         if( ! data_sent )
 509                                                                 uh_http_sendhf(cl, 500, "Internal Server Error",
 510                                                                         "The Lua child did not produce any response");
 511
 512                                                         break;
 513                                                 }
 514                                         }
 515                                 }
 516
 517                                 /* timeout exceeded or interrupted by SIGCHLD */
 518                                 else
 519                                 {
 520                                         if( (errno != EINTR) && ! data_sent )
 521                                         {
 522                                                 ensure(uh_http_sendhf(cl, 504, "Gateway Timeout",
 523                                                         "The Lua script took too long to produce "
 524                                                         "a response"));
 525                                         }
 526
 527                                         break;
 528                                 }
 529                         }
 530
 531                 out:
 532                         close(rfd[0]);
 533                         close(wfd[1]);
 534
 535                         if( !kill(child, 0) )
 536                         {
 537                                 kill(child, SIGTERM);
 538                                 waitpid(child, NULL, 0);
 539                         }
 540
 541                         break;
 542         }
 543 }
 544
 545 void uh_lua_close(lua_State *L)
 546 {
 547         lua_close(L);
 548 }