Mark MIN and MAX as macros as they have side effects.
[darkstat] / http.c
1 /* darkstat 3
2 * copyright (c) 2001-2011 Emil Mikulic.
3 *
4 * http.c: embedded webserver.
5 * This borrows a lot of code from darkhttpd.
6 *
7 * You may use, modify and redistribute this file under the terms of the
8 * GNU General Public License version 2. (see COPYING.GPL)
9 */
10
11 #include "cdefs.h"
12 #include "config.h"
13 #include "conv.h"
14 #include "err.h"
15 #include "graph_db.h"
16 #include "hosts_db.h"
17 #include "http.h"
18 #include "now.h"
19 #include "queue.h"
20 #include "str.h"
21
22 #include <sys/uio.h>
23 #include <sys/socket.h>
24 #include <arpa/inet.h>
25 #include <netinet/in.h>
26 #include <netdb.h>
27 #include <assert.h>
28 #include <ctype.h>
29 #include <errno.h>
30 #include <fcntl.h>
31 #include <signal.h>
32 #include <stdarg.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <unistd.h>
37 #include <zlib.h>
38
39 static const char mime_type_xml[] = "text/xml";
40 static const char mime_type_html[] = "text/html; charset=us-ascii";
41 static const char mime_type_css[] = "text/css";
42 static const char mime_type_js[] = "text/javascript";
43 static const char encoding_identity[] = "identity";
44 static const char encoding_gzip[] = "gzip";
45
46 static const char server[] = PACKAGE_NAME "/" PACKAGE_VERSION;
47 static int idletime = 60;
48 #define MAX_REQUEST_LENGTH 4000
49
50 static int *insocks = NULL;
51 static unsigned int insock_num = 0;
52
53 struct connection {
54 LIST_ENTRY(connection) entries;
55
56 int socket;
57 struct sockaddr_storage client;
58 time_t last_active;
59 enum {
60 RECV_REQUEST, /* receiving request */
61 SEND_HEADER_AND_REPLY, /* try to send header+reply together */
62 SEND_HEADER, /* sending generated header */
63 SEND_REPLY, /* sending reply */
64 DONE /* conn closed, need to remove from queue */
65 } state;
66
67 /* char request[request_length+1] is null-terminated */
68 char *request;
69 size_t request_length;
70 int accept_gzip;
71
72 /* request fields */
73 char *method, *uri, *query; /* query can be NULL */
74
75 char *header;
76 const char *mime_type, *encoding, *header_extra;
77 size_t header_length, header_sent;
78 int header_dont_free, header_only, http_code;
79
80 char *reply;
81 int reply_dont_free;
82 size_t reply_length, reply_sent;
83
84 unsigned int total_sent; /* header + body = total, for logging */
85 };
86
87 static LIST_HEAD(conn_list_head, connection) connlist =
88 LIST_HEAD_INITIALIZER(conn_list_head);
89
90 struct bindaddr_entry {
91 STAILQ_ENTRY(bindaddr_entry) entries;
92 const char *s;
93 };
94 static STAILQ_HEAD(bindaddrs_head, bindaddr_entry) bindaddrs =
95 STAILQ_HEAD_INITIALIZER(bindaddrs);
96
97 /* ---------------------------------------------------------------------------
98 * Decode URL by converting %XX (where XX are hexadecimal digits) to the
99 * character it represents. Don't forget to free the return value.
100 */
101 static char *urldecode(const char *url)
102 {
103 size_t i, len = strlen(url);
104 char *out = xmalloc(len+1);
105 int pos;
106
107 for (i=0, pos=0; i<len; i++)
108 {
109 if (url[i] == '%' && i+2 < len &&
110 isxdigit(url[i+1]) && isxdigit(url[i+2]))
111 {
112 /* decode %XX */
113 #define HEX_TO_DIGIT(hex) ( \
114 ((hex) >= 'A' && (hex) <= 'F') ? ((hex)-'A'+10): \
115 ((hex) >= 'a' && (hex) <= 'f') ? ((hex)-'a'+10): \
116 ((hex)-'0') )
117
118 out[pos++] = HEX_TO_DIGIT(url[i+1]) * 16 +
119 HEX_TO_DIGIT(url[i+2]);
120 i += 2;
121
122 #undef HEX_TO_DIGIT
123 }
124 else
125 {
126 /* straight copy */
127 out[pos++] = url[i];
128 }
129 }
130 out[pos] = 0;
131 #if 0
132 /* don't really need to realloc here - it's probably a performance hit */
133 out = xrealloc(out, strlen(out)+1); /* dealloc what we don't need */
134 #endif
135 return (out);
136 }
137
138
139
140 /* ---------------------------------------------------------------------------
141 * Consolidate slashes in-place by shifting parts of the string over repeated
142 * slashes.
143 */
144 static void consolidate_slashes(char *s)
145 {
146 size_t left = 0, right = 0;
147 int saw_slash = 0;
148
149 assert(s != NULL);
150
151 while (s[right] != '\0')
152 {
153 if (saw_slash)
154 {
155 if (s[right] == '/') right++;
156 else
157 {
158 saw_slash = 0;
159 s[left++] = s[right++];
160 }
161 }
162 else
163 {
164 if (s[right] == '/') saw_slash++;
165 s[left++] = s[right++];
166 }
167 }
168 s[left] = '\0';
169 }
170
171
172
173 /* ---------------------------------------------------------------------------
174 * Resolve /./ and /../ in a URI, returing a new, safe URI, or NULL if the URI
175 * is invalid/unsafe. Returned buffer needs to be deallocated.
176 */
177 static char *make_safe_uri(char *uri)
178 {
179 char **elem, *out;
180 unsigned int slashes = 0, elements = 0;
181 size_t urilen, i, j, pos;
182
183 assert(uri != NULL);
184 if (uri[0] != '/')
185 return (NULL);
186 consolidate_slashes(uri);
187 urilen = strlen(uri);
188
189 /* count the slashes */
190 for (i=0, slashes=0; i<urilen; i++)
191 if (uri[i] == '/') slashes++;
192
193 /* make an array for the URI elements */
194 elem = xmalloc(sizeof(*elem) * slashes);
195 for (i=0; i<slashes; i++)
196 elem[i] = (NULL);
197
198 /* split by slashes and build elem[] array */
199 for (i=1; i<urilen;)
200 {
201 /* look for the next slash */
202 for (j=i; j<urilen && uri[j] != '/'; j++)
203 ;
204
205 /* process uri[i,j) */
206 if ((j == i+1) && (uri[i] == '.'))
207 /* "." */;
208 else if ((j == i+2) && (uri[i] == '.') && (uri[i+1] == '.'))
209 {
210 /* ".." */
211 if (elements == 0)
212 {
213 /*
214 * Unsafe string so free elem[]. All its elements are free
215 * at this point.
216 */
217 free(elem);
218 return (NULL);
219 }
220 else
221 {
222 elements--;
223 free(elem[elements]);
224 }
225 }
226 else elem[elements++] = split_string(uri, i, j);
227
228 i = j + 1; /* uri[j] is a slash - move along one */
229 }
230
231 /* reassemble */
232 out = xmalloc(urilen+1); /* it won't expand */
233 pos = 0;
234 for (i=0; i<elements; i++)
235 {
236 size_t delta = strlen(elem[i]);
237
238 assert(pos <= urilen);
239 out[pos++] = '/';
240
241 assert(pos+delta <= urilen);
242 memcpy(out+pos, elem[i], delta);
243 free(elem[i]);
244 pos += delta;
245 }
246 free(elem);
247
248 if ((elements == 0) || (uri[urilen-1] == '/')) out[pos++] = '/';
249 assert(pos <= urilen);
250 out[pos] = '\0';
251
252 #if 0
253 /* don't really need to do this and it's probably a performance hit: */
254 /* shorten buffer if necessary */
255 if (pos != urilen) out = xrealloc(out, strlen(out)+1);
256 #endif
257 return (out);
258 }
259
260 /* ---------------------------------------------------------------------------
261 * Allocate and initialize an empty connection.
262 */
263 static struct connection *new_connection(void)
264 {
265 struct connection *conn = xmalloc(sizeof(*conn));
266
267 conn->socket = -1;
268 memset(&conn->client, 0, sizeof(conn->client));
269 conn->last_active = now;
270 conn->request = NULL;
271 conn->request_length = 0;
272 conn->accept_gzip = 0;
273 conn->method = NULL;
274 conn->uri = NULL;
275 conn->query = NULL;
276 conn->header = NULL;
277 conn->mime_type = NULL;
278 conn->encoding = NULL;
279 conn->header_extra = "";
280 conn->header_length = 0;
281 conn->header_sent = 0;
282 conn->header_dont_free = 0;
283 conn->header_only = 0;
284 conn->http_code = 0;
285 conn->reply = NULL;
286 conn->reply_dont_free = 0;
287 conn->reply_length = 0;
288 conn->reply_sent = 0;
289 conn->total_sent = 0;
290
291 /* Make it harmless so it gets garbage-collected if it should, for some
292 * reason, fail to be correctly filled out.
293 */
294 conn->state = DONE;
295
296 return (conn);
297 }
298
299
300
301 /* ---------------------------------------------------------------------------
302 * Accept a connection from sockin and add it to the connection queue.
303 */
304 static void accept_connection(const int sockin)
305 {
306 struct sockaddr_storage addrin;
307 socklen_t sin_size;
308 struct connection *conn;
309 char ipaddr[INET6_ADDRSTRLEN], portstr[12];
310 int sock;
311
312 sin_size = (socklen_t)sizeof(addrin);
313 sock = accept(sockin, (struct sockaddr *)&addrin, &sin_size);
314 if (sock == -1)
315 {
316 if (errno == ECONNABORTED || errno == EINTR)
317 {
318 verbosef("accept() failed: %s", strerror(errno));
319 return;
320 }
321 /* else */ err(1, "accept()");
322 }
323
324 fd_set_nonblock(sock);
325
326 /* allocate and initialise struct connection */
327 conn = new_connection();
328 conn->socket = sock;
329 conn->state = RECV_REQUEST;
330 memcpy(&conn->client, &addrin, sizeof(conn->client));
331 LIST_INSERT_HEAD(&connlist, conn, entries);
332
333 getnameinfo((struct sockaddr *) &addrin, sin_size,
334 ipaddr, sizeof(ipaddr), portstr, sizeof(portstr),
335 NI_NUMERICHOST | NI_NUMERICSERV);
336 verbosef("accepted connection from %s:%s", ipaddr, portstr);
337 }
338
339
340
341 /* ---------------------------------------------------------------------------
342 * Log a connection, then cleanly deallocate its internals.
343 */
344 static void free_connection(struct connection *conn)
345 {
346 dverbosef("free_connection(%d)", conn->socket);
347 if (conn->socket != -1) close(conn->socket);
348 if (conn->request != NULL) free(conn->request);
349 if (conn->method != NULL) free(conn->method);
350 if (conn->uri != NULL) free(conn->uri);
351 if (conn->query != NULL) free(conn->query);
352 if (conn->header != NULL && !conn->header_dont_free) free(conn->header);
353 if (conn->reply != NULL && !conn->reply_dont_free) free(conn->reply);
354 }
355
356
357
358 /* ---------------------------------------------------------------------------
359 * Format [when] as an RFC1123 date, stored in the specified buffer. The same
360 * buffer is returned for convenience.
361 */
362 #define DATE_LEN 30 /* strlen("Fri, 28 Feb 2003 00:02:08 GMT")+1 */
363 static char *rfc1123_date(char *dest, const time_t when)
364 {
365 time_t tmp = when;
366 if (strftime(dest, DATE_LEN,
367 "%a, %d %b %Y %H:%M:%S %Z", gmtime(&tmp) ) == 0)
368 errx(1, "strftime() failed [%s]", dest);
369 return (dest);
370 }
371
372 static void generate_header(struct connection *conn,
373 const int code, const char *text)
374 {
375 char date[DATE_LEN];
376
377 assert(conn->header == NULL);
378 assert(conn->mime_type != NULL);
379 if (conn->encoding == NULL)
380 conn->encoding = encoding_identity;
381
382 verbosef("http: %d %s (%s: %d bytes)", code, text,
383 conn->encoding, conn->reply_length);
384 conn->header_length = xasprintf(&(conn->header),
385 "HTTP/1.1 %d %s\r\n"
386 "Date: %s\r\n"
387 "Server: %s\r\n"
388 "Vary: Accept-Encoding\r\n"
389 "Content-Type: %s\r\n"
390 "Content-Length: %d\r\n"
391 "Content-Encoding: %s\r\n"
392 "X-Robots-Tag: noindex, noarchive\r\n"
393 "%s"
394 "\r\n"
395 ,
396 code, text,
397 rfc1123_date(date, now), server,
398 conn->mime_type, conn->reply_length, conn->encoding,
399 conn->header_extra);
400 conn->http_code = code;
401 }
402
403
404
405 /* ---------------------------------------------------------------------------
406 * A default reply for any (erroneous) occasion.
407 */
408 static void default_reply(struct connection *conn,
409 const int errcode, const char *errname, const char *format, ...)
410 {
411 char *reason;
412 va_list va;
413
414 va_start(va, format);
415 xvasprintf(&reason, format, va);
416 va_end(va);
417
418 conn->reply_length = xasprintf(&(conn->reply),
419 "<html><head><title>%d %s</title></head><body>\n"
420 "<h1>%s</h1>\n" /* errname */
421 "%s\n" /* reason */
422 "<hr>\n"
423 "Generated by %s"
424 "</body></html>\n",
425 errcode, errname, errname, reason, server);
426 free(reason);
427
428 /* forget any dangling metadata */
429 conn->mime_type = mime_type_html;
430 conn->encoding = encoding_identity;
431
432 generate_header(conn, errcode, errname);
433 }
434
435
436
437 /* ---------------------------------------------------------------------------
438 * Parses a single HTTP request field. Returns string from end of [field] to
439 * first \r, \n or end of request string. Returns NULL if [field] can't be
440 * matched.
441 *
442 * You need to remember to deallocate the result.
443 * example: parse_field(conn, "Referer: ");
444 */
445 static char *parse_field(const struct connection *conn, const char *field)
446 {
447 size_t bound1, bound2;
448 char *pos;
449
450 /* find start */
451 pos = strstr(conn->request, field);
452 if (pos == NULL)
453 return (NULL);
454 bound1 = pos - conn->request + strlen(field);
455
456 /* find end */
457 for (bound2 = bound1;
458 conn->request[bound2] != '\r' &&
459 bound2 < conn->request_length; bound2++)
460 ;
461
462 /* copy to buffer */
463 return (split_string(conn->request, bound1, bound2));
464 }
465
466
467
468 /* ---------------------------------------------------------------------------
469 * Parse an HTTP request like "GET /hosts/?sort=in HTTP/1.1" to get the method
470 * (GET), the uri (/hosts/), the query (sort=in) and whether the UA will
471 * accept gzip encoding. Remember to deallocate all these buffers. Query
472 * can be NULL. The method will be returned in uppercase.
473 */
474 static int parse_request(struct connection *conn)
475 {
476 size_t bound1, bound2, mid;
477 char *accept_enc;
478
479 /* parse method */
480 for (bound1 = 0; bound1 < conn->request_length &&
481 conn->request[bound1] != ' '; bound1++)
482 ;
483
484 conn->method = split_string(conn->request, 0, bound1);
485 strntoupper(conn->method, bound1);
486
487 /* parse uri */
488 for (; bound1 < conn->request_length &&
489 conn->request[bound1] == ' '; bound1++)
490 ;
491
492 if (bound1 == conn->request_length)
493 return (0); /* fail */
494
495 for (bound2=bound1+1; bound2 < conn->request_length &&
496 conn->request[bound2] != ' ' &&
497 conn->request[bound2] != '\r'; bound2++)
498 ;
499
500 /* find query string */
501 for (mid=bound1; mid<bound2 && conn->request[mid] != '?'; mid++)
502 ;
503
504 if (conn->request[mid] == '?') {
505 conn->query = split_string(conn->request, mid+1, bound2);
506 bound2 = mid;
507 }
508
509 conn->uri = split_string(conn->request, bound1, bound2);
510
511 /* parse important fields */
512 accept_enc = parse_field(conn, "Accept-Encoding: ");
513 if (accept_enc != NULL) {
514 if (strstr(accept_enc, "gzip") != NULL)
515 conn->accept_gzip = 1;
516 free(accept_enc);
517 }
518 return (1);
519 }
520
521 /* FIXME: maybe we need a smarter way of doing static pages: */
522
523 /* ---------------------------------------------------------------------------
524 * Web interface: static stylesheet.
525 */
526 static void
527 static_style_css(struct connection *conn)
528 {
529 #include "stylecss.h"
530
531 conn->reply = style_css;
532 conn->reply_length = style_css_len;
533 conn->reply_dont_free = 1;
534 conn->mime_type = mime_type_css;
535 }
536
537 /* ---------------------------------------------------------------------------
538 * Web interface: static JavaScript.
539 */
540 static void
541 static_graph_js(struct connection *conn)
542 {
543 #include "graphjs.h"
544
545 conn->reply = graph_js;
546 conn->reply_length = graph_js_len;
547 conn->reply_dont_free = 1;
548 conn->mime_type = mime_type_js;
549 }
550
551 /* ---------------------------------------------------------------------------
552 * gzip a reply, if requested and possible. Don't bother with a minimum
553 * length requirement, I've never seen a page fail to compress.
554 */
555 static void
556 process_gzip(struct connection *conn)
557 {
558 char *buf;
559 size_t len;
560 z_stream zs;
561
562 if (!conn->accept_gzip)
563 return;
564
565 buf = xmalloc(conn->reply_length);
566 len = conn->reply_length;
567
568 zs.zalloc = Z_NULL;
569 zs.zfree = Z_NULL;
570 zs.opaque = Z_NULL;
571
572 if (deflateInit2(&zs, Z_BEST_COMPRESSION, Z_DEFLATED,
573 15+16, /* 15 = biggest window, 16 = add gzip header+trailer */
574 8 /* default */,
575 Z_DEFAULT_STRATEGY) != Z_OK)
576 return;
577
578 zs.avail_in = conn->reply_length;
579 zs.next_in = (unsigned char *)conn->reply;
580
581 zs.avail_out = conn->reply_length;
582 zs.next_out = (unsigned char *)buf;
583
584 if (deflate(&zs, Z_FINISH) != Z_STREAM_END) {
585 deflateEnd(&zs);
586 free(buf);
587 verbosef("failed to compress %u bytes", (unsigned int)len);
588 return;
589 }
590
591 if (conn->reply_dont_free)
592 conn->reply_dont_free = 0;
593 else
594 free(conn->reply);
595
596 conn->reply = buf;
597 conn->reply_length -= zs.avail_out;
598 conn->encoding = encoding_gzip;
599 deflateEnd(&zs);
600 }
601
602 /* ---------------------------------------------------------------------------
603 * Process a GET/HEAD request
604 */
605 static void process_get(struct connection *conn)
606 {
607 char *decoded_url, *safe_url;
608
609 verbosef("http: %s \"%s\" %s", conn->method, conn->uri,
610 (conn->query == NULL)?"":conn->query);
611
612 /* work out path of file being requested */
613 decoded_url = urldecode(conn->uri);
614
615 /* make sure it's safe */
616 safe_url = make_safe_uri(decoded_url);
617 free(decoded_url);
618 if (safe_url == NULL)
619 {
620 default_reply(conn, 400, "Bad Request",
621 "You requested an invalid URI: %s", conn->uri);
622 return;
623 }
624
625 if (strcmp(safe_url, "/") == 0) {
626 struct str *buf = html_front_page();
627 str_extract(buf, &(conn->reply_length), &(conn->reply));
628 conn->mime_type = mime_type_html;
629 }
630 else if (str_starts_with(safe_url, "/hosts/")) {
631 /* FIXME here - make this saner */
632 struct str *buf = html_hosts(safe_url, conn->query);
633 if (buf == NULL) {
634 default_reply(conn, 404, "Not Found",
635 "The page you requested could not be found.");
636 free(safe_url);
637 return;
638 }
639 str_extract(buf, &(conn->reply_length), &(conn->reply));
640 conn->mime_type = mime_type_html;
641 }
642 else if (str_starts_with(safe_url, "/graphs.xml")) {
643 struct str *buf = xml_graphs();
644 str_extract(buf, &(conn->reply_length), &(conn->reply));
645 conn->mime_type = mime_type_xml;
646 /* hack around Opera caching the XML */
647 conn->header_extra = "Pragma: no-cache\r\n";
648 }
649 else if (strcmp(safe_url, "/style.css") == 0)
650 static_style_css(conn);
651 else if (strcmp(safe_url, "/graph.js") == 0)
652 static_graph_js(conn);
653 else {
654 default_reply(conn, 404, "Not Found",
655 "The page you requested could not be found.");
656 free(safe_url);
657 return;
658 }
659 free(safe_url);
660
661 process_gzip(conn);
662 assert(conn->mime_type != NULL);
663 generate_header(conn, 200, "OK");
664 }
665
666
667
668 /* ---------------------------------------------------------------------------
669 * Process a request: build the header and reply, advance state.
670 */
671 static void process_request(struct connection *conn)
672 {
673 if (!parse_request(conn))
674 {
675 default_reply(conn, 400, "Bad Request",
676 "You sent a request that the server couldn't understand.");
677 }
678 else if (strcmp(conn->method, "GET") == 0)
679 {
680 process_get(conn);
681 }
682 else if (strcmp(conn->method, "HEAD") == 0)
683 {
684 process_get(conn);
685 conn->header_only = 1;
686 }
687 else
688 {
689 default_reply(conn, 501, "Not Implemented",
690 "The method you specified (%s) is not implemented.",
691 conn->method);
692 }
693
694 /* advance state */
695 if (conn->header_only)
696 conn->state = SEND_HEADER;
697 else
698 conn->state = SEND_HEADER_AND_REPLY;
699
700 /* request not needed anymore */
701 free(conn->request);
702 conn->request = NULL; /* important: don't free it again later */
703 }
704
705
706
707 /* ---------------------------------------------------------------------------
708 * Receiving request.
709 */
710 static void poll_recv_request(struct connection *conn)
711 {
712 #define BUFSIZE 65536
713 char buf[BUFSIZE];
714 ssize_t recvd;
715
716 recvd = recv(conn->socket, buf, BUFSIZE, 0);
717 dverbosef("poll_recv_request(%d) got %d bytes", conn->socket, (int)recvd);
718 if (recvd <= 0)
719 {
720 if (recvd == -1)
721 verbosef("recv(%d) error: %s", conn->socket, strerror(errno));
722 conn->state = DONE;
723 return;
724 }
725 conn->last_active = now;
726 #undef BUFSIZE
727
728 /* append to conn->request */
729 conn->request = xrealloc(conn->request, conn->request_length+recvd+1);
730 memcpy(conn->request+conn->request_length, buf, (size_t)recvd);
731 conn->request_length += recvd;
732 conn->request[conn->request_length] = 0;
733
734 /* process request if we have all of it */
735 if (conn->request_length > 4 &&
736 memcmp(conn->request+conn->request_length-4, "\r\n\r\n", 4) == 0)
737 process_request(conn);
738
739 /* die if it's too long */
740 if (conn->request_length > MAX_REQUEST_LENGTH)
741 {
742 default_reply(conn, 413, "Request Entity Too Large",
743 "Your request was dropped because it was too long.");
744 conn->state = SEND_HEADER;
745 }
746 }
747
748
749
750 /* ---------------------------------------------------------------------------
751 * Try to send header and [a part of the] reply in one packet.
752 */
753 static void poll_send_header_and_reply(struct connection *conn)
754 {
755 ssize_t sent;
756 struct iovec iov[2];
757
758 assert(!conn->header_only);
759 assert(conn->reply_length > 0);
760 assert(conn->header_sent == 0);
761
762 assert(conn->reply_sent == 0);
763
764 /* Fill out iovec */
765 iov[0].iov_base = conn->header;
766 iov[0].iov_len = conn->header_length;
767
768 iov[1].iov_base = conn->reply;
769 iov[1].iov_len = conn->reply_length;
770
771 sent = writev(conn->socket, iov, 2);
772 conn->last_active = now;
773
774 /* handle any errors (-1) or closure (0) in send() */
775 if (sent < 1) {
776 if (sent == -1)
777 verbosef("writev(%d) error: %s", conn->socket, strerror(errno));
778 conn->state = DONE;
779 return;
780 }
781
782 /* Figure out what we've sent. */
783 conn->total_sent += (unsigned int)sent;
784 if (sent < (ssize_t)conn->header_length) {
785 verbosef("partially sent header");
786 conn->header_sent = sent;
787 conn->state = SEND_HEADER;
788 return;
789 }
790 /* else */
791 conn->header_sent = conn->header_length;
792 sent -= conn->header_length;
793
794 if (sent < (ssize_t)conn->reply_length) {
795 verbosef("partially sent reply");
796 conn->reply_sent += sent;
797 conn->state = SEND_REPLY;
798 return;
799 }
800 /* else */
801 conn->reply_sent = conn->reply_length;
802 conn->state = DONE;
803 }
804
805 /* ---------------------------------------------------------------------------
806 * Sending header. Assumes conn->header is not NULL.
807 */
808 static void poll_send_header(struct connection *conn)
809 {
810 ssize_t sent;
811
812 sent = send(conn->socket, conn->header + conn->header_sent,
813 conn->header_length - conn->header_sent, 0);
814 conn->last_active = now;
815 dverbosef("poll_send_header(%d) sent %d bytes", conn->socket, (int)sent);
816
817 /* handle any errors (-1) or closure (0) in send() */
818 if (sent < 1)
819 {
820 if (sent == -1)
821 verbosef("send(%d) error: %s", conn->socket, strerror(errno));
822 conn->state = DONE;
823 return;
824 }
825 conn->header_sent += (unsigned int)sent;
826 conn->total_sent += (unsigned int)sent;
827
828 /* check if we're done sending */
829 if (conn->header_sent == conn->header_length)
830 {
831 if (conn->header_only)
832 conn->state = DONE;
833 else
834 conn->state = SEND_REPLY;
835 }
836 }
837
838
839
840 /* ---------------------------------------------------------------------------
841 * Sending reply.
842 */
843 static void poll_send_reply(struct connection *conn)
844 {
845 ssize_t sent;
846
847 sent = send(conn->socket,
848 conn->reply + conn->reply_sent,
849 conn->reply_length - conn->reply_sent, 0);
850 conn->last_active = now;
851 dverbosef("poll_send_reply(%d) sent %d: [%d-%d] of %d",
852 conn->socket, (int)sent,
853 (int)conn->reply_sent,
854 (int)(conn->reply_sent + sent - 1),
855 (int)conn->reply_length);
856
857 /* handle any errors (-1) or closure (0) in send() */
858 if (sent < 1)
859 {
860 if (sent == -1)
861 verbosef("send(%d) error: %s", conn->socket, strerror(errno));
862 else if (sent == 0)
863 verbosef("send(%d) closure", conn->socket);
864 conn->state = DONE;
865 return;
866 }
867 conn->reply_sent += (unsigned int)sent;
868 conn->total_sent += (unsigned int)sent;
869
870 /* check if we're done sending */
871 if (conn->reply_sent == conn->reply_length) conn->state = DONE;
872 }
873
874 /* Use getaddrinfo to figure out what type of socket to create and
875 * what to bind it to. "bindaddr" can be NULL. Remember to freeaddrinfo()
876 * the result.
877 */
878 static struct addrinfo *get_bind_addr(
879 const char *bindaddr, const unsigned short bindport)
880 {
881 struct addrinfo hints, *ai;
882 char portstr[6];
883 int ret;
884
885 memset(&hints, 0, sizeof(hints));
886 hints.ai_family = AF_UNSPEC;
887 #ifdef linux
888 /* Special case for Linux: with bindaddr=NULL and ai_family=AF_UNSPEC,
889 * we successfully bind to 0.0.0.0 and then fail to bind to ::, resulting
890 * in a v4-only http socket.
891 *
892 * Conversely, if we specify AF_INET6, we bind to just :: which is able to
893 * accept v4 as well as v6 connections.
894 */
895 if (bindaddr == NULL)
896 hints.ai_family = AF_INET6; /* we'll get a dual stack socket */
897 #endif
898 hints.ai_socktype = SOCK_STREAM;
899 hints.ai_flags = AI_PASSIVE;
900 snprintf(portstr, sizeof(portstr), "%u", bindport);
901 if ((ret = getaddrinfo(bindaddr, portstr, &hints, &ai)))
902 err(1, "getaddrinfo(%s,%s) failed: %s",
903 bindaddr ? bindaddr : "NULL", portstr, gai_strerror(ret));
904 if (ai == NULL)
905 err(1, "getaddrinfo() returned NULL pointer");
906 return ai;
907 }
908
909 void http_add_bindaddr(const char *bindaddr)
910 {
911 struct bindaddr_entry *ent;
912
913 ent = xmalloc(sizeof(*ent));
914 ent->s = bindaddr;
915 STAILQ_INSERT_TAIL(&bindaddrs, ent, entries);
916 }
917
918 static void http_listen_one(struct addrinfo *ai,
919 const unsigned short bindport)
920 {
921 char ipaddr[INET6_ADDRSTRLEN];
922 int sockin, sockopt, ret;
923
924 /* create incoming socket */
925 if ((sockin = socket(ai->ai_family, SOCK_STREAM, 0)) == -1)
926 err(1, "socket() failed");
927
928 /* reuse address */
929 sockopt = 1;
930 if (setsockopt(sockin, SOL_SOCKET, SO_REUSEADDR,
931 &sockopt, sizeof(sockopt)) == -1)
932 err(1, "can't set SO_REUSEADDR");
933
934 /* format address into ipaddr string */
935 if ((ret = getnameinfo(ai->ai_addr, ai->ai_addrlen, ipaddr,
936 sizeof(ipaddr), NULL, 0, NI_NUMERICHOST)) != 0)
937 err(1, "getnameinfo failed: %s", gai_strerror(ret));
938
939 /* bind socket */
940 if (bind(sockin, ai->ai_addr, ai->ai_addrlen) == -1)
941 err(1, "bind(\"%s\") failed", ipaddr);
942
943 /* listen on socket */
944 if (listen(sockin, -1) == -1)
945 err(1, "listen() failed");
946
947 verbosef("listening on http://%s%s%s:%u/",
948 (ai->ai_family == AF_INET6) ? "[" : "",
949 ipaddr,
950 (ai->ai_family == AF_INET6) ? "]" : "",
951 bindport);
952
953 /* add to insocks */
954 insocks = xrealloc(insocks, sizeof(*insocks) * (insock_num + 1));
955 insocks[insock_num++] = sockin;
956 }
957
958 /* Initialize the http sockets and listen on them. */
959 void http_listen(const unsigned short bindport)
960 {
961 /* If the user didn't specify any bind addresses, add a NULL.
962 * This will become a wildcard.
963 */
964 if (STAILQ_EMPTY(&bindaddrs))
965 http_add_bindaddr(NULL);
966
967 /* Listen on every specified interface. */
968 while (!STAILQ_EMPTY(&bindaddrs)) {
969 struct bindaddr_entry *bindaddr = STAILQ_FIRST(&bindaddrs);
970 struct addrinfo *ai, *ais = get_bind_addr(bindaddr->s, bindport);
971
972 /* There could be multiple addresses returned, handle them all. */
973 for (ai = ais; ai; ai = ai->ai_next)
974 http_listen_one(ai, bindport);
975
976 freeaddrinfo(ais);
977
978 STAILQ_REMOVE_HEAD(&bindaddrs, entries);
979 free(bindaddr);
980 }
981
982 /* ignore SIGPIPE */
983 if (signal(SIGPIPE, SIG_IGN) == SIG_ERR)
984 err(1, "can't ignore SIGPIPE");
985 }
986
987
988
989 /* ---------------------------------------------------------------------------
990 * Set recv/send fd_sets and calculate timeout length.
991 */
992 void
993 http_fd_set(fd_set *recv_set, fd_set *send_set, int *max_fd,
994 struct timeval *timeout, int *need_timeout)
995 {
996 struct connection *conn, *next;
997 int minidle = idletime + 1;
998 unsigned int i;
999
1000 #define MAX_FD_SET(sock, fdset) do { \
1001 FD_SET(sock, fdset); *max_fd = MAX(*max_fd, sock); } while(0)
1002
1003 for (i=0; i<insock_num; i++)
1004 MAX_FD_SET(insocks[i], recv_set);
1005
1006 LIST_FOREACH_SAFE(conn, &connlist, entries, next)
1007 {
1008 int idlefor = now - conn->last_active;
1009
1010 /* Time out dead connections. */
1011 if (idlefor >= idletime) {
1012 char ipaddr[INET6_ADDRSTRLEN];
1013 /* FIXME: this is too late on FreeBSD, socket is invalid */
1014 int ret = getnameinfo((struct sockaddr *)&conn->client,
1015 sizeof(conn->client), ipaddr, sizeof(ipaddr),
1016 NULL, 0, NI_NUMERICHOST);
1017 if (ret == 0)
1018 verbosef("http socket timeout from %s (fd %d)",
1019 ipaddr, conn->socket);
1020 else
1021 warn("http socket timeout: getnameinfo error: %s",
1022 gai_strerror(ret));
1023 conn->state = DONE;
1024 }
1025
1026 /* Connections that need a timeout. */
1027 if (conn->state != DONE)
1028 minidle = MIN(minidle, (idletime - idlefor));
1029
1030 switch (conn->state)
1031 {
1032 case DONE:
1033 /* clean out stale connection */
1034 LIST_REMOVE(conn, entries);
1035 free_connection(conn);
1036 free(conn);
1037 break;
1038
1039 case RECV_REQUEST:
1040 MAX_FD_SET(conn->socket, recv_set);
1041 break;
1042
1043 case SEND_HEADER_AND_REPLY:
1044 case SEND_HEADER:
1045 case SEND_REPLY:
1046 MAX_FD_SET(conn->socket, send_set);
1047 break;
1048
1049 default: errx(1, "invalid state");
1050 }
1051 }
1052 #undef MAX_FD_SET
1053
1054 /* Only set timeout if cap hasn't already. */
1055 if ((*need_timeout == 0) && (minidle <= idletime)) {
1056 *need_timeout = 1;
1057 timeout->tv_sec = minidle;
1058 timeout->tv_usec = 0;
1059 }
1060 }
1061
1062
1063
1064 /* ---------------------------------------------------------------------------
1065 * poll connections that select() says need attention
1066 */
1067 void http_poll(fd_set *recv_set, fd_set *send_set)
1068 {
1069 struct connection *conn;
1070 unsigned int i;
1071
1072 for (i=0; i<insock_num; i++)
1073 if (FD_ISSET(insocks[i], recv_set))
1074 accept_connection(insocks[i]);
1075
1076 LIST_FOREACH(conn, &connlist, entries)
1077 switch (conn->state)
1078 {
1079 case RECV_REQUEST:
1080 if (FD_ISSET(conn->socket, recv_set)) poll_recv_request(conn);
1081 break;
1082
1083 case SEND_HEADER_AND_REPLY:
1084 if (FD_ISSET(conn->socket, send_set)) poll_send_header_and_reply(conn);
1085 break;
1086
1087 case SEND_HEADER:
1088 if (FD_ISSET(conn->socket, send_set)) poll_send_header(conn);
1089 break;
1090
1091 case SEND_REPLY:
1092 if (FD_ISSET(conn->socket, send_set)) poll_send_reply(conn);
1093 break;
1094
1095 case DONE: /* fallthrough */
1096 default: errx(1, "invalid state");
1097 }
1098 }
1099
1100 void http_stop(void) {
1101 struct connection *conn;
1102 unsigned int i;
1103
1104 /* Close listening sockets. */
1105 for (i=0; i<insock_num; i++)
1106 close(insocks[i]);
1107 free(insocks);
1108 insocks = NULL;
1109
1110 /* Close in-flight connections. */
1111 LIST_FOREACH(conn, &connlist, entries) {
1112 LIST_REMOVE(conn, entries);
1113 free_connection(conn);
1114 free(conn);
1115 }
1116 }
1117
1118 /* vim:set ts=4 sw=4 et tw=78: */