d5d78544e0e4043b297b4d85852a3923a93e7d3f
[kai/samba.git] / source4 / web_server / http.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    http handling code
5
6    Copyright (C) Andrew Tridgell 2005
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "smbd/service_task.h"
24 #include "web_server/web_server.h"
25 #include "smbd/service_stream.h"
26 #include "smbd/service.h"
27 #include "lib/events/events.h"
28 #include "system/time.h"
29 #include "system/wait.h"
30 #include "lib/appweb/esp/esp.h"
31 #include "lib/appweb/ejs/ejsInternal.h"
32 #include "lib/util/dlinklist.h"
33 #include "lib/tls/tls.h"
34 #include "scripting/ejs/smbcalls.h"
35
36 #define SAMBA_SESSION_KEY "SambaSessionId"
37 #define HTTP_PREAUTH_URI  "/scripting/preauth.esp"
38 #define JSONRPC_REQUEST   "/services"
39 #define JSONRPC_SERVER    "/request.esp"
40
41 /* state of the esp subsystem for a specific request */
42 struct esp_state {
43         struct websrv_context *web;
44         struct EspRequest *req;
45         struct MprVar variables[ESP_OBJ_MAX];
46         struct session_data *session;
47 };
48
49 /*
50   output the http headers
51 */
52 static void http_output_headers(struct websrv_context *web)
53 {
54         int i;
55         char *s;
56         DATA_BLOB b;
57         uint32_t content_length = 0;
58         const char *response_string = "Unknown Code";
59         const struct {
60                 unsigned code;
61                 const char *response_string;
62         } codes[] = {
63                 { 200, "OK" },
64                 { 301, "Moved" },
65                 { 302, "Found" },
66                 { 303, "Method" },
67                 { 304, "Not Modified" },
68                 { 400, "Bad request" },
69                 { 401, "Unauthorized" },
70                 { 403, "Forbidden" },
71                 { 404, "Not Found" },
72                 { 500, "Internal Server Error" },
73                 { 501, "Not implemented" }
74         };
75         for (i=0;i<ARRAY_SIZE(codes);i++) {
76                 if (codes[i].code == web->output.response_code) {
77                         response_string = codes[i].response_string;
78                 }
79         }
80
81         if (web->output.headers == NULL) return;
82         s = talloc_asprintf(web, "HTTP/1.0 %u %s\r\n", 
83                             web->output.response_code, response_string);
84         if (s == NULL) return;
85         for (i=0;web->output.headers[i];i++) {
86                 s = talloc_asprintf_append(s, "%s\r\n", web->output.headers[i]);
87         }
88
89         /* work out the content length */
90         content_length = web->output.content.length;
91         if (web->output.fd != -1) {
92                 struct stat st;
93                 fstat(web->output.fd, &st);
94                 content_length += st.st_size;
95         }
96         s = talloc_asprintf_append(s, "Content-Length: %u\r\n\r\n", content_length);
97         if (s == NULL) return;
98
99         b = web->output.content;
100         web->output.content = data_blob_string_const(s);
101         data_blob_append(web, &web->output.content, b.data, b.length);
102         data_blob_free(&b);
103 }
104
105 /*
106   return the local path for a URL
107 */
108 static const char *http_local_path(struct websrv_context *web,
109                                    const char *url,
110                                    const char *base_dir)
111 {
112         int i;
113         char *path;
114
115         /* check that the url is OK */
116         if (url[0] != '/') return NULL;
117
118         for (i=0;url[i];i++) {
119                 if ((!isalnum((unsigned char)url[i]) && !strchr("./_-", url[i])) ||
120                     (url[i] == '.' && strchr("/.", url[i+1]))) {
121                         return NULL;
122                 }
123         }
124
125         path = talloc_asprintf(web, "%s/%s", base_dir, url+1);
126         if (path == NULL) return NULL;
127
128         if (directory_exist(path)) {
129                 path = talloc_asprintf_append(path, "/index.esp");
130         }
131         return path;
132 }
133
134 /*
135   called when esp wants to read a file to support include() calls
136 */
137 static int http_readFile(EspHandle handle,
138                          char **buf,
139                          int *len,
140                          const char *path,
141                          const char *base_dir)
142 {
143         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
144         int fd = -1;
145         struct stat st;
146         *buf = NULL;
147
148         path = http_local_path(web, path, base_dir);
149         if (path == NULL) goto failed;
150
151         fd = open(path, O_RDONLY);
152         if (fd == -1 || fstat(fd, &st) != 0 || !S_ISREG(st.st_mode)) goto failed;
153
154         *buf = talloc_size(handle, st.st_size+1);
155         if (*buf == NULL) goto failed;
156
157         if (read(fd, *buf, st.st_size) != st.st_size) goto failed;
158
159         (*buf)[st.st_size] = 0;
160
161         close(fd);
162         *len = st.st_size;
163         return 0;
164
165 failed:
166         DEBUG(0,("Failed to read file %s - %s\n", path, strerror(errno)));
167         if (fd != -1) close(fd);
168         talloc_free(*buf);
169         *buf = NULL;
170         return -1;
171 }
172
173 static int http_readFileFromWebappsDir(EspHandle handle,
174                                        char **buf,
175                                        int *len,
176                                        const char *path)
177 {
178     return http_readFile(handle, buf, len, path, lp_webapps_directory());
179 }
180
181
182
183 /*
184   called when esp wants to find the real path of a file
185 */
186 static int http_mapToStorage(EspHandle handle, char *path, int len, const char *uri, int flags)
187 {
188         if (uri == NULL || strlen(uri) >= len) return -1;
189         strncpy(path, uri, len);
190         return 0;
191 }
192
193 /*
194   called when esp wants to output something
195 */
196 static int http_writeBlock(EspHandle handle, const char *buf, int size)
197 {
198         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
199         NTSTATUS status;
200         status = data_blob_append(web, &web->output.content, buf, size);
201         if (!NT_STATUS_IS_OK(status)) return -1;
202         return size;
203 }
204
205
206 /*
207   set a http header
208 */
209 static void http_setHeader(EspHandle handle, const char *value, bool allowMultiple)
210 {
211         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
212         char *p = strchr(value, ':');
213
214         if (p && !allowMultiple && web->output.headers) {
215                 int i;
216                 for (i=0;web->output.headers[i];i++) {
217                         if (strncmp(web->output.headers[i], value, (p+1)-value) == 0) {
218                                 web->output.headers[i] = talloc_strdup(web, value);
219                                 return;
220                         }
221                 }
222         }
223
224         web->output.headers = str_list_add(web->output.headers, value);
225         talloc_steal(web, web->output.headers);
226 }
227
228 /*
229   set a http response code
230 */
231 static void http_setResponseCode(EspHandle handle, int code)
232 {
233         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
234         web->output.response_code = code;
235 }
236
237 /*
238   redirect to another web page
239  */
240 static void http_redirect(EspHandle handle, int code, char *url)
241 {
242         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
243         const char *host = web->input.host;
244         
245         /* form the full url, unless it already looks like a url */
246         if (strchr(url, ':') == NULL) {
247                 if (host == NULL) {
248                         struct socket_address *socket_address = socket_get_my_addr(web->conn->socket, web);
249                         if (socket_address == NULL) goto internal_error;
250                         host = talloc_asprintf(web, "%s:%u",
251                                                socket_address->addr, socket_address->port);
252                 }
253                 if (host == NULL) goto internal_error;
254                 if (url[0] != '/') {
255                         char *p = strrchr(web->input.url, '/');
256                         if (p == web->input.url) {
257                                 url = talloc_asprintf(web, "http%s://%s/%s", 
258                                                       tls_enabled(web->conn->socket)?"s":"",
259                                                       host, url);
260                         } else {
261                                 int dirlen = p - web->input.url;
262                                 url = talloc_asprintf(web, "http%s://%s%*.*s/%s",
263                                                       tls_enabled(web->conn->socket)?"s":"",
264                                                       host, 
265                                                       dirlen, dirlen, web->input.url,
266                                                       url);
267                         }
268                         if (url == NULL) goto internal_error;
269                 }
270         }
271
272         http_setHeader(handle, talloc_asprintf(web, "Location: %s", url), 0);
273
274         /* make sure we give a valid redirect code */
275         if (code >= 300 && code < 400) {
276                 http_setResponseCode(handle, code);
277         } else {
278                 http_setResponseCode(handle, 302);
279         }
280         return;
281
282 internal_error:
283         http_error(web, 500, "Internal server error");
284 }
285
286
287 /*
288   setup a cookie
289 */
290 static void http_setCookie(EspHandle handle, const char *name, const char *value, 
291                            int lifetime, const char *path, bool secure)
292 {
293         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
294         char *buf;
295         
296         if (lifetime > 0) {
297                 buf = talloc_asprintf(web, "Set-Cookie: %s=%s; path=%s; Expires=%s; %s",
298                                       name, value, path?path:"/", 
299                                       http_timestring(web, time(NULL)+lifetime),
300                                       secure?"secure":"");
301         } else {
302                 buf = talloc_asprintf(web, "Set-Cookie: %s=%s; path=%s; %s",
303                                       name, value, path?path:"/", 
304                                       secure?"secure":"");
305         }
306         http_setHeader(handle, "Cache-control: no-cache=\"set-cookie\"", 0);
307         http_setHeader(handle, buf, 0);
308         talloc_free(buf);
309 }
310
311 /*
312   return the session id
313 */
314 static const char *http_getSessionId(EspHandle handle)
315 {
316         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
317         return web->session->id;
318 }
319
320 /*
321   setup a session
322 */
323 static void http_createSession(EspHandle handle, int timeout)
324 {
325         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
326         if (web->session) {
327                 web->session->lifetime = timeout;
328                 http_setCookie(web, SAMBA_SESSION_KEY, web->session->id, 
329                                web->session->lifetime, "/", 0);
330         }
331 }
332
333 /*
334   destroy a session
335 */
336 static void http_destroySession(EspHandle handle)
337 {
338         struct websrv_context *web = talloc_get_type(handle, struct websrv_context);
339         talloc_free(web->session);
340         web->session = NULL;
341 }
342
343
344 /*
345   setup for a raw http level error
346 */
347 void http_error(struct websrv_context *web, int code, const char *info)
348 {
349         char *s;
350         s = talloc_asprintf(web,"<HTML><HEAD><TITLE>Error %u</TITLE></HEAD><BODY><H1>Error %u</H1><pre>%s</pre><p></BODY></HTML>\r\n\r\n", 
351                             code, code, info);
352         if (s == NULL) {
353                 stream_terminate_connection(web->conn, "http_error: out of memory");
354                 return;
355         }
356         http_writeBlock(web, s, strlen(s));
357         http_setResponseCode(web, code);
358         http_output_headers(web);
359         EVENT_FD_NOT_READABLE(web->conn->event.fde);
360         EVENT_FD_WRITEABLE(web->conn->event.fde);
361         web->output.output_pending = True;
362 }
363
364 /*
365   map a unix error code to a http error
366 */
367 void http_error_unix(struct websrv_context *web, const char *info)
368 {
369         int code = 500;
370         switch (errno) {
371         case ENOENT:
372         case EISDIR:
373                 code = 404;
374                 break;
375         case EACCES:
376                 code = 403;
377                 break;
378         }
379         info = talloc_asprintf(web, "%s<p>%s<p>\n", info, strerror(errno));
380         http_error(web, code, info);
381 }
382
383
384 /*
385   a simple file request
386 */
387 static void http_simple_request(struct websrv_context *web)
388 {
389         const char *url = web->input.url;
390         const char *path;
391         struct stat st;
392
393         path = http_local_path(web, url, lp_webapps_directory());
394         if (path == NULL) goto invalid;
395
396         /* looks ok */
397         web->output.fd = open(path, O_RDONLY);
398         if (web->output.fd == -1) {
399                 DEBUG(0,("Failed to read file %s - %s\n", path, strerror(errno)));
400                 http_error_unix(web, path);
401                 return;
402         }
403
404         if (fstat(web->output.fd, &st) != 0 || !S_ISREG(st.st_mode)) {
405                 close(web->output.fd);
406                 goto invalid;
407         }
408
409         return;
410
411 invalid:
412         http_error(web, 400, "Malformed URL");
413 }
414
415 /*
416   setup the standard ESP arrays
417 */
418 static void http_setup_arrays(struct esp_state *esp)
419 {
420         struct websrv_context *web = esp->web;
421         struct esp_data *edata = talloc_get_type(web->task->private, struct esp_data);
422         struct EspRequest *req = esp->req;
423         struct socket_address *socket_address = socket_get_my_addr(web->conn->socket, esp);
424         struct socket_address *peer_address = socket_get_peer_addr(web->conn->socket, esp);
425         char *p;
426
427 #define SETVAR(type, name, value) do { \
428                 const char *v = value; \
429                 if (v) espSetStringVar(req, type, name, v); \
430 } while (0)
431
432         SETVAR(ESP_REQUEST_OBJ, "CONTENT_LENGTH", 
433                talloc_asprintf(esp, "%u", web->input.content_length));
434         SETVAR(ESP_REQUEST_OBJ, "QUERY_STRING", web->input.query_string);
435         SETVAR(ESP_REQUEST_OBJ, "POST_DATA",
436                talloc_strndup(esp,
437                               web->input.partial.data,
438                               web->input.partial.length));
439         SETVAR(ESP_REQUEST_OBJ, "REQUEST_METHOD", web->input.post_request?"POST":"GET");
440         SETVAR(ESP_REQUEST_OBJ, "REQUEST_URI", web->input.url);
441         p = strrchr(web->input.url, '/');
442         SETVAR(ESP_REQUEST_OBJ, "SCRIPT_NAME", p+1);
443         SETVAR(ESP_REQUEST_OBJ, "SCRIPT_FILENAME", web->input.url);
444         if (peer_address) {
445                 struct MprVar mpv = mprObject("socket_address");
446                 mprSetPtrChild(&mpv, "socket_address", peer_address);
447                 espSetVar(req, ESP_REQUEST_OBJ, "REMOTE_SOCKET_ADDRESS", mpv);
448                 SETVAR(ESP_REQUEST_OBJ, "REMOTE_ADDR", peer_address->addr);
449         }
450         p = socket_get_peer_name(web->conn->socket, esp);
451         SETVAR(ESP_REQUEST_OBJ, "REMOTE_HOST", p);
452         SETVAR(ESP_REQUEST_OBJ, "REMOTE_USER", "");
453         SETVAR(ESP_REQUEST_OBJ, "CONTENT_TYPE", web->input.content_type);
454         if (web->session) {
455                 SETVAR(ESP_REQUEST_OBJ, "SESSION_ID", web->session->id);
456         }
457         SETVAR(ESP_REQUEST_OBJ, "COOKIE_SUPPORT", web->input.cookie?"True":"False");
458
459         SETVAR(ESP_HEADERS_OBJ, "HTTP_REFERER", web->input.referer);
460         SETVAR(ESP_HEADERS_OBJ, "HOST", web->input.host);
461         SETVAR(ESP_HEADERS_OBJ, "ACCEPT_ENCODING", web->input.accept_encoding);
462         SETVAR(ESP_HEADERS_OBJ, "ACCEPT_LANGUAGE", web->input.accept_language);
463         SETVAR(ESP_HEADERS_OBJ, "ACCEPT_CHARSET", web->input.accept_charset);
464         SETVAR(ESP_HEADERS_OBJ, "COOKIE", web->input.cookie);
465         SETVAR(ESP_HEADERS_OBJ, "USER_AGENT", web->input.user_agent);
466
467         if (socket_address) {
468                 SETVAR(ESP_SERVER_OBJ, "SERVER_ADDR", socket_address->addr);
469                 SETVAR(ESP_SERVER_OBJ, "SERVER_NAME", socket_address->addr);
470                 SETVAR(ESP_SERVER_OBJ, "SERVER_HOST", socket_address->addr);
471                 SETVAR(ESP_SERVER_OBJ, "SERVER_PORT", 
472                        talloc_asprintf(esp, "%u", socket_address->port));
473         }
474
475         SETVAR(ESP_SERVER_OBJ, "DOCUMENT_ROOT", lp_webapps_directory());
476         SETVAR(ESP_SERVER_OBJ, "SERVER_PROTOCOL", tls_enabled(web->conn->socket)?"https":"http");
477         SETVAR(ESP_SERVER_OBJ, "SERVER_SOFTWARE", "SAMBA");
478         SETVAR(ESP_SERVER_OBJ, "GATEWAY_INTERFACE", "CGI/1.1");
479         SETVAR(ESP_SERVER_OBJ, "TLS_SUPPORT", tls_support(edata->tls_params)?"True":"False");
480 }
481
482 #if HAVE_SETJMP_H
483 /* the esp scripting lirary generates exceptions when
484    it hits a major error. We need to catch these and
485    report a internal server error via http
486 */
487 static jmp_buf ejs_exception_buf;
488 static const char *exception_reason;
489
490 static void web_server_ejs_exception(const char *reason)
491 {
492         Ejs *ep = ejsPtr(0);
493         if (ep) {
494                 ejsSetErrorMsg(0, "%s", reason);
495                 exception_reason = ep->error;
496         } else {
497                 exception_reason = reason;
498         }
499         DEBUG(0,("%s", exception_reason));
500         longjmp(ejs_exception_buf, -1);
501 }
502 #else
503 static void web_server_ejs_exception(const char *reason)
504 {
505         DEBUG(0,("%s", reason));
506         smb_panic(reason);
507 }
508 #endif
509
510 /*
511   process a esp request
512 */
513 static void esp_request(struct esp_state *esp, const char *url)
514 {
515         struct websrv_context *web = esp->web;
516         int size;
517         int res;
518         char *emsg = NULL, *buf;
519
520         if (http_readFile(web, &buf, &size, url, lp_webapps_directory()) != 0) {
521                 http_error_unix(web, url);
522                 return;
523         }
524
525 #if HAVE_SETJMP_H
526         if (setjmp(ejs_exception_buf) != 0) {
527                 http_error(web, 500, exception_reason);
528                 return;
529         }
530 #endif
531
532         res = espProcessRequest(esp->req, url, buf, &emsg);
533         if (res != 0 && emsg) {
534                 http_writeBlock(web, "<pre>", 5);
535                 http_writeBlock(web, emsg, strlen(emsg));
536                 http_writeBlock(web, "</pre>", 6);
537         }
538         talloc_free(buf);
539 }
540
541 /*
542   process a JSON RPC request
543 */
544 static void jsonrpc_request(struct esp_state *esp)
545 {
546         struct websrv_context *web = esp->web;
547         const char *path = http_local_path(web,
548                                            JSONRPC_SERVER,
549                                            lp_jsonrpc_services_dir());
550         MprVar *global;
551         MprVar v;
552         MprVar temp;
553         int size;
554         int res;
555         char *emsg = NULL;
556         char *emsg2 = NULL;
557         char *buf;
558         char *error_script =
559                 "error.setOrigin(jsonrpc.Constant.ErrorOrigin.Server); "
560                 "error.setError(jsonrpc.Constant.ErrorCode.UnexpectedOutput, "
561                 "               global.errorString);"
562                 "error.Send();";
563
564         /* Ensure we got a valid path. */
565         if (path == NULL) {
566                 /* should never occur */
567                 http_error(esp->web, 500, "Internal server error");
568                 return;
569         }
570
571         /* Ensure that the JSON-RPC server request script exists */
572         if (!file_exist(path)) {
573                 http_error_unix(esp->web, path);
574                 return;
575         }
576
577         /* Call the server request script */
578         if (http_readFile(web, &buf, &size,
579                           JSONRPC_SERVER, lp_jsonrpc_services_dir()) != 0) {
580                 http_error_unix(web, JSONRPC_SERVER);
581                 return;
582         }
583
584 #if HAVE_SETJMP_H
585         if (setjmp(ejs_exception_buf) != 0) {
586                 http_error(web, 500, exception_reason);
587                 return;
588         }
589 #endif
590
591         res = espProcessRequest(esp->req, JSONRPC_SERVER, buf, &emsg);
592         if (res != 0 && emsg) {
593                 /* Save the error in a string accessible from javascript */
594                 global = ejsGetGlobalObject(0);
595                 v = mprString(emsg);
596                 mprCreateProperty(global, "errorString", &v);
597
598                 /* Create and send a JsonRpcError object */
599                 if (ejsEvalScript(0,
600                                   error_script,
601                                   &temp,
602                                   &emsg2) != 0) {
603                         http_writeBlock(web, "<pre>", 5);
604                         http_writeBlock(web, emsg, strlen(emsg));
605                         http_writeBlock(web, "</pre>", 6);
606                 }
607         }
608         talloc_free(buf);
609 }
610
611 /*
612   perform pre-authentication on every page if /scripting/preauth.esp
613   exists.  If this script generates any non-whitepace output at all,
614   then we don't run the requested URL.
615
616   note that the preauth is run even for static pages such as images, but not
617   for JSON-RPC service requests which do their own authentication via the
618   JSON-RPC server.
619 */
620 static BOOL http_preauth(struct esp_state *esp)
621 {
622         const char *path = http_local_path(esp->web,
623                                            HTTP_PREAUTH_URI,
624                                            lp_webapps_directory());
625         int i;
626         if (path == NULL) {
627                 http_error(esp->web, 500, "Internal server error");
628                 return False;
629         }
630         if (!file_exist(path)) {
631                 /* if the preath script is not installed then allow access */
632                 return True;
633         }
634         esp_request(esp, HTTP_PREAUTH_URI);
635         for (i=0;i<esp->web->output.content.length;i++) {
636                 if (!isspace(esp->web->output.content.data[i])) {
637                         /* if the preauth has generated content, then force it
638                            to be html, so that we can show the login page for
639                            failed access to images */
640                         http_setHeader(esp->web, "Content-Type: text/html", 0);
641                         return False;
642                 }
643         }
644         data_blob_free(&esp->web->output.content);
645         return True;
646 }
647
648
649 /* 
650    handling of + and % escapes in http variables 
651 */
652 static const char *http_unescape(TALLOC_CTX *mem_ctx, const char *p)
653 {
654         char *s0 = talloc_strdup(mem_ctx, p);
655         char *s = s0;
656         if (s == NULL) return NULL;
657
658         while (*s) {
659                 unsigned v;
660                 if (*s == '+') *s = ' ';
661                 if (*s == '%' && sscanf(s+1, "%02x", &v) == 1) {
662                         *s = (char)v;
663                         memmove(s+1, s+3, strlen(s+3)+1);
664                 }
665                 s++;
666         }
667
668         return s0;
669 }
670
671 /*
672   set a form or GET variable
673 */
674 static void esp_putvar(struct esp_state *esp, const char *var, const char *value)
675 {
676         if (strcasecmp(var, SAMBA_SESSION_KEY) == 0) {
677                 /* special case support for browsers without cookie
678                  support */
679                 esp->web->input.session_key = talloc_strdup(esp, value);
680         } else {
681                 mprSetPropertyValue(&esp->variables[ESP_FORM_OBJ], 
682                                     http_unescape(esp, var),
683                                     mprCreateStringVar(http_unescape(esp, value), 0));
684         }
685 }
686
687
688 /*
689   parse the variables in a POST style request
690 */
691 static NTSTATUS http_parse_post(struct esp_state *esp)
692 {
693         DATA_BLOB b = esp->web->input.partial;
694
695         while (b.length) {
696                 char *p, *line;
697                 size_t len;
698
699                 p = memchr(b.data, '&', b.length);
700                 if (p == NULL) {
701                         len = b.length;
702                 } else {
703                         len = p - (char *)b.data;
704                 }
705                 line = talloc_strndup(esp, (char *)b.data, len);
706                 NT_STATUS_HAVE_NO_MEMORY(line);
707                                      
708                 p = strchr(line,'=');
709                 if (p) {
710                         *p = 0;
711                         esp_putvar(esp, line, p+1);
712                 }
713                 talloc_free(line);
714                 b.length -= len;
715                 b.data += len;
716                 if (b.length > 0) {
717                         b.length--;
718                         b.data++;
719                 }
720         }
721
722         return NT_STATUS_OK;
723 }
724
725 /*
726   parse the variables in a GET style request
727 */
728 static NTSTATUS http_parse_get(struct esp_state *esp)
729 {
730         struct websrv_context *web = esp->web;
731         char *p, *s, *tok;
732         char *pp;
733
734         p = strchr(web->input.url, '?');
735         web->input.query_string = p+1;
736         *p = 0;
737
738         s = talloc_strdup(esp, esp->web->input.query_string);
739         NT_STATUS_HAVE_NO_MEMORY(s);
740
741         for (tok=strtok_r(s,"&;", &pp);tok;tok=strtok_r(NULL,"&;", &pp)) {
742                 p = strchr(tok,'=');
743                 if (p) {
744                         *p = 0;
745                         esp_putvar(esp, tok, p+1);
746                 }
747         }
748         return NT_STATUS_OK;
749 }
750
751 /*
752   called when a session times out
753 */
754 static void session_timeout(struct event_context *ev, struct timed_event *te, 
755                             struct timeval t, void *private)
756 {
757         struct session_data *s = talloc_get_type(private, struct session_data);
758         talloc_free(s);
759 }
760
761 /*
762   destroy a session
763  */
764 static int session_destructor(struct session_data *s)
765 {
766         DLIST_REMOVE(s->edata->sessions, s);
767         return 0;
768 }
769
770 /*
771   setup the session for this request
772 */
773 static void http_setup_session(struct esp_state *esp)
774 {
775         const char *session_key = SAMBA_SESSION_KEY;
776         char *p;
777         const char *cookie = esp->web->input.cookie;
778         const char *key = NULL;
779         struct esp_data *edata = talloc_get_type(esp->web->task->private, struct esp_data);
780         struct session_data *s;
781         BOOL generated_key = False;
782
783         /* look for our session key */
784         if (cookie && (p = strstr(cookie, session_key)) && 
785             p[strlen(session_key)] == '=') {
786                 p += strlen(session_key)+1;
787                 key = talloc_strndup(esp, p, strcspn(p, ";"));
788         }
789
790         if (key == NULL && esp->web->input.session_key) {
791                 key = esp->web->input.session_key;
792         } else if (key == NULL) {
793                 key = generate_random_str_list(esp, 16, "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
794                 generated_key = True;
795         }
796
797         /* try to find this session in the existing session list */
798         for (s=edata->sessions;s;s=s->next) {
799                 if (strcmp(key, s->id) == 0) {
800                         break;
801                 }
802         }
803
804         if (s == NULL) {
805                 /* create a new session */
806                 s = talloc_zero(edata, struct session_data);
807                 s->id = talloc_steal(s, key);
808                 s->data = NULL;
809                 s->te = NULL;
810                 s->edata = edata;
811                 s->lifetime = lp_parm_int(-1, "web", "sessiontimeout", 900);
812                 DLIST_ADD(edata->sessions, s);
813                 talloc_set_destructor(s, session_destructor);
814                 if (!generated_key) {
815                         mprSetPropertyValue(&esp->variables[ESP_REQUEST_OBJ], 
816                                             "SESSION_EXPIRED", mprCreateStringVar("True", 0));
817                 }
818         }
819
820         http_setCookie(esp->web, session_key, key, s->lifetime, "/", 0);
821
822         if (s->data) {
823                 mprCopyVar(&esp->variables[ESP_SESSION_OBJ], s->data, MPR_DEEP_COPY);
824         }
825
826         esp->web->session = s;
827 }
828
829
830 /* callbacks for esp processing */
831 static const struct Esp esp_control = {
832         .maxScriptSize   = 60000,
833         .writeBlock      = http_writeBlock,
834         .setHeader       = http_setHeader,
835         .redirect        = http_redirect,
836         .setResponseCode = http_setResponseCode,
837         .readFile        = http_readFileFromWebappsDir,
838         .mapToStorage    = http_mapToStorage,
839         .setCookie       = http_setCookie,
840         .createSession   = http_createSession,
841         .destroySession  = http_destroySession,
842         .getSessionId    = http_getSessionId
843 };
844
845 /*
846   process a complete http request
847 */
848 void http_process_input(struct websrv_context *web)
849 {
850         NTSTATUS status;
851         struct esp_state *esp = NULL;
852         struct esp_data *edata = talloc_get_type(web->task->private, struct esp_data);
853         struct smbcalls_context *smbcalls_ctx;
854         char *p;
855         void *save_mpr_ctx = mprMemCtx();
856         void *ejs_save = ejs_save_state();
857         int i;
858         const char *file_type = NULL;
859         enum page_type {
860                 page_type_simple,
861                 page_type_esp,
862                 page_type_jsonrpc
863         };
864         enum page_type page_type;
865         const struct {
866                 const char *extension;
867                 const char *mime_type;
868                 enum page_type page_type;
869         } mime_types[] = {
870                 {"gif",  "image/gif"},
871                 {"png",  "image/png"},
872                 {"jpg",  "image/jpeg"},
873                 {"txt",  "text/plain"},
874                 {"ico",  "image/x-icon"},
875                 {"css",  "text/css"},
876                 {"esp",  "text/html", True}
877         };
878
879         /*
880          * give the smbcalls a chance to find the event context
881          * and messaging context 
882          */
883         smbcalls_ctx = talloc(web, struct smbcalls_context);
884         if (smbcalls_ctx == NULL) goto internal_error;
885         smbcalls_ctx->event_ctx = web->conn->event.ctx;
886         smbcalls_ctx->msg_ctx = web->conn->msg_ctx;
887
888         esp = talloc_zero(smbcalls_ctx, struct esp_state);
889         if (esp == NULL) goto internal_error;
890
891         esp->web = web;
892
893         mprSetCtx(esp);
894
895         if (espOpen(&esp_control) != 0) goto internal_error;
896
897         for (i=0;i<ARRAY_SIZE(esp->variables);i++) {
898                 esp->variables[i] = mprCreateUndefinedVar();
899         }
900         esp->variables[ESP_HEADERS_OBJ]     = mprCreateObjVar("headers", ESP_HASH_SIZE);
901         esp->variables[ESP_FORM_OBJ]        = mprCreateObjVar("form", ESP_HASH_SIZE);
902         esp->variables[ESP_APPLICATION_OBJ] = mprCreateObjVar("application", ESP_HASH_SIZE);
903         esp->variables[ESP_COOKIES_OBJ]     = mprCreateObjVar("cookies", ESP_HASH_SIZE);
904         esp->variables[ESP_FILES_OBJ]       = mprCreateObjVar("files", ESP_HASH_SIZE);
905         esp->variables[ESP_REQUEST_OBJ]     = mprCreateObjVar("request", ESP_HASH_SIZE);
906         esp->variables[ESP_SERVER_OBJ]      = mprCreateObjVar("server", ESP_HASH_SIZE);
907         esp->variables[ESP_SESSION_OBJ]     = mprCreateObjVar("session", ESP_HASH_SIZE);
908
909         if (edata->application_data) {
910                 mprCopyVar(&esp->variables[ESP_APPLICATION_OBJ], 
911                            edata->application_data, MPR_DEEP_COPY);
912         }
913
914         smb_setup_ejs_functions(web_server_ejs_exception);
915
916         if (web->input.url == NULL) {
917                 http_error(web, 400, "You must specify a GET or POST request");
918                 mprSetCtx(save_mpr_ctx);
919                 ejs_restore_state(ejs_save);
920                 return;
921         }
922         
923         /* parse any form or get variables */
924         if (web->input.post_request) {
925                 status = http_parse_post(esp);
926                 if (!NT_STATUS_IS_OK(status)) {
927                         http_error(web, 400, "Malformed POST data");
928                         mprSetCtx(save_mpr_ctx);
929                         ejs_restore_state(ejs_save);
930                         return;
931                 }
932         } 
933         if (strchr(web->input.url, '?')) {
934                 status = http_parse_get(esp);
935                 if (!NT_STATUS_IS_OK(status)) {
936                         http_error(web, 400, "Malformed GET data");
937                         mprSetCtx(save_mpr_ctx);
938                         ejs_restore_state(ejs_save);
939                         return;
940                 }
941         }
942
943         http_setup_session(esp);
944
945         esp->req = espCreateRequest(web, web->input.url, esp->variables);
946         if (esp->req == NULL) goto internal_error;
947
948         /*
949          * Work out the mime type.  First, we see if the request is a JSON-RPC
950          * service request.  If not, we look at the extension.
951          */
952         if (strncmp(web->input.url,
953                     JSONRPC_REQUEST,
954                     sizeof(JSONRPC_REQUEST) - 1) == 0 &&
955             (web->input.url[sizeof(JSONRPC_REQUEST) - 1] == '\0' ||
956              web->input.url[sizeof(JSONRPC_REQUEST) - 1] == '/')) {
957             page_type = page_type_jsonrpc;
958             file_type = "text/json";
959             
960         } else {
961             p = strrchr(web->input.url, '.');
962             if (p == NULL) {
963                     page_type = page_type_esp;
964                     file_type = "text/html";
965             }
966             for (i=0;p && i<ARRAY_SIZE(mime_types);i++) {
967                 if (strcmp(mime_types[i].extension, p+1) == 0) {
968                     page_type = mime_types[i].page_type;
969                     file_type = mime_types[i].mime_type;
970                 }
971             }
972             if (file_type == NULL) {
973                 page_type = page_type_simple;
974                 file_type = "text/html";
975             }
976         }
977
978         /* setup basic headers */
979         http_setResponseCode(web, 200);
980         http_setHeader(web, talloc_asprintf(esp, "Date: %s", 
981                                             http_timestring(esp, time(NULL))), 0);
982         http_setHeader(web, "Server: Samba", 0);
983         http_setHeader(web, "Connection: close", 0);
984         http_setHeader(web, talloc_asprintf(esp, "Content-Type: %s", file_type), 0);
985
986         http_setup_arrays(esp);
987
988         /*
989          * Do pre-authentication.  If pre-authentication succeeds, do
990          * page-type-specific processing.
991          */
992         switch(page_type)
993         {
994         case page_type_simple:
995                 if (http_preauth(esp)) {
996                         http_simple_request(web);
997                 }
998                 break;
999
1000         case page_type_esp:
1001                 if (http_preauth(esp)) {
1002                         esp_request(esp, web->input.url);
1003                 }
1004                 break;
1005
1006         case page_type_jsonrpc:
1007                 jsonrpc_request(esp);
1008                 break;
1009         }
1010
1011         if (web->conn == NULL) {
1012                 /* the connection has been terminated above us, probably
1013                    via a timeout */
1014                 goto internal_error;
1015         }
1016
1017         if (!web->output.output_pending) {
1018                 http_output_headers(web);
1019                 EVENT_FD_WRITEABLE(web->conn->event.fde);
1020                 web->output.output_pending = True;
1021         }
1022
1023         /* copy any application data to long term storage in edata */
1024         talloc_free(edata->application_data);
1025         edata->application_data = talloc_zero(edata, struct MprVar);
1026         mprSetCtx(edata->application_data);
1027         mprCopyVar(edata->application_data, &esp->variables[ESP_APPLICATION_OBJ], 
1028                    MPR_DEEP_COPY);
1029         mprSetCtx(esp);
1030
1031         /* copy any session data */
1032         if (web->session) {
1033                 talloc_free(web->session->data);
1034                 web->session->data = talloc_zero(web->session, struct MprVar);
1035                 if (esp->variables[ESP_SESSION_OBJ].properties == NULL ||
1036                     esp->variables[ESP_SESSION_OBJ].properties[0].numItems == 0) {
1037                         talloc_free(web->session);
1038                         web->session = NULL;
1039                 } else {
1040                         mprSetCtx(web->session->data);
1041                         mprCopyVar(web->session->data, &esp->variables[ESP_SESSION_OBJ], 
1042                                    MPR_DEEP_COPY);
1043                         /* setup the timeout for the session data */
1044                         mprSetCtx(esp);
1045                         talloc_free(web->session->te);
1046                         web->session->te = event_add_timed(web->conn->event.ctx, web->session, 
1047                                                            timeval_current_ofs(web->session->lifetime, 0), 
1048                                                            session_timeout, web->session);
1049                 }
1050         }
1051
1052         talloc_free(esp);
1053         mprSetCtx(save_mpr_ctx);
1054         ejs_restore_state(ejs_save);
1055         return;
1056         
1057 internal_error:
1058         mprSetCtx(esp);
1059         talloc_free(esp);
1060         if (web->conn != NULL) {
1061                 http_error(web, 500, "Internal server error");
1062         }
1063         mprSetCtx(save_mpr_ctx);
1064         ejs_restore_state(ejs_save);
1065 }
1066
1067
1068 /*
1069   parse one line of header input
1070 */
1071 NTSTATUS http_parse_header(struct websrv_context *web, const char *line)
1072 {
1073         if (line[0] == 0) {
1074                 web->input.end_of_headers = True;
1075         } else if (strncasecmp(line,"GET ", 4)==0) {
1076                 web->input.url = talloc_strndup(web, &line[4], strcspn(&line[4], " \t"));
1077         } else if (strncasecmp(line,"POST ", 5)==0) {
1078                 web->input.post_request = True;
1079                 web->input.url = talloc_strndup(web, &line[5], strcspn(&line[5], " \t"));
1080         } else if (strchr(line, ':') == NULL) {
1081                 http_error(web, 400, "This server only accepts GET and POST requests");
1082                 return NT_STATUS_INVALID_PARAMETER;
1083         } else if (strncasecmp(line,"Content-Length: ", 16)==0) {
1084                 web->input.content_length = strtoul(&line[16], NULL, 10);
1085         } else {
1086 #define PULL_HEADER(v, s) do { \
1087         if (strncmp(line, s, strlen(s)) == 0) { \
1088                 web->input.v = talloc_strdup(web, &line[strlen(s)]); \
1089                 return NT_STATUS_OK; \
1090         } \
1091 } while (0)
1092                 PULL_HEADER(content_type, "Content-Type: ");
1093                 PULL_HEADER(user_agent, "User-Agent: ");
1094                 PULL_HEADER(referer, "Referer: ");
1095                 PULL_HEADER(host, "Host: ");
1096                 PULL_HEADER(accept_encoding, "Accept-Encoding: ");
1097                 PULL_HEADER(accept_language, "Accept-Language: ");
1098                 PULL_HEADER(accept_charset, "Accept-Charset: ");
1099                 PULL_HEADER(cookie, "Cookie: ");
1100         }
1101
1102         /* ignore all other headers for now */
1103         return NT_STATUS_OK;
1104 }
1105
1106
1107 /*
1108   setup the esp processor - called at task initialisation
1109 */
1110 NTSTATUS http_setup_esp(struct task_server *task)
1111 {
1112         struct esp_data *edata;
1113
1114         edata = talloc_zero(task, struct esp_data);
1115         NT_STATUS_HAVE_NO_MEMORY(edata);
1116
1117         task->private = edata;
1118
1119         edata->tls_params = tls_initialise(edata);
1120         NT_STATUS_HAVE_NO_MEMORY(edata->tls_params);
1121
1122         return NT_STATUS_OK;
1123 }