b2f6f5f4ba22dd2f5d6a7d9be14c0ec842780e46
[sfrench/samba-autobuild/.git] / source4 / web_server / web_server.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    web server startup
5
6    Copyright (C) Andrew Tridgell 2005
7    Copyright (C) Jelmer Vernooij 2008
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "web_server/web_server.h"
25 #include "../lib/util/dlinklist.h"
26 #include "lib/tls/tls.h"
27 #include "lib/events/events.h"
28 #include "lib/socket/netif.h"
29 #include "param/param.h"
30
31 /* don't allow connections to hang around forever */
32 #define HTTP_TIMEOUT 120
33
34 /*
35   destroy a web connection
36 */
37 static int websrv_destructor(struct websrv_context *web)
38 {
39         return 0;
40 }
41
42 /*
43   called when a connection times out. This prevents a stuck connection
44   from hanging around forever
45 */
46 static void websrv_timeout(struct tevent_context *event_context, 
47                            struct tevent_timer *te, 
48                            struct timeval t, void *private_data)
49 {
50         struct websrv_context *web = talloc_get_type(private_data, struct websrv_context);
51         struct stream_connection *conn = web->conn;
52         web->conn = NULL;
53         /* TODO: send a message to any running esp context on this connection
54            to stop running */
55         stream_terminate_connection(conn, "websrv_timeout: timed out"); 
56 }
57
58 /*
59   setup for a raw http level error
60 */
61 void http_error(struct websrv_context *web, const char *status, const char *info)
62 {
63         char *s;
64         s = talloc_asprintf(web,"<HTML><HEAD><TITLE>Error %s</TITLE></HEAD><BODY><H1>Error %s</H1><pre>%s</pre><p></BODY></HTML>\r\n\r\n", 
65                             status, status, info);
66         if (s == NULL) {
67                 stream_terminate_connection(web->conn, "http_error: out of memory");
68                 return;
69         }
70         websrv_output_headers(web, status, NULL);
71         websrv_output(web, s, strlen(s));
72 }
73
74 void websrv_output_headers(struct websrv_context *web, const char *status, struct http_header *headers)
75 {
76         char *s;
77         DATA_BLOB b;
78         struct http_header *hdr;
79
80         s = talloc_asprintf(web, "HTTP/1.0 %s\r\n", status);
81         if (s == NULL) return;
82         for (hdr = headers; hdr; hdr = hdr->next) {
83                 s = talloc_asprintf_append_buffer(s, "%s: %s\r\n", hdr->name, hdr->value);
84         }
85
86         s = talloc_asprintf_append_buffer(s, "\r\n");
87
88         b = web->output.content;
89         web->output.content = data_blob_string_const(s);
90         websrv_output(web, b.data, b.length);
91         data_blob_free(&b);
92 }
93
94 void websrv_output(struct websrv_context *web, void *data, size_t length)
95 {
96         data_blob_append(web, &web->output.content, data, length);
97         EVENT_FD_NOT_READABLE(web->conn->event.fde);
98         EVENT_FD_WRITEABLE(web->conn->event.fde);
99         web->output.output_pending = true;
100 }
101
102
103 /*
104   parse one line of header input
105 */
106 NTSTATUS http_parse_header(struct websrv_context *web, const char *line)
107 {
108         if (line[0] == 0) {
109                 web->input.end_of_headers = true;
110         } else if (strncasecmp(line,"GET ", 4)==0) {
111                 web->input.url = talloc_strndup(web, &line[4], strcspn(&line[4], " \t"));
112         } else if (strncasecmp(line,"POST ", 5)==0) {
113                 web->input.post_request = true;
114                 web->input.url = talloc_strndup(web, &line[5], strcspn(&line[5], " \t"));
115         } else if (strchr(line, ':') == NULL) {
116                 http_error(web, "400 Bad request", "This server only accepts GET and POST requests");
117                 return NT_STATUS_INVALID_PARAMETER;
118         } else if (strncasecmp(line, "Content-Length: ", 16)==0) {
119                 web->input.content_length = strtoul(&line[16], NULL, 10);
120         } else {
121                 struct http_header *hdr = talloc_zero(web, struct http_header);
122                 char *colon = strchr(line, ':');
123                 if (colon == NULL) {
124                         http_error(web, "500 Internal Server Error", "invalidly formatted header");
125                         return NT_STATUS_INVALID_PARAMETER;
126                 }
127
128                 hdr->name = talloc_strndup(hdr, line, colon-line);
129                 hdr->value = talloc_strdup(hdr, colon+1);
130                 DLIST_ADD(web->input.headers, hdr);
131         }
132
133         /* ignore all other headers for now */
134         return NT_STATUS_OK;
135 }
136
137 /*
138   called when a web connection becomes readable
139 */
140 static void websrv_recv(struct stream_connection *conn, uint16_t flags)
141 {
142         struct web_server_data *wdata;
143         struct websrv_context *web = talloc_get_type(conn->private_data,
144                                                      struct websrv_context);
145         NTSTATUS status;
146         uint8_t buf[1024];
147         size_t nread;
148         uint8_t *p;
149         DATA_BLOB b;
150
151         /* not the most efficient http parser ever, but good enough for us */
152         status = socket_recv(conn->socket, buf, sizeof(buf), &nread);
153         if (NT_STATUS_IS_ERR(status)) goto failed;
154         if (!NT_STATUS_IS_OK(status)) return;
155
156         if (!data_blob_append(web, &web->input.partial, buf, nread))
157                 goto failed;
158
159         /* parse any lines that are available */
160         b = web->input.partial;
161         while (!web->input.end_of_headers &&
162                (p=(uint8_t *)memchr(b.data, '\n', b.length))) {
163                 const char *line = (const char *)b.data;
164                 *p = 0;
165                 if (p != b.data && p[-1] == '\r') {
166                         p[-1] = 0;
167                 }
168                 status = http_parse_header(web, line);
169                 if (!NT_STATUS_IS_OK(status)) return;
170                 b.length -= (p - b.data) + 1;
171                 b.data = p+1;
172         }
173
174         /* keep any remaining bytes in web->input.partial */
175         if (b.length == 0) {
176                 b.data = NULL;
177         }
178         b = data_blob_talloc(web, b.data, b.length);
179         data_blob_free(&web->input.partial);
180         web->input.partial = b;
181
182         /* we finish when we have both the full headers (terminated by
183            a blank line) and any post data, as indicated by the
184            content_length */
185         if (web->input.end_of_headers &&
186             web->input.partial.length >= web->input.content_length) {
187                 if (web->input.partial.length > web->input.content_length) {
188                         web->input.partial.data[web->input.content_length] = 0;
189                 }
190                 EVENT_FD_NOT_READABLE(web->conn->event.fde);
191
192                 /* the reference/unlink code here is quite subtle. It
193                  is needed because the rendering of the web-pages, and
194                  in particular the esp/ejs backend, is semi-async.  So
195                  we could well end up in the connection timeout code
196                  while inside http_process_input(), but we must not
197                  destroy the stack variables being used by that
198                  rendering process when we handle the timeout. */
199                 if (!talloc_reference(web->task, web)) goto failed;
200                 wdata = talloc_get_type(web->task->private_data, struct web_server_data);
201                 if (wdata == NULL) goto failed;
202                 wdata->http_process_input(wdata, web);
203                 talloc_unlink(web->task, web);
204         }
205         return;
206
207 failed:
208         stream_terminate_connection(conn, "websrv_recv: failed");
209 }
210
211
212
213 /*
214   called when a web connection becomes writable
215 */
216 static void websrv_send(struct stream_connection *conn, uint16_t flags)
217 {
218         struct websrv_context *web = talloc_get_type(conn->private_data,
219                                                      struct websrv_context);
220         NTSTATUS status;
221         size_t nsent;
222         DATA_BLOB b;
223
224         b = web->output.content;
225         b.data += web->output.nsent;
226         b.length -= web->output.nsent;
227
228         status = socket_send(conn->socket, &b, &nsent);
229         if (NT_STATUS_IS_ERR(status)) {
230                 stream_terminate_connection(web->conn, "socket_send: failed");
231                 return;
232         }
233         if (!NT_STATUS_IS_OK(status)) {
234                 return;
235         }
236
237         web->output.nsent += nsent;
238
239         if (web->output.content.length == web->output.nsent) {
240                 stream_terminate_connection(web->conn, "websrv_send: finished sending");
241         }
242 }
243
244 /*
245   establish a new connection to the web server
246 */
247 static void websrv_accept(struct stream_connection *conn)
248 {
249         struct task_server *task = talloc_get_type(conn->private_data, struct task_server);
250         struct web_server_data *wdata = talloc_get_type(task->private_data, struct web_server_data);
251         struct websrv_context *web;
252         struct socket_context *tls_socket;
253
254         web = talloc_zero(conn, struct websrv_context);
255         if (web == NULL) goto failed;
256
257         web->task = task;
258         web->conn = conn;
259         conn->private_data = web;
260         talloc_set_destructor(web, websrv_destructor);
261
262         event_add_timed(conn->event.ctx, web, 
263                         timeval_current_ofs(HTTP_TIMEOUT, 0),
264                         websrv_timeout, web);
265
266         /* Overwrite the socket with a (possibly) TLS socket */
267         tls_socket = tls_init_server(wdata->tls_params, conn->socket, 
268                                      conn->event.fde, "GPHO");
269         /* We might not have TLS, or it might not have initilised */
270         if (tls_socket) {
271                 talloc_unlink(conn, conn->socket);
272                 talloc_steal(conn, tls_socket);
273                 conn->socket = tls_socket;
274         } else {
275                 DEBUG(3, ("TLS not available for web_server connections\n"));
276         }
277
278         return;
279
280 failed:
281         talloc_free(conn);
282 }
283
284
285 static const struct stream_server_ops web_stream_ops = {
286         .name                   = "web",
287         .accept_connection      = websrv_accept,
288         .recv_handler           = websrv_recv,
289         .send_handler           = websrv_send,
290 };
291
292 /*
293   startup the web server task
294 */
295 static void websrv_task_init(struct task_server *task)
296 {
297         NTSTATUS status;
298         uint16_t port = lpcfg_web_port(task->lp_ctx);
299         const struct model_ops *model_ops;
300         struct web_server_data *wdata;
301
302         task_server_set_title(task, "task[websrv]");
303
304         /* run the web server as a single process */
305         model_ops = process_model_startup("single");
306         if (!model_ops) goto failed;
307
308         /* startup the Python processor - unfortunately we can't do this
309            per connection as that wouldn't allow for session variables */
310         wdata = talloc_zero(task, struct web_server_data);
311         if (wdata == NULL) goto failed;
312
313         task->private_data = wdata;
314
315         if (lpcfg_interfaces(task->lp_ctx) && lpcfg_bind_interfaces_only(task->lp_ctx)) {
316                 int num_interfaces;
317                 int i;
318                 struct interface *ifaces;
319
320                 load_interfaces(NULL, lpcfg_interfaces(task->lp_ctx), &ifaces);
321
322                 num_interfaces = iface_count(ifaces);
323                 for(i = 0; i < num_interfaces; i++) {
324                         const char *address = iface_n_ip(ifaces, i);
325                         status = stream_setup_socket(task,
326                                                      task->event_ctx,
327                                                      task->lp_ctx, model_ops,
328                                                      &web_stream_ops, 
329                                                      "ipv4", address, 
330                                                      &port, lpcfg_socket_options(task->lp_ctx),
331                                                      task);
332                         if (!NT_STATUS_IS_OK(status)) goto failed;
333                 }
334
335                 talloc_free(ifaces);
336         } else {
337                 status = stream_setup_socket(task, task->event_ctx,
338                                              task->lp_ctx, model_ops,
339                                              &web_stream_ops,
340                                              "ipv4", lpcfg_socket_address(task->lp_ctx),
341                                              &port, lpcfg_socket_options(task->lp_ctx),
342                                              task);
343                 if (!NT_STATUS_IS_OK(status)) goto failed;
344         }
345
346         wdata->tls_params = tls_initialise(wdata, task->lp_ctx);
347         if (wdata->tls_params == NULL) goto failed;
348
349         if (!wsgi_initialize(wdata)) goto failed;
350
351
352         return;
353
354 failed:
355         task_server_terminate(task, "websrv_task_init: failed to startup web server task", true);
356 }
357
358
359 /* called at smbd startup - register ourselves as a server service */
360 NTSTATUS server_service_web_init(void)
361 {
362         return register_server_service("web", websrv_task_init);
363 }