[package] uhttpd:
[openwrt/svn-archive/archive.git] / 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 }