server_fcgi.c revision 1.10 
1/*	$OpenBSD: server_fcgi.c,v 1.10 2014/08/02 11:59:04 florian Exp $	*/
2
3/*
4 * Copyright (c) 2014 Florian Obser <florian@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19#include <sys/types.h>
20#include <sys/queue.h>
21#include <sys/time.h>
22#include <sys/stat.h>
23#include <sys/socket.h>
24#include <sys/un.h>
25#include <sys/tree.h>
26#include <sys/hash.h>
27
28#include <net/if.h>
29#include <netinet/in_systm.h>
30#include <netinet/in.h>
31#include <netinet/ip.h>
32#include <netinet/tcp.h>
33#include <arpa/inet.h>
34
35#include <errno.h>
36#include <fcntl.h>
37#include <stdlib.h>
38#include <string.h>
39#include <unistd.h>
40#include <stdio.h>
41#include <err.h>
42#include <event.h>
43
44#include <openssl/ssl.h>
45
46#include "httpd.h"
47#include "http.h"
48
49#define FCGI_CONTENT_SIZE	 65535
50#define FCGI_PADDING_SIZE	 255
51#define FCGI_RECORD_SIZE	 \
52    (sizeof(struct fcgi_record_header) + FCGI_CONTENT_SIZE + FCGI_PADDING_SIZE)
53
54#define FCGI_BEGIN_REQUEST	 1
55#define FCGI_ABORT_REQUEST	 2
56#define FCGI_END_REQUEST	 3
57#define FCGI_PARAMS		 4
58#define FCGI_STDIN		 5
59#define FCGI_STDOUT		 6
60#define FCGI_STDERR		 7
61#define FCGI_DATA		 8
62#define FCGI_GET_VALUES		 9
63#define FCGI_GET_VALUES_RESULT	10
64#define FCGI_UNKNOWN_TYPE	11
65#define FCGI_MAXTYPE		(FCGI_UNKNOWN_TYPE)
66
67#define FCGI_RESPONDER		 1
68
69struct fcgi_record_header {
70	uint8_t		version;
71	uint8_t		type;
72	uint16_t	id;
73	uint16_t	content_len;
74	uint8_t		padding_len;
75	uint8_t		reserved;
76} __packed;
77
78struct fcgi_begin_request_body {
79	uint16_t	role;
80	uint8_t		flags;
81	uint8_t		reserved[5];
82} __packed;
83
84int	server_fcgi_header(struct client *, u_int);
85void	server_fcgi_read(struct bufferevent *, void *);
86int	fcgi_add_param(uint8_t *, const char *, const char *, int *,
87    struct client *);
88
89int
90server_fcgi(struct httpd *env, struct client *clt)
91{
92	uint8_t				 buf[FCGI_RECORD_SIZE];
93	char				 hbuf[MAXHOSTNAMELEN];
94	struct server_config		*srv_conf = clt->clt_srv_conf;
95	struct http_descriptor		*desc	= clt->clt_desc;
96	struct sockaddr_un		 sun;
97	struct fcgi_record_header	*h;
98	struct fcgi_begin_request_body	*begin;
99	struct kv			*kv, key;
100	size_t				 len;
101	int				 fd = -1, total_len;
102	const char			*errstr = NULL;
103	char				*request_uri, *p;
104	in_port_t			 port;
105	struct sockaddr_storage		 ss;
106
107	if (srv_conf->path[0] == ':') {
108		p = srv_conf->path + 1;
109
110		port = strtonum(p, 0, 0xffff, &errstr);
111		if (errstr != NULL) {
112			log_warn("%s: strtonum %s, %s", __func__, p, errstr);
113			goto fail;
114		}
115		memset(&ss, 0, sizeof(ss));
116		ss.ss_family = AF_INET;
117		((struct sockaddr_in *)
118		    &ss)->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
119		port = htons(port);
120
121		if ((fd = server_socket_connect(&ss, port, srv_conf)) == -1)
122			goto fail;
123	} else {
124		if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
125			goto fail;
126
127		memset(&sun, 0, sizeof(sun));
128		sun.sun_family = AF_UNIX;
129		len = strlcpy(sun.sun_path,
130		    srv_conf->path, sizeof(sun.sun_path));
131		if (len >= sizeof(sun.sun_path)) {
132			errstr = "socket path to long";
133			goto fail;
134		}
135		sun.sun_len = len;
136
137		if (connect(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1)
138			goto fail;
139	}
140
141	socket_set_blockmode(fd, BM_NONBLOCK);
142
143	memset(&hbuf, 0, sizeof(hbuf));
144	clt->clt_fcgi_state = FCGI_READ_HEADER;
145	clt->clt_fcgi_toread = sizeof(struct fcgi_record_header);
146
147	if (clt->clt_srvevb != NULL)
148		evbuffer_free(clt->clt_srvevb);
149
150	clt->clt_srvevb = evbuffer_new();
151	if (clt->clt_srvevb == NULL) {
152		errstr = "failed to allocate evbuffer";
153		goto fail;
154	}
155
156	if (clt->clt_srvbev != NULL)
157		bufferevent_free(clt->clt_srvbev);
158
159	clt->clt_srvbev = bufferevent_new(fd, server_fcgi_read,
160	    NULL, server_file_error, clt);
161	if (clt->clt_srvbev == NULL) {
162		errstr = "failed to allocate fcgi buffer event";
163		goto fail;
164	}
165
166	memset(&buf, 0, sizeof(buf));
167
168	h = (struct fcgi_record_header *) &buf;
169	h->version = 1;
170	h->type = FCGI_BEGIN_REQUEST;
171	h->id = htons(1);
172	h->content_len = htons(sizeof(struct fcgi_begin_request_body));
173	h->padding_len = 0;
174
175	begin = (struct fcgi_begin_request_body *) &buf[sizeof(struct
176	    fcgi_record_header)];
177	begin->role = htons(FCGI_RESPONDER);
178
179	bufferevent_write(clt->clt_srvbev, &buf,
180	    sizeof(struct fcgi_record_header) +
181	    sizeof(struct fcgi_begin_request_body));
182
183	h->type = FCGI_PARAMS;
184	h->content_len = total_len = 0;
185
186	if (fcgi_add_param(buf, "SCRIPT_NAME", desc->http_path, &total_len,
187	    clt) == -1) {
188		errstr = "failed to encode param";
189		goto fail;
190	}
191
192	if (desc->http_query)
193		if (fcgi_add_param(buf, "QUERY_STRING", desc->http_query,
194		    &total_len, clt) == -1) {
195			errstr = "failed to encode param";
196			goto fail;
197		}
198
199	if (fcgi_add_param(buf, "DOCUMENT_URI", desc->http_path, &total_len,
200	    clt) == -1) {
201		errstr = "failed to encode param";
202		goto fail;
203	}
204	if (fcgi_add_param(buf, "GATEWAY_INTERFACE", "CGI/1.1", &total_len,
205	    clt) == -1) {
206		errstr = "failed to encode param";
207		goto fail;
208	}
209
210	key.kv_key = "Accept";
211	if ((kv = kv_find(&desc->http_headers, &key)) != NULL &&
212	    kv->kv_value != NULL)
213		if (fcgi_add_param(buf, "HTTP_ACCEPT", kv->kv_value,
214		    &total_len, clt) == -1) {
215			errstr = "failed to encode param";
216			goto fail;
217		}
218
219	key.kv_key = "Accept-Encoding";
220	if ((kv = kv_find(&desc->http_headers, &key)) != NULL &&
221	    kv->kv_value != NULL)
222		if (fcgi_add_param(buf, "HTTP_ACCEPT_ENCODING", kv->kv_value,
223		    &total_len, clt) == -1) {
224			errstr = "failed to encode param";
225			goto fail;
226		}
227
228	key.kv_key = "Accept-Language";
229	if ((kv = kv_find(&desc->http_headers, &key)) != NULL &&
230	    kv->kv_value != NULL)
231		if (fcgi_add_param(buf, "HTTP_ACCEPT_LANGUAGE", kv->kv_value,
232		    &total_len, clt) == -1) {
233			errstr = "failed to encode param";
234			goto fail;
235		}
236
237	key.kv_key = "Connection";
238	if ((kv = kv_find(&desc->http_headers, &key)) != NULL &&
239	    kv->kv_value != NULL)
240		if (fcgi_add_param(buf, "HTTP_CONNECTION", kv->kv_value,
241		    &total_len, clt) == -1) {
242			errstr = "failed to encode param";
243			goto fail;
244		}
245
246	key.kv_key = "Cookie";
247	if ((kv = kv_find(&desc->http_headers, &key)) != NULL &&
248	    kv->kv_value != NULL)
249		if (fcgi_add_param(buf, "HTTP_COOKIE", kv->kv_value,
250		    &total_len, clt) == -1) {
251			errstr = "failed to encode param";
252			goto fail;
253		}
254
255	key.kv_key = "Host";
256	if ((kv = kv_find(&desc->http_headers, &key)) != NULL &&
257	    kv->kv_value != NULL)
258		if (fcgi_add_param(buf, "HTTP_HOST", kv->kv_value,
259		    &total_len, clt) == -1) {
260			errstr = "failed to encode param";
261			goto fail;
262		}
263
264	key.kv_key = "User-Agent";
265	if ((kv = kv_find(&desc->http_headers, &key)) != NULL &&
266	    kv->kv_value != NULL)
267		if (fcgi_add_param(buf, "HTTP_USER_AGENT", kv->kv_value,
268		    &total_len, clt) == -1) {
269			errstr = "failed to encode param";
270			goto fail;
271		}
272
273	(void)print_host(&clt->clt_ss, hbuf, sizeof(hbuf));
274	if (fcgi_add_param(buf, "REMOTE_ADDR", hbuf, &total_len, clt) == -1) {
275		errstr = "failed to encode param";
276		goto fail;
277	}
278
279	(void)snprintf(hbuf, sizeof(hbuf), "%d", ntohs(clt->clt_port));
280	if (fcgi_add_param(buf, "REMOTE_PORT", hbuf, &total_len, clt) == -1) {
281		errstr = "failed to encode param";
282		goto fail;
283	}
284
285	if (fcgi_add_param(buf, "REQUEST_METHOD",
286	    server_httpmethod_byid(desc->http_method), &total_len, clt) == -1) {
287		errstr = "failed to encode param";
288		goto fail;
289	}
290
291	if (!desc->http_query) {
292		if (fcgi_add_param(buf, "REQUEST_URI", desc->http_path,
293		    &total_len, clt) == -1) {
294			errstr = "failed to encode param";
295			goto fail;
296		}
297	} else if (asprintf(&request_uri, "%s?%s", desc->http_path,
298	    desc->http_query) != -1) {
299		if (fcgi_add_param(buf, "REQUEST_URI", request_uri, &total_len,
300		    clt) == -1) {
301			errstr = "failed to encode param";
302			goto fail;
303		}
304		free(request_uri);
305	}
306
307	(void)print_host(&clt->clt_srv_ss, hbuf, sizeof(hbuf));
308	if (fcgi_add_param(buf, "SERVER_ADDR", hbuf, &total_len, clt) == -1) {
309		errstr = "failed to encode param";
310		goto fail;
311	}
312
313	(void)snprintf(hbuf, sizeof(hbuf), "%d",
314	    ntohs(server_socket_getport(&clt->clt_srv_ss)));
315	if (fcgi_add_param(buf, "SERVER_PORT", hbuf, &total_len, clt) == -1) {
316		errstr = "failed to encode param";
317		goto fail;
318	}
319
320	if (fcgi_add_param(buf, "SERVER_NAME", srv_conf->name, &total_len,
321	    clt) == -1) {
322		errstr = "failed to encode param";
323		goto fail;
324	}
325
326	if (fcgi_add_param(buf, "SERVER_PROTOCOL", desc->http_version,
327	    &total_len, clt) == -1) {
328		errstr = "failed to encode param";
329		goto fail;
330	}
331
332	if (fcgi_add_param(buf, "SERVER_SOFTWARE", HTTPD_SERVERNAME, &total_len,
333	    clt) == -1) {
334		errstr = "failed to encode param";
335		goto fail;
336	}
337
338	if (total_len != 0) {	/* send last params record */
339		bufferevent_write(clt->clt_srvbev, &buf,
340		    sizeof(struct fcgi_record_header) +
341		    ntohs(h->content_len));
342	}
343
344	/* send "no more params" message */
345	h->content_len = 0;
346	bufferevent_write(clt->clt_srvbev, &buf,
347	    sizeof(struct fcgi_record_header));
348
349	h->type = FCGI_STDIN;
350
351	bufferevent_write(clt->clt_srvbev, &buf,
352	    sizeof(struct fcgi_record_header));
353
354	bufferevent_settimeout(clt->clt_srvbev,
355	    srv_conf->timeout.tv_sec, srv_conf->timeout.tv_sec);
356	bufferevent_enable(clt->clt_srvbev, EV_READ|EV_WRITE);
357	bufferevent_disable(clt->clt_bev, EV_READ);
358
359	/*
360	 * persist is not supported yet because we don't get the
361	 * Content-Length from slowcgi and don't support chunked encoding.
362	 */
363	clt->clt_persist = 0;
364	clt->clt_done = 0;
365
366	return (0);
367 fail:
368	if (errstr == NULL)
369		errstr = strerror(errno);
370	server_abort_http(clt, 500, errstr);
371	return (-1);
372}
373
374int
375fcgi_add_param(uint8_t *buf, const char *key, const char *val, int *total_len,
376    struct client *clt)
377{
378	struct fcgi_record_header	*h;
379	int				 len = 0;
380	int				 key_len = strlen(key);
381	int				 val_len = strlen(val);
382	uint8_t				*param;
383
384	len += key_len + val_len;
385	len += key_len > 127 ? 4 : 1;
386	len += val_len > 127 ? 4 : 1;
387
388	DPRINTF("%s: %s[%d] => %s[%d], total_len: %d", __func__, key, key_len,
389	    val, val_len, *total_len);
390
391	if (len > FCGI_CONTENT_SIZE)
392		return (-1);
393
394	if (*total_len + len > FCGI_CONTENT_SIZE) {
395		bufferevent_write(clt->clt_srvbev, buf,
396		    sizeof(struct fcgi_record_header) + *total_len);
397		*total_len = 0;
398	}
399
400	h = (struct fcgi_record_header *) buf;
401	param = buf + sizeof(struct fcgi_record_header) + *total_len;
402
403	if (key_len > 127) {
404		*param++ = ((key_len >> 24) & 0xff) | 0x80;
405		*param++ = ((key_len >> 16) & 0xff);
406		*param++ = ((key_len >> 8) & 0xff);
407		*param++ = (key_len & 0xff);
408	} else
409		*param++ = key_len;
410
411	if (val_len > 127) {
412		*param++ = ((val_len >> 24) & 0xff) | 0x80;
413		*param++ = ((val_len >> 16) & 0xff);
414		*param++ = ((val_len >> 8) & 0xff);
415		*param++ = (val_len & 0xff);
416	} else
417		*param++ = val_len;
418
419	memcpy(param, key, key_len);
420	param += key_len;
421	memcpy(param, val, val_len);
422
423	*total_len += len;
424
425	h->content_len = htons(*total_len);
426	return (0);
427}
428
429void
430server_fcgi_read(struct bufferevent *bev, void *arg)
431{
432	uint8_t				 buf[FCGI_RECORD_SIZE];
433	struct client			*clt = (struct client *) arg;
434	struct fcgi_record_header	*h;
435	size_t				 len;
436
437	do {
438		len = bufferevent_read(bev, &buf, clt->clt_fcgi_toread);
439		/* XXX error handling */
440		evbuffer_add(clt->clt_srvevb, &buf, len);
441		clt->clt_fcgi_toread -= len;
442		DPRINTF("%s: len: %lu toread: %d state: %d", __func__, len,
443		    clt->clt_fcgi_toread, clt->clt_fcgi_state);
444
445		if (clt->clt_fcgi_toread != 0)
446			return;
447
448		switch (clt->clt_fcgi_state) {
449		case FCGI_READ_HEADER:
450			clt->clt_fcgi_state = FCGI_READ_CONTENT;
451			h = (struct fcgi_record_header *)
452			    EVBUFFER_DATA(clt->clt_srvevb);
453			DPRINTF("%s: record header: version %d type %d id %d "
454			    "content len %d", __func__, h->version, h->type,
455			    ntohs(h->id), ntohs(h->content_len));
456			clt->clt_fcgi_type = h->type;
457			clt->clt_fcgi_toread = ntohs(h->content_len);
458			evbuffer_drain(clt->clt_srvevb,
459			    EVBUFFER_LENGTH(clt->clt_srvevb));
460			if (clt->clt_fcgi_toread != 0)
461				break;
462
463			/* fallthrough if content_len == 0 */
464		case FCGI_READ_CONTENT:
465			if (clt->clt_fcgi_type == FCGI_STDOUT &&
466			    EVBUFFER_LENGTH(clt->clt_srvevb) > 0) {
467				if (++clt->clt_chunk == 1)
468					server_fcgi_header(clt, 200);
469				server_bufferevent_write_buffer(clt,
470				    clt->clt_srvevb);
471			}
472			evbuffer_drain(clt->clt_srvevb,
473			    EVBUFFER_LENGTH(clt->clt_srvevb));
474			clt->clt_fcgi_state = FCGI_READ_HEADER;
475			clt->clt_fcgi_toread =
476			    sizeof(struct fcgi_record_header);
477		}
478	} while (len > 0);
479}
480
481int
482server_fcgi_header(struct client *clt, u_int code)
483{
484	struct http_descriptor	*desc = clt->clt_desc;
485	const char		*error;
486	char			 tmbuf[32];
487
488	if (desc == NULL || (error = server_httperror_byid(code)) == NULL)
489		return (-1);
490
491	kv_purge(&desc->http_headers);
492
493	/* Add error codes */
494	if (kv_setkey(&desc->http_pathquery, "%lu", code) == -1 ||
495	    kv_set(&desc->http_pathquery, "%s", error) == -1)
496		return (-1);
497
498	/* Add headers */
499	if (kv_add(&desc->http_headers, "Server", HTTPD_SERVERNAME) == NULL)
500		return (-1);
501
502	/* Is it a persistent connection? */
503	if (clt->clt_persist) {
504		if (kv_add(&desc->http_headers,
505		    "Connection", "keep-alive") == NULL)
506			return (-1);
507	} else if (kv_add(&desc->http_headers, "Connection", "close") == NULL)
508		return (-1);
509
510	/* Date header is mandatory and should be added last */
511	server_http_date(tmbuf, sizeof(tmbuf));
512	if (kv_add(&desc->http_headers, "Date", tmbuf) == NULL)
513		return (-1);
514
515	/* Write initial header (fcgi might append more) */
516	if (server_writeresponse_http(clt) == -1 ||
517	    server_bufferevent_print(clt, "\r\n") == -1 ||
518	    server_writeheader_http(clt) == -1)
519		return (-1);
520
521	return (0);
522}
523