?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Drop main() prototype. Syncs with NetBSD-8
[minix.git] / external / bsd / libevent / dist / http.c
blob192b1f1aa8fe5e77580b8d5b485526b28e2b319b
1 /* $NetBSD: http.c,v 1.3 2015/01/29 07:26:02 spz Exp $ */
2 /*
3 * Copyright (c) 2002-2007 Niels Provos <provos@citi.umich.edu>
4 * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include "event2/event-config.h"
30 #include <sys/cdefs.h>
31 __RCSID("$NetBSD: http.c,v 1.3 2015/01/29 07:26:02 spz Exp $");
32
33 #ifdef _EVENT_HAVE_SYS_PARAM_H
34 #include <sys/param.h>
35 #endif
36 #ifdef _EVENT_HAVE_SYS_TYPES_H
37 #include <sys/types.h>
38 #endif
39
40 #ifdef _EVENT_HAVE_SYS_TIME_H
41 #include <sys/time.h>
42 #endif
43 #ifdef HAVE_SYS_IOCCOM_H
44 #include <sys/ioccom.h>
45 #endif
46
47 #ifndef WIN32
48 #include <sys/resource.h>
49 #include <sys/socket.h>
50 #include <sys/stat.h>
51 #include <sys/wait.h>
52 #else
53 #include <winsock2.h>
54 #include <ws2tcpip.h>
55 #endif
56
57 #include <sys/queue.h>
58
59 #ifdef _EVENT_HAVE_NETINET_IN_H
60 #include <netinet/in.h>
61 #endif
62 #ifdef _EVENT_HAVE_ARPA_INET_H
63 #include <arpa/inet.h>
64 #endif
65 #ifdef _EVENT_HAVE_NETDB_H
66 #include <netdb.h>
67 #endif
68
69 #ifdef WIN32
70 #include <winsock2.h>
71 #endif
72
73 #include <errno.h>
74 #include <stdio.h>
75 #include <stdlib.h>
76 #include <string.h>
77 #ifndef WIN32
78 #include <syslog.h>
79 #endif
80 #include <signal.h>
81 #include <time.h>
82 #ifdef _EVENT_HAVE_UNISTD_H
83 #include <unistd.h>
84 #endif
85 #ifdef _EVENT_HAVE_FCNTL_H
86 #include <fcntl.h>
87 #endif
88
89 #undef timeout_pending
90 #undef timeout_initialized
91
92 #include "strlcpy-internal.h"
93 #include "event2/http.h"
94 #include "event2/event.h"
95 #include "event2/buffer.h"
96 #include "event2/bufferevent.h"
97 #include "event2/bufferevent_compat.h"
98 #include "event2/http_struct.h"
99 #include "event2/http_compat.h"
100 #include "event2/util.h"
101 #include "event2/listener.h"
102 #include "log-internal.h"
103 #include "util-internal.h"
104 #include "http-internal.h"
105 #include "mm-internal.h"
106 #include "bufferevent-internal.h"
107
108 #ifndef _EVENT_HAVE_GETNAMEINFO
109 #define NI_MAXSERV 32
110 #define NI_MAXHOST 1025
111
112 #ifndef NI_NUMERICHOST
113 #define NI_NUMERICHOST 1
114 #endif
115
116 #ifndef NI_NUMERICSERV
117 #define NI_NUMERICSERV 2
118 #endif
119
120 static int
121 fake_getnameinfo(const struct sockaddr *sa, size_t salen, char *host,
122 size_t hostlen, char *serv, size_t servlen, int flags)
123 {
124 struct sockaddr_in *sin = (struct sockaddr_in *)sa;
125
126 if (serv != NULL) {
127 char tmpserv[16];
128 evutil_snprintf(tmpserv, sizeof(tmpserv),
129 "%d", ntohs(sin->sin_port));
130 if (strlcpy(serv, tmpserv, servlen) >= servlen)
131 return (-1);
132 }
133
134 if (host != NULL) {
135 if (flags & NI_NUMERICHOST) {
136 if (strlcpy(host, inet_ntoa(sin->sin_addr),
137 hostlen) >= hostlen)
138 return (-1);
139 else
140 return (0);
141 } else {
142 struct hostent *hp;
143 hp = gethostbyaddr((char *)&sin->sin_addr,
144 sizeof(struct in_addr), AF_INET);
145 if (hp == NULL)
146 return (-2);
147
148 if (strlcpy(host, hp->h_name, hostlen) >= hostlen)
149 return (-1);
150 else
151 return (0);
152 }
153 }
154 return (0);
155 }
156
157 #endif
158
159 #define REQ_VERSION_BEFORE(req, major_v, minor_v) \
160 ((req)->major < (major_v) || \
161 ((req)->major == (major_v) && (req)->minor < (minor_v)))
162
163 #define REQ_VERSION_ATLEAST(req, major_v, minor_v) \
164 ((req)->major > (major_v) || \
165 ((req)->major == (major_v) && (req)->minor >= (minor_v)))
166
167 #ifndef MIN
168 #define MIN(a,b) (((a)<(b))?(a):(b))
169 #endif
170
171 extern int debug;
172
173 static evutil_socket_t bind_socket_ai(struct evutil_addrinfo *, int reuse);
174 static evutil_socket_t bind_socket(const char *, ev_uint16_t, int reuse);
175 static void name_from_addr(struct sockaddr *, ev_socklen_t, char **, char **);
176 static int evhttp_associate_new_request_with_connection(
177 struct evhttp_connection *evcon);
178 static void evhttp_connection_start_detectclose(
179 struct evhttp_connection *evcon);
180 static void evhttp_connection_stop_detectclose(
181 struct evhttp_connection *evcon);
182 static void evhttp_request_dispatch(struct evhttp_connection* evcon);
183 static void evhttp_read_firstline(struct evhttp_connection *evcon,
184 struct evhttp_request *req);
185 static void evhttp_read_header(struct evhttp_connection *evcon,
186 struct evhttp_request *req);
187 static int evhttp_add_header_internal(struct evkeyvalq *headers,
188 const char *key, const char *value);
189 static const char *evhttp_response_phrase_internal(int code);
190 static void evhttp_get_request(struct evhttp *, evutil_socket_t, struct sockaddr *, ev_socklen_t);
191 static void evhttp_write_buffer(struct evhttp_connection *,
192 void (*)(struct evhttp_connection *, void *), void *);
193 static void evhttp_make_header(struct evhttp_connection *, struct evhttp_request *);
194
195 /* callbacks for bufferevent */
196 static void evhttp_read_cb(struct bufferevent *, void *);
197 static void evhttp_write_cb(struct bufferevent *, void *);
198 static void evhttp_error_cb(struct bufferevent *bufev, short what, void *arg);
199 static int evhttp_decode_uri_internal(const char *uri, size_t length,
200 char *ret, int decode_plus);
201 static int evhttp_find_vhost(struct evhttp *http, struct evhttp **outhttp,
202 const char *hostname);
203
204 #ifndef _EVENT_HAVE_STRSEP
205 /* strsep replacement for platforms that lack it. Only works if
206 * del is one character long. */
207 static char *
208 strsep(char **s, const char *del)
209 {
210 char *d, *tok;
211 EVUTIL_ASSERT(strlen(del) == 1);
212 if (!s || !*s)
213 return NULL;
214 tok = *s;
215 d = strstr(tok, del);
216 if (d) {
217 *d = '\0';
218 *s = d + 1;
219 } else
220 *s = NULL;
221 return tok;
222 }
223 #endif
224
225 static size_t
226 html_replace(const char ch, const char **escaped)
227 {
228 switch (ch) {
229 case '<':
230 *escaped = "&lt;";
231 return 4;
232 case '>':
233 *escaped = "&gt;";
234 return 4;
235 case '"':
236 *escaped = "&quot;";
237 return 6;
238 case '\'':
239 *escaped = "&#039;";
240 return 6;
241 case '&':
242 *escaped = "&amp;";
243 return 5;
244 default:
245 break;
246 }
247
248 return 1;
249 }
250
251 /*
252 * Replaces <, >, ", ' and & with &lt;, &gt;, &quot;,
253 * &#039; and &amp; correspondingly.
254 *
255 * The returned string needs to be freed by the caller.
256 */
257
258 char *
259 evhttp_htmlescape(const char *html)
260 {
261 size_t i;
262 size_t new_size = 0, old_size = 0;
263 char *escaped_html, *p;
264
265 if (html == NULL)
266 return (NULL);
267
268 old_size = strlen(html);
269 for (i = 0; i < old_size; ++i) {
270 const char *replaced = NULL;
271 const size_t replace_size = html_replace(html[i], &replaced);
272 if (replace_size > EV_SIZE_MAX - new_size) {
273 event_warn("%s: html_replace overflow", __func__);
274 return (NULL);
275 }
276 new_size += replace_size;
277 }
278
279 if (new_size == EV_SIZE_MAX)
280 return (NULL);
281 p = escaped_html = mm_malloc(new_size + 1);
282 if (escaped_html == NULL) {
283 event_warn("%s: malloc(%lu)", __func__,
284 (unsigned long)(new_size + 1));
285 return (NULL);
286 }
287 for (i = 0; i < old_size; ++i) {
288 const char *replaced = &html[i];
289 const size_t len = html_replace(html[i], &replaced);
290 memcpy(p, replaced, len);
291 p += len;
292 }
293
294 *p = '\0';
295
296 return (escaped_html);
297 }
298
299 /** Given an evhttp_cmd_type, returns a constant string containing the
300 * equivalent HTTP command, or NULL if the evhttp_command_type is
301 * unrecognized. */
302 static const char *
303 evhttp_method(enum evhttp_cmd_type type)
304 {
305 const char *method;
306
307 switch (type) {
308 case EVHTTP_REQ_GET:
309 method = "GET";
310 break;
311 case EVHTTP_REQ_POST:
312 method = "POST";
313 break;
314 case EVHTTP_REQ_HEAD:
315 method = "HEAD";
316 break;
317 case EVHTTP_REQ_PUT:
318 method = "PUT";
319 break;
320 case EVHTTP_REQ_DELETE:
321 method = "DELETE";
322 break;
323 case EVHTTP_REQ_OPTIONS:
324 method = "OPTIONS";
325 break;
326 case EVHTTP_REQ_TRACE:
327 method = "TRACE";
328 break;
329 case EVHTTP_REQ_CONNECT:
330 method = "CONNECT";
331 break;
332 case EVHTTP_REQ_PATCH:
333 method = "PATCH";
334 break;
335 default:
336 method = NULL;
337 break;
338 }
339
340 return (method);
341 }
342
343 /**
344 * Determines if a response should have a body.
345 * Follows the rules in RFC 2616 section 4.3.
346 * @return 1 if the response MUST have a body; 0 if the response MUST NOT have
347 * a body.
348 */
349 static int
350 evhttp_response_needs_body(struct evhttp_request *req)
351 {
352 return (req->response_code != HTTP_NOCONTENT &&
353 req->response_code != HTTP_NOTMODIFIED &&
354 (req->response_code < 100 || req->response_code >= 200) &&
355 req->type != EVHTTP_REQ_HEAD);
356 }
357
358 /** Helper: adds the event 'ev' with the timeout 'timeout', or with
359 * default_timeout if timeout is -1.
360 */
361 static int
362 evhttp_add_event(struct event *ev, int timeout, int default_timeout)
363 {
364 if (timeout != 0) {
365 struct timeval tv;
366
367 evutil_timerclear(&tv);
368 tv.tv_sec = timeout != -1 ? timeout : default_timeout;
369 return event_add(ev, &tv);
370 } else {
371 return event_add(ev, NULL);
372 }
373 }
374
375 /** Helper: called after we've added some data to an evcon's bufferevent's
376 * output buffer. Sets the evconn's writing-is-done callback, and puts
377 * the bufferevent into writing mode.
378 */
379 static void
380 evhttp_write_buffer(struct evhttp_connection *evcon,
381 void (*cb)(struct evhttp_connection *, void *), void *arg)
382 {
383 event_debug(("%s: preparing to write buffer\n", __func__));
384
385 /* Set call back */
386 evcon->cb = cb;
387 evcon->cb_arg = arg;
388
389 /* Disable the read callback: we don't actually care about data;
390 * we only care about close detection. (We don't disable reading,
391 * since we *do* want to learn about any close events.) */
392 bufferevent_setcb(evcon->bufev,
393 NULL, /*read*/
394 evhttp_write_cb,
395 evhttp_error_cb,
396 evcon);
397
398 bufferevent_enable(evcon->bufev, EV_WRITE);
399 }
400
401 static void
402 evhttp_send_continue_done(struct evhttp_connection *evcon, void *arg)
403 {
404 bufferevent_disable(evcon->bufev, EV_WRITE);
405 }
406
407 static void
408 evhttp_send_continue(struct evhttp_connection *evcon,
409 struct evhttp_request *req)
410 {
411 bufferevent_enable(evcon->bufev, EV_WRITE);
412 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
413 "HTTP/%d.%d 100 Continue\r\n\r\n",
414 req->major, req->minor);
415 evcon->cb = evhttp_send_continue_done;
416 evcon->cb_arg = NULL;
417 bufferevent_setcb(evcon->bufev,
418 evhttp_read_cb,
419 evhttp_write_cb,
420 evhttp_error_cb,
421 evcon);
422 }
423
424 /** Helper: returns true iff evconn is in any connected state. */
425 static int
426 evhttp_connected(struct evhttp_connection *evcon)
427 {
428 switch (evcon->state) {
429 case EVCON_DISCONNECTED:
430 case EVCON_CONNECTING:
431 return (0);
432 case EVCON_IDLE:
433 case EVCON_READING_FIRSTLINE:
434 case EVCON_READING_HEADERS:
435 case EVCON_READING_BODY:
436 case EVCON_READING_TRAILER:
437 case EVCON_WRITING:
438 default:
439 return (1);
440 }
441 }
442
443 /* Create the headers needed for an outgoing HTTP request, adds them to
444 * the request's header list, and writes the request line to the
445 * connection's output buffer.
446 */
447 static void
448 evhttp_make_header_request(struct evhttp_connection *evcon,
449 struct evhttp_request *req)
450 {
451 const char *method;
452
453 evhttp_remove_header(req->output_headers, "Proxy-Connection");
454
455 /* Generate request line */
456 method = evhttp_method(req->type);
457 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
458 "%s %s HTTP/%d.%d\r\n",
459 method, req->uri, req->major, req->minor);
460
461 /* Add the content length on a post or put request if missing */
462 if ((req->type == EVHTTP_REQ_POST || req->type == EVHTTP_REQ_PUT) &&
463 evhttp_find_header(req->output_headers, "Content-Length") == NULL){
464 char size[22];
465 evutil_snprintf(size, sizeof(size), EV_SIZE_FMT,
466 EV_SIZE_ARG(evbuffer_get_length(req->output_buffer)));
467 evhttp_add_header(req->output_headers, "Content-Length", size);
468 }
469 }
470
471 /** Return true if the list of headers in 'headers', intepreted with respect
472 * to flags, means that we should send a "connection: close" when the request
473 * is done. */
474 static int
475 evhttp_is_connection_close(int flags, struct evkeyvalq* headers)
476 {
477 if (flags & EVHTTP_PROXY_REQUEST) {
478 /* proxy connection */
479 const char *connection = evhttp_find_header(headers, "Proxy-Connection");
480 return (connection == NULL || evutil_ascii_strcasecmp(connection, "keep-alive") != 0);
481 } else {
482 const char *connection = evhttp_find_header(headers, "Connection");
483 return (connection != NULL && evutil_ascii_strcasecmp(connection, "close") == 0);
484 }
485 }
486
487 /* Return true iff 'headers' contains 'Connection: keep-alive' */
488 static int
489 evhttp_is_connection_keepalive(struct evkeyvalq* headers)
490 {
491 const char *connection = evhttp_find_header(headers, "Connection");
492 return (connection != NULL
493 && evutil_ascii_strncasecmp(connection, "keep-alive", 10) == 0);
494 }
495
496 /* Add a correct "Date" header to headers, unless it already has one. */
497 static void
498 evhttp_maybe_add_date_header(struct evkeyvalq *headers)
499 {
500 if (evhttp_find_header(headers, "Date") == NULL) {
501 char date[50];
502 #ifndef WIN32
503 struct tm cur;
504 #endif
505 struct tm *cur_p;
506 time_t t = time(NULL);
507 #ifdef WIN32
508 cur_p = gmtime(&t);
509 #else
510 gmtime_r(&t, &cur);
511 cur_p = &cur;
512 #endif
513 if (strftime(date, sizeof(date),
514 "%a, %d %b %Y %H:%M:%S GMT", cur_p) != 0) {
515 evhttp_add_header(headers, "Date", date);
516 }
517 }
518 }
519
520 /* Add a "Content-Length" header with value 'content_length' to headers,
521 * unless it already has a content-length or transfer-encoding header. */
522 static void
523 evhttp_maybe_add_content_length_header(struct evkeyvalq *headers,
524 size_t content_length)
525 {
526 if (evhttp_find_header(headers, "Transfer-Encoding") == NULL &&
527 evhttp_find_header(headers, "Content-Length") == NULL) {
528 char len[22];
529 evutil_snprintf(len, sizeof(len), EV_SIZE_FMT,
530 EV_SIZE_ARG(content_length));
531 evhttp_add_header(headers, "Content-Length", len);
532 }
533 }
534
535 /*
536 * Create the headers needed for an HTTP reply in req->output_headers,
537 * and write the first HTTP response for req line to evcon.
538 */
539 static void
540 evhttp_make_header_response(struct evhttp_connection *evcon,
541 struct evhttp_request *req)
542 {
543 int is_keepalive = evhttp_is_connection_keepalive(req->input_headers);
544 evbuffer_add_printf(bufferevent_get_output(evcon->bufev),
545 "HTTP/%d.%d %d %s\r\n",
546 req->major, req->minor, req->response_code,
547 req->response_code_line);
548
549 if (req->major == 1) {
550 if (req->minor >= 1)
551 evhttp_maybe_add_date_header(req->output_headers);
552
553 /*
554 * if the protocol is 1.0; and the connection was keep-alive
555 * we need to add a keep-alive header, too.
556 */
557 if (req->minor == 0 && is_keepalive)
558 evhttp_add_header(req->output_headers,
559 "Connection", "keep-alive");
560
561 if ((req->minor >= 1 || is_keepalive) &&
562 evhttp_response_needs_body(req)) {
563 /*
564 * we need to add the content length if the
565 * user did not give it, this is required for
566 * persistent connections to work.
567 */
568 evhttp_maybe_add_content_length_header(
569 req->output_headers,
570 evbuffer_get_length(req->output_buffer));
571 }
572 }
573
574 /* Potentially add headers for unidentified content. */
575 if (evhttp_response_needs_body(req)) {
576 if (evhttp_find_header(req->output_headers,
577 "Content-Type") == NULL) {
578 evhttp_add_header(req->output_headers,
579 "Content-Type", "text/html; charset=ISO-8859-1");
580 }
581 }
582
583 /* if the request asked for a close, we send a close, too */
584 if (evhttp_is_connection_close(req->flags, req->input_headers)) {
585 evhttp_remove_header(req->output_headers, "Connection");
586 if (!(req->flags & EVHTTP_PROXY_REQUEST))
587 evhttp_add_header(req->output_headers, "Connection", "close");
588 evhttp_remove_header(req->output_headers, "Proxy-Connection");
589 }
590 }
591
592 /** Generate all headers appropriate for sending the http request in req (or
593 * the response, if we're sending a response), and write them to evcon's
594 * bufferevent. Also writes all data from req->output_buffer */
595 static void
596 evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
597 {
598 struct evkeyval *header;
599 struct evbuffer *output = bufferevent_get_output(evcon->bufev);
600
601 /*
602 * Depending if this is a HTTP request or response, we might need to
603 * add some new headers or remove existing headers.
604 */
605 if (req->kind == EVHTTP_REQUEST) {
606 evhttp_make_header_request(evcon, req);
607 } else {
608 evhttp_make_header_response(evcon, req);
609 }
610
611 TAILQ_FOREACH(header, req->output_headers, next) {
612 evbuffer_add_printf(output, "%s: %s\r\n",
613 header->key, header->value);
614 }
615 evbuffer_add(output, "\r\n", 2);
616
617 if (evbuffer_get_length(req->output_buffer) > 0) {
618 /*
619 * For a request, we add the POST data, for a reply, this
620 * is the regular data.
621 */
622 /* XXX We might want to support waiting (a limited amount of
623 time) for a continue status line from the server before
624 sending POST/PUT message bodies. */
625 evbuffer_add_buffer(output, req->output_buffer);
626 }
627 }
628
629 void
630 evhttp_connection_set_max_headers_size(struct evhttp_connection *evcon,
631 ev_ssize_t new_max_headers_size)
632 {
633 if (new_max_headers_size<0)
634 evcon->max_headers_size = EV_SIZE_MAX;
635 else
636 evcon->max_headers_size = new_max_headers_size;
637 }
638 void
639 evhttp_connection_set_max_body_size(struct evhttp_connection* evcon,
640 ev_ssize_t new_max_body_size)
641 {
642 if (new_max_body_size<0)
643 evcon->max_body_size = EV_UINT64_MAX;
644 else
645 evcon->max_body_size = new_max_body_size;
646 }
647
648 static int
649 evhttp_connection_incoming_fail(struct evhttp_request *req,
650 enum evhttp_connection_error error)
651 {
652 switch (error) {
653 case EVCON_HTTP_TIMEOUT:
654 case EVCON_HTTP_EOF:
655 /*
656 * these are cases in which we probably should just
657 * close the connection and not send a reply. this
658 * case may happen when a browser keeps a persistent
659 * connection open and we timeout on the read. when
660 * the request is still being used for sending, we
661 * need to disassociated it from the connection here.
662 */
663 if (!req->userdone) {
664 /* remove it so that it will not be freed */
665 TAILQ_REMOVE(&req->evcon->requests, req, next);
666 /* indicate that this request no longer has a
667 * connection object
668 */
669 req->evcon = NULL;
670 }
671 return (-1);
672 case EVCON_HTTP_INVALID_HEADER:
673 case EVCON_HTTP_BUFFER_ERROR:
674 case EVCON_HTTP_REQUEST_CANCEL:
675 default: /* xxx: probably should just error on default */
676 /* the callback looks at the uri to determine errors */
677 if (req->uri) {
678 mm_free(req->uri);
679 req->uri = NULL;
680 }
681 if (req->uri_elems) {
682 evhttp_uri_free(req->uri_elems);
683 req->uri_elems = NULL;
684 }
685
686 /*
687 * the callback needs to send a reply, once the reply has
688 * been send, the connection should get freed.
689 */
690 (*req->cb)(req, req->cb_arg);
691 }
692
693 return (0);
694 }
695
696 /* Called when evcon has experienced a (non-recoverable? -NM) error, as
697 * given in error. If it's an outgoing connection, reset the connection,
698 * retry any pending requests, and inform the user. If it's incoming,
699 * delegates to evhttp_connection_incoming_fail(). */
700 void
701 evhttp_connection_fail(struct evhttp_connection *evcon,
702 enum evhttp_connection_error error)
703 {
704 struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
705 void (*cb)(struct evhttp_request *, void *);
706 void *cb_arg;
707 EVUTIL_ASSERT(req != NULL);
708
709 bufferevent_disable(evcon->bufev, EV_READ|EV_WRITE);
710
711 if (evcon->flags & EVHTTP_CON_INCOMING) {
712 /*
713 * for incoming requests, there are two different
714 * failure cases. it's either a network level error
715 * or an http layer error. for problems on the network
716 * layer like timeouts we just drop the connections.
717 * For HTTP problems, we might have to send back a
718 * reply before the connection can be freed.
719 */
720 if (evhttp_connection_incoming_fail(req, error) == -1)
721 evhttp_connection_free(evcon);
722 return;
723 }
724
725 /* when the request was canceled, the callback is not executed */
726 if (error != EVCON_HTTP_REQUEST_CANCEL) {
727 /* save the callback for later; the cb might free our object */
728 cb = req->cb;
729 cb_arg = req->cb_arg;
730 } else {
731 cb = NULL;
732 cb_arg = NULL;
733 }
734
735 /* do not fail all requests; the next request is going to get
736 * send over a new connection. when a user cancels a request,
737 * all other pending requests should be processed as normal
738 */
739 TAILQ_REMOVE(&evcon->requests, req, next);
740 evhttp_request_free(req);
741
742 /* reset the connection */
743 evhttp_connection_reset(evcon);
744
745 /* We are trying the next request that was queued on us */
746 if (TAILQ_FIRST(&evcon->requests) != NULL)
747 evhttp_connection_connect(evcon);
748
749 /* inform the user */
750 if (cb != NULL)
751 (*cb)(NULL, cb_arg);
752 }
753
754 /* Bufferevent callback: invoked when any data has been written from an
755 * http connection's bufferevent */
756 static void
757 evhttp_write_cb(struct bufferevent *bufev, void *arg)
758 {
759 struct evhttp_connection *evcon = arg;
760
761 /* Activate our call back */
762 if (evcon->cb != NULL)
763 (*evcon->cb)(evcon, evcon->cb_arg);
764 }
765
766 /**
767 * Advance the connection state.
768 * - If this is an outgoing connection, we've just processed the response;
769 * idle or close the connection.
770 * - If this is an incoming connection, we've just processed the request;
771 * respond.
772 */
773 static void
774 evhttp_connection_done(struct evhttp_connection *evcon)
775 {
776 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
777 int con_outgoing = evcon->flags & EVHTTP_CON_OUTGOING;
778
779 if (con_outgoing) {
780 /* idle or close the connection */
781 int need_close;
782 TAILQ_REMOVE(&evcon->requests, req, next);
783 req->evcon = NULL;
784
785 evcon->state = EVCON_IDLE;
786
787 need_close =
788 evhttp_is_connection_close(req->flags, req->input_headers)||
789 evhttp_is_connection_close(req->flags, req->output_headers);
790
791 /* check if we got asked to close the connection */
792 if (need_close)
793 evhttp_connection_reset(evcon);
794
795 if (TAILQ_FIRST(&evcon->requests) != NULL) {
796 /*
797 * We have more requests; reset the connection
798 * and deal with the next request.
799 */
800 if (!evhttp_connected(evcon))
801 evhttp_connection_connect(evcon);
802 else
803 evhttp_request_dispatch(evcon);
804 } else if (!need_close) {
805 /*
806 * The connection is going to be persistent, but we
807 * need to detect if the other side closes it.
808 */
809 evhttp_connection_start_detectclose(evcon);
810 }
811 } else {
812 /*
813 * incoming connection - we need to leave the request on the
814 * connection so that we can reply to it.
815 */
816 evcon->state = EVCON_WRITING;
817 }
818
819 /* notify the user of the request */
820 (*req->cb)(req, req->cb_arg);
821
822 /* if this was an outgoing request, we own and it's done. so free it.
823 * unless the callback specifically requested to own the request.
824 */
825 if (con_outgoing && ((req->flags & EVHTTP_USER_OWNED) == 0)) {
826 evhttp_request_free(req);
827 }
828 }
829
830 /*
831 * Handles reading from a chunked request.
832 * return ALL_DATA_READ:
833 * all data has been read
834 * return MORE_DATA_EXPECTED:
835 * more data is expected
836 * return DATA_CORRUPTED:
837 * data is corrupted
838 * return REQUEST_CANCELED:
839 * request was canceled by the user calling evhttp_cancel_request
840 * return DATA_TOO_LONG:
841 * ran over the maximum limit
842 */
843
844 static enum message_read_status
845 evhttp_handle_chunked_read(struct evhttp_request *req, struct evbuffer *buf)
846 {
847 if (req == NULL || buf == NULL) {
848 return DATA_CORRUPTED;
849 }
850
851 while (1) {
852 size_t buflen;
853
854 if ((buflen = evbuffer_get_length(buf)) == 0) {
855 break;
856 }
857
858 /* evbuffer_get_length returns size_t, but len variable is ssize_t,
859 * check for overflow conditions */
860 if (buflen > EV_SSIZE_MAX) {
861 return DATA_CORRUPTED;
862 }
863
864 if (req->ntoread < 0) {
865 /* Read chunk size */
866 ev_int64_t ntoread;
867 char *p = evbuffer_readln(buf, NULL, EVBUFFER_EOL_CRLF);
868 char *endp;
869 int error;
870 if (p == NULL)
871 break;
872 /* the last chunk is on a new line? */
873 if (strlen(p) == 0) {
874 mm_free(p);
875 continue;
876 }
877 ntoread = evutil_strtoll(p, &endp, 16);
878 error = (*p == '\0' ||
879 (*endp != '\0' && *endp != ' ') ||
880 ntoread < 0);
881 mm_free(p);
882 if (error) {
883 /* could not get chunk size */
884 return (DATA_CORRUPTED);
885 }
886
887 /* ntoread is signed int64, body_size is unsigned size_t, check for under/overflow conditions */
888 if ((ev_uint64_t)ntoread > EV_SIZE_MAX - req->body_size) {
889 return DATA_CORRUPTED;
890 }
891
892 if (req->body_size + (size_t)ntoread > req->evcon->max_body_size) {
893 /* failed body length test */
894 event_debug(("Request body is too long"));
895 return (DATA_TOO_LONG);
896 }
897
898 req->body_size += (size_t)ntoread;
899 req->ntoread = ntoread;
900 if (req->ntoread == 0) {
901 /* Last chunk */
902 return (ALL_DATA_READ);
903 }
904 continue;
905 }
906
907 /* req->ntoread is signed int64, len is ssize_t, based on arch,
908 * ssize_t could only be 32b, check for these conditions */
909 if (req->ntoread > EV_SSIZE_MAX) {
910 return DATA_CORRUPTED;
911 }
912
913 /* don't have enough to complete a chunk; wait for more */
914 if (req->ntoread > 0 && buflen < (ev_uint64_t)req->ntoread)
915 return (MORE_DATA_EXPECTED);
916
917 /* Completed chunk */
918 evbuffer_remove_buffer(buf, req->input_buffer, (size_t)req->ntoread);
919 req->ntoread = -1;
920 if (req->chunk_cb != NULL) {
921 req->flags |= EVHTTP_REQ_DEFER_FREE;
922 (*req->chunk_cb)(req, req->cb_arg);
923 evbuffer_drain(req->input_buffer,
924 evbuffer_get_length(req->input_buffer));
925 req->flags &= ~EVHTTP_REQ_DEFER_FREE;
926 if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
927 return (REQUEST_CANCELED);
928 }
929 }
930 }
931
932 return (MORE_DATA_EXPECTED);
933 }
934
935 static void
936 evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
937 {
938 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
939
940 switch (evhttp_parse_headers(req, buf)) {
941 case DATA_CORRUPTED:
942 case DATA_TOO_LONG:
943 evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
944 break;
945 case ALL_DATA_READ:
946 bufferevent_disable(evcon->bufev, EV_READ);
947 evhttp_connection_done(evcon);
948 break;
949 case MORE_DATA_EXPECTED:
950 case REQUEST_CANCELED: /* ??? */
951 default:
952 bufferevent_enable(evcon->bufev, EV_READ);
953 break;
954 }
955 }
956
957 static void
958 evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
959 {
960 struct evbuffer *buf = bufferevent_get_input(evcon->bufev);
961
962 if (req->chunked) {
963 switch (evhttp_handle_chunked_read(req, buf)) {
964 case ALL_DATA_READ:
965 /* finished last chunk */
966 evcon->state = EVCON_READING_TRAILER;
967 evhttp_read_trailer(evcon, req);
968 return;
969 case DATA_CORRUPTED:
970 case DATA_TOO_LONG:/*separate error for this? XXX */
971 /* corrupted data */
972 evhttp_connection_fail(evcon,
973 EVCON_HTTP_INVALID_HEADER);
974 return;
975 case REQUEST_CANCELED:
976 /* request canceled */
977 evhttp_request_free(req);
978 return;
979 case MORE_DATA_EXPECTED:
980 default:
981 break;
982 }
983 } else if (req->ntoread < 0) {
984 /* Read until connection close. */
985 if ((size_t)(req->body_size + evbuffer_get_length(buf)) < req->body_size) {
986 evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
987 return;
988 }
989
990 req->body_size += evbuffer_get_length(buf);
991 evbuffer_add_buffer(req->input_buffer, buf);
992 } else if (req->chunk_cb != NULL || evbuffer_get_length(buf) >= (size_t)req->ntoread) {
993 /* XXX: the above get_length comparison has to be fixed for overflow conditions! */
994 /* We've postponed moving the data until now, but we're
995 * about to use it. */
996 size_t n = evbuffer_get_length(buf);
997
998 if (n > (size_t) req->ntoread)
999 n = (size_t) req->ntoread;
1000 req->ntoread -= n;
1001 req->body_size += n;
1002 evbuffer_remove_buffer(buf, req->input_buffer, n);
1003 }
1004
1005 if (req->body_size > req->evcon->max_body_size ||
1006 (!req->chunked && req->ntoread >= 0 &&
1007 (size_t)req->ntoread > req->evcon->max_body_size)) {
1008 /* XXX: The above casted comparison must checked for overflow */
1009 /* failed body length test */
1010 event_debug(("Request body is too long"));
1011 evhttp_connection_fail(evcon,
1012 EVCON_HTTP_INVALID_HEADER);
1013 return;
1014 }
1015
1016 if (evbuffer_get_length(req->input_buffer) > 0 && req->chunk_cb != NULL) {
1017 req->flags |= EVHTTP_REQ_DEFER_FREE;
1018 (*req->chunk_cb)(req, req->cb_arg);
1019 req->flags &= ~EVHTTP_REQ_DEFER_FREE;
1020 evbuffer_drain(req->input_buffer,
1021 evbuffer_get_length(req->input_buffer));
1022 if ((req->flags & EVHTTP_REQ_NEEDS_FREE) != 0) {
1023 evhttp_request_free(req);
1024 return;
1025 }
1026 }
1027
1028 if (req->ntoread == 0) {
1029 bufferevent_disable(evcon->bufev, EV_READ);
1030 /* Completed content length */
1031 evhttp_connection_done(evcon);
1032 return;
1033 }
1034
1035 /* Read more! */
1036 bufferevent_enable(evcon->bufev, EV_READ);
1037 }
1038
1039 #define get_deferred_queue(evcon) \
1040 (event_base_get_deferred_cb_queue((evcon)->base))
1041
1042 /*
1043 * Gets called when more data becomes available
1044 */
1045
1046 static void
1047 evhttp_read_cb(struct bufferevent *bufev, void *arg)
1048 {
1049 struct evhttp_connection *evcon = arg;
1050 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1051
1052 /* Cancel if it's pending. */
1053 event_deferred_cb_cancel(get_deferred_queue(evcon),
1054 &evcon->read_more_deferred_cb);
1055
1056 switch (evcon->state) {
1057 case EVCON_READING_FIRSTLINE:
1058 evhttp_read_firstline(evcon, req);
1059 /* note the request may have been freed in
1060 * evhttp_read_body */
1061 break;
1062 case EVCON_READING_HEADERS:
1063 evhttp_read_header(evcon, req);
1064 /* note the request may have been freed in
1065 * evhttp_read_body */
1066 break;
1067 case EVCON_READING_BODY:
1068 evhttp_read_body(evcon, req);
1069 /* note the request may have been freed in
1070 * evhttp_read_body */
1071 break;
1072 case EVCON_READING_TRAILER:
1073 evhttp_read_trailer(evcon, req);
1074 break;
1075 case EVCON_IDLE:
1076 {
1077 #ifdef USE_DEBUG
1078 struct evbuffer *input;
1079 size_t total_len;
1080
1081 input = bufferevent_get_input(evcon->bufev);
1082 total_len = evbuffer_get_length(input);
1083 event_debug(("%s: read "EV_SIZE_FMT
1084 " bytes in EVCON_IDLE state,"
1085 " resetting connection",
1086 __func__, EV_SIZE_ARG(total_len)));
1087 #endif
1088
1089 evhttp_connection_reset(evcon);
1090 }
1091 break;
1092 case EVCON_DISCONNECTED:
1093 case EVCON_CONNECTING:
1094 case EVCON_WRITING:
1095 default:
1096 event_errx(1, "%s: illegal connection state %d",
1097 __func__, evcon->state);
1098 }
1099 }
1100
1101 static void
1102 evhttp_deferred_read_cb(struct deferred_cb *cb, void *data)
1103 {
1104 struct evhttp_connection *evcon = data;
1105 evhttp_read_cb(evcon->bufev, evcon);
1106 }
1107
1108 static void
1109 evhttp_write_connectioncb(struct evhttp_connection *evcon, void *arg)
1110 {
1111 /* This is after writing the request to the server */
1112 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1113 EVUTIL_ASSERT(req != NULL);
1114
1115 EVUTIL_ASSERT(evcon->state == EVCON_WRITING);
1116
1117 /* We are done writing our header and are now expecting the response */
1118 req->kind = EVHTTP_RESPONSE;
1119
1120 evhttp_start_read(evcon);
1121 }
1122
1123 /*
1124 * Clean up a connection object
1125 */
1126
1127 void
1128 evhttp_connection_free(struct evhttp_connection *evcon)
1129 {
1130 struct evhttp_request *req;
1131
1132 /* notify interested parties that this connection is going down */
1133 if (evcon->fd != -1) {
1134 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1135 (*evcon->closecb)(evcon, evcon->closecb_arg);
1136 }
1137
1138 /* remove all requests that might be queued on this
1139 * connection. for server connections, this should be empty.
1140 * because it gets dequeued either in evhttp_connection_done or
1141 * evhttp_connection_fail.
1142 */
1143 while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
1144 TAILQ_REMOVE(&evcon->requests, req, next);
1145 evhttp_request_free(req);
1146 }
1147
1148 if (evcon->http_server != NULL) {
1149 struct evhttp *http = evcon->http_server;
1150 TAILQ_REMOVE(&http->connections, evcon, next);
1151 }
1152
1153 if (event_initialized(&evcon->retry_ev)) {
1154 event_del(&evcon->retry_ev);
1155 event_debug_unassign(&evcon->retry_ev);
1156 }
1157
1158 if (evcon->bufev != NULL)
1159 bufferevent_free(evcon->bufev);
1160
1161 event_deferred_cb_cancel(get_deferred_queue(evcon),
1162 &evcon->read_more_deferred_cb);
1163
1164 if (evcon->fd != -1) {
1165 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1166 evutil_closesocket(evcon->fd);
1167 }
1168
1169 if (evcon->bind_address != NULL)
1170 mm_free(evcon->bind_address);
1171
1172 if (evcon->address != NULL)
1173 mm_free(evcon->address);
1174
1175 mm_free(evcon);
1176 }
1177
1178 void
1179 evhttp_connection_set_local_address(struct evhttp_connection *evcon,
1180 const char *address)
1181 {
1182 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1183 if (evcon->bind_address)
1184 mm_free(evcon->bind_address);
1185 if ((evcon->bind_address = mm_strdup(address)) == NULL)
1186 event_warn("%s: strdup", __func__);
1187 }
1188
1189 void
1190 evhttp_connection_set_local_port(struct evhttp_connection *evcon,
1191 ev_uint16_t port)
1192 {
1193 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
1194 evcon->bind_port = port;
1195 }
1196
1197 static void
1198 evhttp_request_dispatch(struct evhttp_connection* evcon)
1199 {
1200 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1201
1202 /* this should not usually happy but it's possible */
1203 if (req == NULL)
1204 return;
1205
1206 /* delete possible close detection events */
1207 evhttp_connection_stop_detectclose(evcon);
1208
1209 /* we assume that the connection is connected already */
1210 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1211
1212 evcon->state = EVCON_WRITING;
1213
1214 /* Create the header from the store arguments */
1215 evhttp_make_header(evcon, req);
1216
1217 evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
1218 }
1219
1220 /* Reset our connection state: disables reading/writing, closes our fd (if
1221 * any), clears out buffers, and puts us in state DISCONNECTED. */
1222 void
1223 evhttp_connection_reset(struct evhttp_connection *evcon)
1224 {
1225 struct evbuffer *tmp;
1226
1227 /* XXXX This is not actually an optimal fix. Instead we ought to have
1228 an API for "stop connecting", or use bufferevent_setfd to turn off
1229 connecting. But for Libevent 2.0, this seems like a minimal change
1230 least likely to disrupt the rest of the bufferevent and http code.
1231
1232 Why is this here? If the fd is set in the bufferevent, and the
1233 bufferevent is connecting, then you can't actually stop the
1234 bufferevent from trying to connect with bufferevent_disable(). The
1235 connect will never trigger, since we close the fd, but the timeout
1236 might. That caused an assertion failure in evhttp_connection_fail.
1237 */
1238 bufferevent_disable_hard(evcon->bufev, EV_READ|EV_WRITE);
1239
1240 if (evcon->fd != -1) {
1241 /* inform interested parties about connection close */
1242 if (evhttp_connected(evcon) && evcon->closecb != NULL)
1243 (*evcon->closecb)(evcon, evcon->closecb_arg);
1244
1245 shutdown(evcon->fd, EVUTIL_SHUT_WR);
1246 evutil_closesocket(evcon->fd);
1247 evcon->fd = -1;
1248 }
1249
1250 /* we need to clean up any buffered data */
1251 tmp = bufferevent_get_output(evcon->bufev);
1252 evbuffer_drain(tmp, evbuffer_get_length(tmp));
1253 tmp = bufferevent_get_input(evcon->bufev);
1254 evbuffer_drain(tmp, evbuffer_get_length(tmp));
1255
1256 evcon->state = EVCON_DISCONNECTED;
1257 }
1258
1259 static void
1260 evhttp_connection_start_detectclose(struct evhttp_connection *evcon)
1261 {
1262 evcon->flags |= EVHTTP_CON_CLOSEDETECT;
1263
1264 bufferevent_enable(evcon->bufev, EV_READ);
1265 }
1266
1267 static void
1268 evhttp_connection_stop_detectclose(struct evhttp_connection *evcon)
1269 {
1270 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1271
1272 bufferevent_disable(evcon->bufev, EV_READ);
1273 }
1274
1275 static void
1276 evhttp_connection_retry(evutil_socket_t fd, short what, void *arg)
1277 {
1278 struct evhttp_connection *evcon = arg;
1279
1280 evcon->state = EVCON_DISCONNECTED;
1281 evhttp_connection_connect(evcon);
1282 }
1283
1284 static void
1285 evhttp_connection_cb_cleanup(struct evhttp_connection *evcon)
1286 {
1287 struct evcon_requestq requests;
1288
1289 if (evcon->retry_max < 0 || evcon->retry_cnt < evcon->retry_max) {
1290 evtimer_assign(&evcon->retry_ev, evcon->base, evhttp_connection_retry, evcon);
1291 /* XXXX handle failure from evhttp_add_event */
1292 evhttp_add_event(&evcon->retry_ev,
1293 MIN(3600, 2 << evcon->retry_cnt),
1294 HTTP_CONNECT_TIMEOUT);
1295 evcon->retry_cnt++;
1296 return;
1297 }
1298 evhttp_connection_reset(evcon);
1299
1300 /*
1301 * User callback can do evhttp_make_request() on the same
1302 * evcon so new request will be added to evcon->requests. To
1303 * avoid freeing it prematurely we iterate over the copy of
1304 * the queue.
1305 */
1306 TAILQ_INIT(&requests);
1307 while (TAILQ_FIRST(&evcon->requests) != NULL) {
1308 struct evhttp_request *request = TAILQ_FIRST(&evcon->requests);
1309 TAILQ_REMOVE(&evcon->requests, request, next);
1310 TAILQ_INSERT_TAIL(&requests, request, next);
1311 }
1312
1313 /* for now, we just signal all requests by executing their callbacks */
1314 while (TAILQ_FIRST(&requests) != NULL) {
1315 struct evhttp_request *request = TAILQ_FIRST(&requests);
1316 TAILQ_REMOVE(&requests, request, next);
1317 request->evcon = NULL;
1318
1319 /* we might want to set an error here */
1320 request->cb(request, request->cb_arg);
1321 evhttp_request_free(request);
1322 }
1323 }
1324
1325 static void
1326 evhttp_error_cb(struct bufferevent *bufev, short what, void *arg)
1327 {
1328 struct evhttp_connection *evcon = arg;
1329 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
1330
1331 switch (evcon->state) {
1332 case EVCON_CONNECTING:
1333 if (what & BEV_EVENT_TIMEOUT) {
1334 event_debug(("%s: connection timeout for \"%s:%d\" on "
1335 EV_SOCK_FMT,
1336 __func__, evcon->address, evcon->port,
1337 EV_SOCK_ARG(evcon->fd)));
1338 evhttp_connection_cb_cleanup(evcon);
1339 return;
1340 }
1341 break;
1342
1343 case EVCON_READING_BODY:
1344 if (!req->chunked && req->ntoread < 0
1345 && what == (BEV_EVENT_READING|BEV_EVENT_EOF)) {
1346 /* EOF on read can be benign */
1347 evhttp_connection_done(evcon);
1348 return;
1349 }
1350 break;
1351
1352 case EVCON_DISCONNECTED:
1353 case EVCON_IDLE:
1354 case EVCON_READING_FIRSTLINE:
1355 case EVCON_READING_HEADERS:
1356 case EVCON_READING_TRAILER:
1357 case EVCON_WRITING:
1358 default:
1359 break;
1360 }
1361
1362 /* when we are in close detect mode, a read error means that
1363 * the other side closed their connection.
1364 */
1365 if (evcon->flags & EVHTTP_CON_CLOSEDETECT) {
1366 evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
1367 EVUTIL_ASSERT(evcon->http_server == NULL);
1368 /* For connections from the client, we just
1369 * reset the connection so that it becomes
1370 * disconnected.
1371 */
1372 EVUTIL_ASSERT(evcon->state == EVCON_IDLE);
1373 evhttp_connection_reset(evcon);
1374 return;
1375 }
1376
1377 if (what & BEV_EVENT_TIMEOUT) {
1378 evhttp_connection_fail(evcon, EVCON_HTTP_TIMEOUT);
1379 } else if (what & (BEV_EVENT_EOF|BEV_EVENT_ERROR)) {
1380 evhttp_connection_fail(evcon, EVCON_HTTP_EOF);
1381 } else {
1382 evhttp_connection_fail(evcon, EVCON_HTTP_BUFFER_ERROR);
1383 }
1384 }
1385
1386 /*
1387 * Event callback for asynchronous connection attempt.
1388 */
1389 static void
1390 evhttp_connection_cb(struct bufferevent *bufev, short what, void *arg)
1391 {
1392 struct evhttp_connection *evcon = arg;
1393 int error;
1394 ev_socklen_t errsz = sizeof(error);
1395
1396 if (!(what & BEV_EVENT_CONNECTED)) {
1397 /* some operating systems return ECONNREFUSED immediately
1398 * when connecting to a local address. the cleanup is going
1399 * to reschedule this function call.
1400 */
1401 #ifndef WIN32
1402 if (errno == ECONNREFUSED)
1403 goto cleanup;
1404 #endif
1405 evhttp_error_cb(bufev, what, arg);
1406 return;
1407 }
1408
1409 /* Check if the connection completed */
1410 if (getsockopt(evcon->fd, SOL_SOCKET, SO_ERROR, (void*)&error,
1411 &errsz) == -1) {
1412 event_debug(("%s: getsockopt for \"%s:%d\" on "EV_SOCK_FMT,
1413 __func__, evcon->address, evcon->port,
1414 EV_SOCK_ARG(evcon->fd)));
1415 goto cleanup;
1416 }
1417
1418 if (error) {
1419 event_debug(("%s: connect failed for \"%s:%d\" on "
1420 EV_SOCK_FMT": %s",
1421 __func__, evcon->address, evcon->port,
1422 EV_SOCK_ARG(evcon->fd),
1423 evutil_socket_error_to_string(error)));
1424 goto cleanup;
1425 }
1426
1427 /* We are connected to the server now */
1428 event_debug(("%s: connected to \"%s:%d\" on "EV_SOCK_FMT"\n",
1429 __func__, evcon->address, evcon->port,
1430 EV_SOCK_ARG(evcon->fd)));
1431
1432 /* Reset the retry count as we were successful in connecting */
1433 evcon->retry_cnt = 0;
1434 evcon->state = EVCON_IDLE;
1435
1436 /* reset the bufferevent cbs */
1437 bufferevent_setcb(evcon->bufev,
1438 evhttp_read_cb,
1439 evhttp_write_cb,
1440 evhttp_error_cb,
1441 evcon);
1442
1443 if (evcon->timeout == -1)
1444 bufferevent_settimeout(evcon->bufev,
1445 HTTP_READ_TIMEOUT, HTTP_WRITE_TIMEOUT);
1446 else {
1447 struct timeval tv;
1448 tv.tv_sec = evcon->timeout;
1449 tv.tv_usec = 0;
1450 bufferevent_set_timeouts(evcon->bufev, &tv, &tv);
1451 }
1452
1453 /* try to start requests that have queued up on this connection */
1454 evhttp_request_dispatch(evcon);
1455 return;
1456
1457 cleanup:
1458 evhttp_connection_cb_cleanup(evcon);
1459 }
1460
1461 /*
1462 * Check if we got a valid response code.
1463 */
1464
1465 static int
1466 evhttp_valid_response_code(int code)
1467 {
1468 if (code == 0)
1469 return (0);
1470
1471 return (1);
1472 }
1473
1474 static int
1475 evhttp_parse_http_version(const char *version, struct evhttp_request *req)
1476 {
1477 int major, minor;
1478 char ch;
1479 int n = sscanf(version, "HTTP/%d.%d%c", &major, &minor, &ch);
1480 if (n != 2 || major > 1) {
1481 event_debug(("%s: bad version %s on message %p from %s",
1482 __func__, version, req, req->remote_host));
1483 return (-1);
1484 }
1485 req->major = major;
1486 req->minor = minor;
1487 return (0);
1488 }
1489
1490 /* Parses the status line of a web server */
1491
1492 static int
1493 evhttp_parse_response_line(struct evhttp_request *req, char *line)
1494 {
1495 char *protocol;
1496 char *number;
1497 const char *readable = "";
1498
1499 protocol = strsep(&line, " ");
1500 if (line == NULL)
1501 return (-1);
1502 number = strsep(&line, " ");
1503 if (line != NULL)
1504 readable = line;
1505
1506 if (evhttp_parse_http_version(protocol, req) < 0)
1507 return (-1);
1508
1509 req->response_code = atoi(number);
1510 if (!evhttp_valid_response_code(req->response_code)) {
1511 event_debug(("%s: bad response code \"%s\"",
1512 __func__, number));
1513 return (-1);
1514 }
1515
1516 if ((req->response_code_line = mm_strdup(readable)) == NULL) {
1517 event_warn("%s: strdup", __func__);
1518 return (-1);
1519 }
1520
1521 return (0);
1522 }
1523
1524 /* Parse the first line of a HTTP request */
1525
1526 static int
1527 evhttp_parse_request_line(struct evhttp_request *req, char *line)
1528 {
1529 char *method;
1530 char *uri;
1531 char *version;
1532 const char *hostname;
1533 const char *scheme;
1534
1535 /* Parse the request line */
1536 method = strsep(&line, " ");
1537 if (line == NULL)
1538 return (-1);
1539 uri = strsep(&line, " ");
1540 if (line == NULL)
1541 return (-1);
1542 version = strsep(&line, " ");
1543 if (line != NULL)
1544 return (-1);
1545
1546 /* First line */
1547 if (strcmp(method, "GET") == 0) {
1548 req->type = EVHTTP_REQ_GET;
1549 } else if (strcmp(method, "POST") == 0) {
1550 req->type = EVHTTP_REQ_POST;
1551 } else if (strcmp(method, "HEAD") == 0) {
1552 req->type = EVHTTP_REQ_HEAD;
1553 } else if (strcmp(method, "PUT") == 0) {
1554 req->type = EVHTTP_REQ_PUT;
1555 } else if (strcmp(method, "DELETE") == 0) {
1556 req->type = EVHTTP_REQ_DELETE;
1557 } else if (strcmp(method, "OPTIONS") == 0) {
1558 req->type = EVHTTP_REQ_OPTIONS;
1559 } else if (strcmp(method, "TRACE") == 0) {
1560 req->type = EVHTTP_REQ_TRACE;
1561 } else if (strcmp(method, "PATCH") == 0) {
1562 req->type = EVHTTP_REQ_PATCH;
1563 } else {
1564 req->type = _EVHTTP_REQ_UNKNOWN;
1565 event_debug(("%s: bad method %s on request %p from %s",
1566 __func__, method, req, req->remote_host));
1567 /* No error yet; we'll give a better error later when
1568 * we see that req->type is unsupported. */
1569 }
1570
1571 if (evhttp_parse_http_version(version, req) < 0)
1572 return (-1);
1573
1574 if ((req->uri = mm_strdup(uri)) == NULL) {
1575 event_debug(("%s: mm_strdup", __func__));
1576 return (-1);
1577 }
1578
1579 if ((req->uri_elems = evhttp_uri_parse_with_flags(req->uri,
1580 EVHTTP_URI_NONCONFORMANT)) == NULL) {
1581 return -1;
1582 }
1583
1584 /* If we have an absolute-URI, check to see if it is an http request
1585 for a known vhost or server alias. If we don't know about this
1586 host, we consider it a proxy request. */
1587 scheme = evhttp_uri_get_scheme(req->uri_elems);
1588 hostname = evhttp_uri_get_host(req->uri_elems);
1589 if (scheme && (!evutil_ascii_strcasecmp(scheme, "http") ||
1590 !evutil_ascii_strcasecmp(scheme, "https")) &&
1591 hostname &&
1592 !evhttp_find_vhost(req->evcon->http_server, NULL, hostname))
1593 req->flags |= EVHTTP_PROXY_REQUEST;
1594
1595 return (0);
1596 }
1597
1598 const char *
1599 evhttp_find_header(const struct evkeyvalq *headers, const char *key)
1600 {
1601 struct evkeyval *header;
1602
1603 TAILQ_FOREACH(header, headers, next) {
1604 if (evutil_ascii_strcasecmp(header->key, key) == 0)
1605 return (header->value);
1606 }
1607
1608 return (NULL);
1609 }
1610
1611 void
1612 evhttp_clear_headers(struct evkeyvalq *headers)
1613 {
1614 struct evkeyval *header;
1615
1616 for (header = TAILQ_FIRST(headers);
1617 header != NULL;
1618 header = TAILQ_FIRST(headers)) {
1619 TAILQ_REMOVE(headers, header, next);
1620 mm_free(header->key);
1621 mm_free(header->value);
1622 mm_free(header);
1623 }
1624 }
1625
1626 /*
1627 * Returns 0, if the header was successfully removed.
1628 * Returns -1, if the header could not be found.
1629 */
1630
1631 int
1632 evhttp_remove_header(struct evkeyvalq *headers, const char *key)
1633 {
1634 struct evkeyval *header;
1635
1636 TAILQ_FOREACH(header, headers, next) {
1637 if (evutil_ascii_strcasecmp(header->key, key) == 0)
1638 break;
1639 }
1640
1641 if (header == NULL)
1642 return (-1);
1643
1644 /* Free and remove the header that we found */
1645 TAILQ_REMOVE(headers, header, next);
1646 mm_free(header->key);
1647 mm_free(header->value);
1648 mm_free(header);
1649
1650 return (0);
1651 }
1652
1653 static int
1654 evhttp_header_is_valid_value(const char *value)
1655 {
1656 const char *p = value;
1657
1658 while ((p = strpbrk(p, "\r\n")) != NULL) {
1659 /* we really expect only one new line */
1660 p += strspn(p, "\r\n");
1661 /* we expect a space or tab for continuation */
1662 if (*p != ' ' && *p != '\t')
1663 return (0);
1664 }
1665 return (1);
1666 }
1667
1668 int
1669 evhttp_add_header(struct evkeyvalq *headers,
1670 const char *key, const char *value)
1671 {
1672 event_debug(("%s: key: %s val: %s\n", __func__, key, value));
1673
1674 if (strchr(key, '\r') != NULL || strchr(key, '\n') != NULL) {
1675 /* drop illegal headers */
1676 event_debug(("%s: dropping illegal header key\n", __func__));
1677 return (-1);
1678 }
1679
1680 if (!evhttp_header_is_valid_value(value)) {
1681 event_debug(("%s: dropping illegal header value\n", __func__));
1682 return (-1);
1683 }
1684
1685 return (evhttp_add_header_internal(headers, key, value));
1686 }
1687
1688 static int
1689 evhttp_add_header_internal(struct evkeyvalq *headers,
1690 const char *key, const char *value)
1691 {
1692 struct evkeyval *header = mm_calloc(1, sizeof(struct evkeyval));
1693 if (header == NULL) {
1694 event_warn("%s: calloc", __func__);
1695 return (-1);
1696 }
1697 if ((header->key = mm_strdup(key)) == NULL) {
1698 mm_free(header);
1699 event_warn("%s: strdup", __func__);
1700 return (-1);
1701 }
1702 if ((header->value = mm_strdup(value)) == NULL) {
1703 mm_free(header->key);
1704 mm_free(header);
1705 event_warn("%s: strdup", __func__);
1706 return (-1);
1707 }
1708
1709 TAILQ_INSERT_TAIL(headers, header, next);
1710
1711 return (0);
1712 }
1713
1714 /*
1715 * Parses header lines from a request or a response into the specified
1716 * request object given an event buffer.
1717 *
1718 * Returns
1719 * DATA_CORRUPTED on error
1720 * MORE_DATA_EXPECTED when we need to read more headers
1721 * ALL_DATA_READ when all headers have been read.
1722 */
1723
1724 enum message_read_status
1725 evhttp_parse_firstline(struct evhttp_request *req, struct evbuffer *buffer)
1726 {
1727 char *line;
1728 enum message_read_status status = ALL_DATA_READ;
1729
1730 size_t line_length;
1731 /* XXX try */
1732 line = evbuffer_readln(buffer, &line_length, EVBUFFER_EOL_CRLF);
1733 if (line == NULL) {
1734 if (req->evcon != NULL &&
1735 evbuffer_get_length(buffer) > req->evcon->max_headers_size)
1736 return (DATA_TOO_LONG);
1737 else
1738 return (MORE_DATA_EXPECTED);
1739 }
1740
1741 if (req->evcon != NULL &&
1742 line_length > req->evcon->max_headers_size) {
1743 mm_free(line);
1744 return (DATA_TOO_LONG);
1745 }
1746
1747 req->headers_size = line_length;
1748
1749 switch (req->kind) {
1750 case EVHTTP_REQUEST:
1751 if (evhttp_parse_request_line(req, line) == -1)
1752 status = DATA_CORRUPTED;
1753 break;
1754 case EVHTTP_RESPONSE:
1755 if (evhttp_parse_response_line(req, line) == -1)
1756 status = DATA_CORRUPTED;
1757 break;
1758 default:
1759 status = DATA_CORRUPTED;
1760 }
1761
1762 mm_free(line);
1763 return (status);
1764 }
1765
1766 static int
1767 evhttp_append_to_last_header(struct evkeyvalq *headers, const char *line)
1768 {
1769 struct evkeyval *header = TAILQ_LAST(headers, evkeyvalq);
1770 char *newval;
1771 size_t old_len, line_len;
1772
1773 if (header == NULL)
1774 return (-1);
1775
1776 old_len = strlen(header->value);
1777 line_len = strlen(line);
1778
1779 newval = mm_realloc(header->value, old_len + line_len + 1);
1780 if (newval == NULL)
1781 return (-1);
1782
1783 memcpy(newval + old_len, line, line_len + 1);
1784 header->value = newval;
1785
1786 return (0);
1787 }
1788
1789 enum message_read_status
1790 evhttp_parse_headers(struct evhttp_request *req, struct evbuffer* buffer)
1791 {
1792 enum message_read_status errcode = DATA_CORRUPTED;
1793 char *line;
1794 enum message_read_status status = MORE_DATA_EXPECTED;
1795
1796 struct evkeyvalq* headers = req->input_headers;
1797 size_t line_length;
1798 while ((line = evbuffer_readln(buffer, &line_length, EVBUFFER_EOL_CRLF))
1799 != NULL) {
1800 char *skey, *svalue;
1801
1802 req->headers_size += line_length;
1803
1804 if (req->evcon != NULL &&
1805 req->headers_size > req->evcon->max_headers_size) {
1806 errcode = DATA_TOO_LONG;
1807 goto error;
1808 }
1809
1810 if (*line == '\0') { /* Last header - Done */
1811 status = ALL_DATA_READ;
1812 mm_free(line);
1813 break;
1814 }
1815
1816 /* Check if this is a continuation line */
1817 if (*line == ' ' || *line == '\t') {
1818 if (evhttp_append_to_last_header(headers, line) == -1)
1819 goto error;
1820 mm_free(line);
1821 continue;
1822 }
1823
1824 /* Processing of header lines */
1825 svalue = line;
1826 skey = strsep(&svalue, ":");
1827 if (svalue == NULL)
1828 goto error;
1829
1830 svalue += strspn(svalue, " ");
1831
1832 if (evhttp_add_header(headers, skey, svalue) == -1)
1833 goto error;
1834
1835 mm_free(line);
1836 }
1837
1838 if (status == MORE_DATA_EXPECTED) {
1839 if (req->evcon != NULL &&
1840 req->headers_size + evbuffer_get_length(buffer) > req->evcon->max_headers_size)
1841 return (DATA_TOO_LONG);
1842 }
1843
1844 return (status);
1845
1846 error:
1847 mm_free(line);
1848 return (errcode);
1849 }
1850
1851 static int
1852 evhttp_get_body_length(struct evhttp_request *req)
1853 {
1854 struct evkeyvalq *headers = req->input_headers;
1855 const char *content_length;
1856 const char *connection;
1857
1858 content_length = evhttp_find_header(headers, "Content-Length");
1859 connection = evhttp_find_header(headers, "Connection");
1860
1861 if (content_length == NULL && connection == NULL)
1862 req->ntoread = -1;
1863 else if (content_length == NULL &&
1864 evutil_ascii_strcasecmp(connection, "Close") != 0) {
1865 /* Bad combination, we don't know when it will end */
1866 event_warnx("%s: we got no content length, but the "
1867 "server wants to keep the connection open: %s.",
1868 __func__, connection);
1869 return (-1);
1870 } else if (content_length == NULL) {
1871 req->ntoread = -1;
1872 } else {
1873 char *endp;
1874 ev_int64_t ntoread = evutil_strtoll(content_length, &endp, 10);
1875 if (*content_length == '\0' || *endp != '\0' || ntoread < 0) {
1876 event_debug(("%s: illegal content length: %s",
1877 __func__, content_length));
1878 return (-1);
1879 }
1880 req->ntoread = ntoread;
1881 }
1882
1883 event_debug(("%s: bytes to read: "EV_I64_FMT" (in buffer "EV_SIZE_FMT")\n",
1884 __func__, EV_I64_ARG(req->ntoread),
1885 EV_SIZE_ARG(evbuffer_get_length(bufferevent_get_input(req->evcon->bufev)))));
1886
1887 return (0);
1888 }
1889
1890 static int
1891 evhttp_method_may_have_body(enum evhttp_cmd_type type)
1892 {
1893 switch (type) {
1894 case EVHTTP_REQ_POST:
1895 case EVHTTP_REQ_PUT:
1896 case EVHTTP_REQ_PATCH:
1897 return 1;
1898 case EVHTTP_REQ_TRACE:
1899 return 0;
1900 /* XXX May any of the below methods have a body? */
1901 case EVHTTP_REQ_GET:
1902 case EVHTTP_REQ_HEAD:
1903 case EVHTTP_REQ_DELETE:
1904 case EVHTTP_REQ_OPTIONS:
1905 case EVHTTP_REQ_CONNECT:
1906 return 0;
1907 default:
1908 return 0;
1909 }
1910 }
1911
1912 static void
1913 evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
1914 {
1915 const char *xfer_enc;
1916
1917 /* If this is a request without a body, then we are done */
1918 if (req->kind == EVHTTP_REQUEST &&
1919 !evhttp_method_may_have_body(req->type)) {
1920 evhttp_connection_done(evcon);
1921 return;
1922 }
1923 evcon->state = EVCON_READING_BODY;
1924 xfer_enc = evhttp_find_header(req->input_headers, "Transfer-Encoding");
1925 if (xfer_enc != NULL && evutil_ascii_strcasecmp(xfer_enc, "chunked") == 0) {
1926 req->chunked = 1;
1927 req->ntoread = -1;
1928 } else {
1929 if (evhttp_get_body_length(req) == -1) {
1930 evhttp_connection_fail(evcon,
1931 EVCON_HTTP_INVALID_HEADER);
1932 return;
1933 }
1934 if (req->kind == EVHTTP_REQUEST && req->ntoread < 1) {
1935 /* An incoming request with no content-length and no
1936 * transfer-encoding has no body. */
1937 evhttp_connection_done(evcon);
1938 return;
1939 }
1940 }
1941
1942 /* Should we send a 100 Continue status line? */
1943 if (req->kind == EVHTTP_REQUEST && REQ_VERSION_ATLEAST(req, 1, 1)) {
1944 const char *expect;
1945
1946 expect = evhttp_find_header(req->input_headers, "Expect");
1947 if (expect) {
1948 if (!evutil_ascii_strcasecmp(expect, "100-continue")) {
1949 /* XXX It would be nice to do some sanity
1950 checking here. Does the resource exist?
1951 Should the resource accept post requests? If
1952 no, we should respond with an error. For
1953 now, just optimistically tell the client to
1954 send their message body. */
1955 if (req->ntoread > 0) {
1956 /* ntoread is ev_int64_t, max_body_size is ev_uint64_t */
1957 if ((req->evcon->max_body_size <= EV_INT64_MAX) && (ev_uint64_t)req->ntoread > req->evcon->max_body_size) {
1958 evhttp_send_error(req, HTTP_ENTITYTOOLARGE, NULL);
1959 return;
1960 }
1961 }
1962 if (!evbuffer_get_length(bufferevent_get_input(evcon->bufev)))
1963 evhttp_send_continue(evcon, req);
1964 } else {
1965 evhttp_send_error(req, HTTP_EXPECTATIONFAILED,
1966 NULL);
1967 return;
1968 }
1969 }
1970 }
1971
1972 evhttp_read_body(evcon, req);
1973 /* note the request may have been freed in evhttp_read_body */
1974 }
1975
1976 static void
1977 evhttp_read_firstline(struct evhttp_connection *evcon,
1978 struct evhttp_request *req)
1979 {
1980 enum message_read_status res;
1981
1982 res = evhttp_parse_firstline(req, bufferevent_get_input(evcon->bufev));
1983 if (res == DATA_CORRUPTED || res == DATA_TOO_LONG) {
1984 /* Error while reading, terminate */
1985 event_debug(("%s: bad header lines on "EV_SOCK_FMT"\n",
1986 __func__, EV_SOCK_ARG(evcon->fd)));
1987 evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
1988 return;
1989 } else if (res == MORE_DATA_EXPECTED) {
1990 /* Need more header lines */
1991 return;
1992 }
1993
1994 evcon->state = EVCON_READING_HEADERS;
1995 evhttp_read_header(evcon, req);
1996 }
1997
1998 static void
1999 evhttp_read_header(struct evhttp_connection *evcon,
2000 struct evhttp_request *req)
2001 {
2002 enum message_read_status res;
2003 evutil_socket_t fd = evcon->fd;
2004
2005 res = evhttp_parse_headers(req, bufferevent_get_input(evcon->bufev));
2006 if (res == DATA_CORRUPTED || res == DATA_TOO_LONG) {
2007 /* Error while reading, terminate */
2008 event_debug(("%s: bad header lines on "EV_SOCK_FMT"\n",
2009 __func__, EV_SOCK_ARG(fd)));
2010 evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
2011 return;
2012 } else if (res == MORE_DATA_EXPECTED) {
2013 /* Need more header lines */
2014 return;
2015 }
2016
2017 /* Disable reading for now */
2018 bufferevent_disable(evcon->bufev, EV_READ);
2019
2020 /* Done reading headers, do the real work */
2021 switch (req->kind) {
2022 case EVHTTP_REQUEST:
2023 event_debug(("%s: checking for post data on "EV_SOCK_FMT"\n",
2024 __func__, EV_SOCK_ARG(fd)));
2025 evhttp_get_body(evcon, req);
2026 /* note the request may have been freed in evhttp_get_body */
2027 break;
2028
2029 case EVHTTP_RESPONSE:
2030 /* Start over if we got a 100 Continue response. */
2031 if (req->response_code == 100) {
2032 evhttp_start_read(evcon);
2033 return;
2034 }
2035 if (!evhttp_response_needs_body(req)) {
2036 event_debug(("%s: skipping body for code %d\n",
2037 __func__, req->response_code));
2038 evhttp_connection_done(evcon);
2039 } else {
2040 event_debug(("%s: start of read body for %s on "
2041 EV_SOCK_FMT"\n",
2042 __func__, req->remote_host, EV_SOCK_ARG(fd)));
2043 evhttp_get_body(evcon, req);
2044 /* note the request may have been freed in
2045 * evhttp_get_body */
2046 }
2047 break;
2048
2049 default:
2050 event_warnx("%s: bad header on "EV_SOCK_FMT, __func__,
2051 EV_SOCK_ARG(fd));
2052 evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
2053 break;
2054 }
2055 /* request may have been freed above */
2056 }
2057
2058 /*
2059 * Creates a TCP connection to the specified port and executes a callback
2060 * when finished. Failure or success is indicate by the passed connection
2061 * object.
2062 *
2063 * Although this interface accepts a hostname, it is intended to take
2064 * only numeric hostnames so that non-blocking DNS resolution can
2065 * happen elsewhere.
2066 */
2067
2068 struct evhttp_connection *
2069 evhttp_connection_new(const char *address, unsigned short port)
2070 {
2071 return (evhttp_connection_base_new(NULL, NULL, address, port));
2072 }
2073
2074 struct evhttp_connection *
2075 evhttp_connection_base_new(struct event_base *base, struct evdns_base *dnsbase,
2076 const char *address, unsigned short port)
2077 {
2078 struct evhttp_connection *evcon = NULL;
2079
2080 event_debug(("Attempting connection to %s:%d\n", address, port));
2081
2082 if ((evcon = mm_calloc(1, sizeof(struct evhttp_connection))) == NULL) {
2083 event_warn("%s: calloc failed", __func__);
2084 goto error;
2085 }
2086
2087 evcon->fd = -1;
2088 evcon->port = port;
2089
2090 evcon->max_headers_size = EV_SIZE_MAX;
2091 evcon->max_body_size = EV_SIZE_MAX;
2092
2093 evcon->timeout = -1;
2094 evcon->retry_cnt = evcon->retry_max = 0;
2095
2096 if ((evcon->address = mm_strdup(address)) == NULL) {
2097 event_warn("%s: strdup failed", __func__);
2098 goto error;
2099 }
2100
2101 if ((evcon->bufev = bufferevent_new(-1,
2102 evhttp_read_cb,
2103 evhttp_write_cb,
2104 evhttp_error_cb, evcon)) == NULL) {
2105 event_warn("%s: bufferevent_new failed", __func__);
2106 goto error;
2107 }
2108
2109 evcon->state = EVCON_DISCONNECTED;
2110 TAILQ_INIT(&evcon->requests);
2111
2112 if (base != NULL) {
2113 evcon->base = base;
2114 bufferevent_base_set(base, evcon->bufev);
2115 }
2116
2117
2118 event_deferred_cb_init(&evcon->read_more_deferred_cb,
2119 evhttp_deferred_read_cb, evcon);
2120
2121 evcon->dns_base = dnsbase;
2122
2123 return (evcon);
2124
2125 error:
2126 if (evcon != NULL)
2127 evhttp_connection_free(evcon);
2128 return (NULL);
2129 }
2130
2131 struct bufferevent *
2132 evhttp_connection_get_bufferevent(struct evhttp_connection *evcon)
2133 {
2134 return evcon->bufev;
2135 }
2136
2137 void
2138 evhttp_connection_set_base(struct evhttp_connection *evcon,
2139 struct event_base *base)
2140 {
2141 EVUTIL_ASSERT(evcon->base == NULL);
2142 EVUTIL_ASSERT(evcon->state == EVCON_DISCONNECTED);
2143 evcon->base = base;
2144 bufferevent_base_set(base, evcon->bufev);
2145 }
2146
2147 void
2148 evhttp_connection_set_timeout(struct evhttp_connection *evcon,
2149 int timeout_in_secs)
2150 {
2151 evcon->timeout = timeout_in_secs;
2152
2153 if (evcon->timeout == -1)
2154 bufferevent_settimeout(evcon->bufev,
2155 HTTP_READ_TIMEOUT, HTTP_WRITE_TIMEOUT);
2156 else
2157 bufferevent_settimeout(evcon->bufev,
2158 evcon->timeout, evcon->timeout);
2159 }
2160
2161 void
2162 evhttp_connection_set_retries(struct evhttp_connection *evcon,
2163 int retry_max)
2164 {
2165 evcon->retry_max = retry_max;
2166 }
2167
2168 void
2169 evhttp_connection_set_closecb(struct evhttp_connection *evcon,
2170 void (*cb)(struct evhttp_connection *, void *), void *cbarg)
2171 {
2172 evcon->closecb = cb;
2173 evcon->closecb_arg = cbarg;
2174 }
2175
2176 void
2177 evhttp_connection_get_peer(struct evhttp_connection *evcon,
2178 char **address, ev_uint16_t *port)
2179 {
2180 *address = evcon->address;
2181 *port = evcon->port;
2182 }
2183
2184 int
2185 evhttp_connection_connect(struct evhttp_connection *evcon)
2186 {
2187 int old_state = evcon->state;
2188
2189 if (evcon->state == EVCON_CONNECTING)
2190 return (0);
2191
2192 evhttp_connection_reset(evcon);
2193
2194 EVUTIL_ASSERT(!(evcon->flags & EVHTTP_CON_INCOMING));
2195 evcon->flags |= EVHTTP_CON_OUTGOING;
2196
2197 evcon->fd = bind_socket(
2198 evcon->bind_address, evcon->bind_port, 0 /*reuse*/);
2199 if (evcon->fd == -1) {
2200 event_debug(("%s: failed to bind to \"%s\"",
2201 __func__, evcon->bind_address));
2202 return (-1);
2203 }
2204
2205 /* Set up a callback for successful connection setup */
2206 bufferevent_setfd(evcon->bufev, evcon->fd);
2207 bufferevent_setcb(evcon->bufev,
2208 NULL /* evhttp_read_cb */,
2209 NULL /* evhttp_write_cb */,
2210 evhttp_connection_cb,
2211 evcon);
2212 bufferevent_settimeout(evcon->bufev, 0,
2213 evcon->timeout != -1 ? evcon->timeout : HTTP_CONNECT_TIMEOUT);
2214 /* make sure that we get a write callback */
2215 bufferevent_enable(evcon->bufev, EV_WRITE);
2216
2217 evcon->state = EVCON_CONNECTING;
2218
2219 if (bufferevent_socket_connect_hostname(evcon->bufev, evcon->dns_base,
2220 AF_UNSPEC, evcon->address, evcon->port) < 0) {
2221 evcon->state = old_state;
2222 event_sock_warn(evcon->fd, "%s: connection to \"%s\" failed",
2223 __func__, evcon->address);
2224 /* some operating systems return ECONNREFUSED immediately
2225 * when connecting to a local address. the cleanup is going
2226 * to reschedule this function call.
2227 */
2228 evhttp_connection_cb_cleanup(evcon);
2229 return (0);
2230 }
2231
2232 return (0);
2233 }
2234
2235 /*
2236 * Starts an HTTP request on the provided evhttp_connection object.
2237 * If the connection object is not connected to the web server already,
2238 * this will start the connection.
2239 */
2240
2241 int
2242 evhttp_make_request(struct evhttp_connection *evcon,
2243 struct evhttp_request *req,
2244 enum evhttp_cmd_type type, const char *uri)
2245 {
2246 /* We are making a request */
2247 req->kind = EVHTTP_REQUEST;
2248 req->type = type;
2249 if (req->uri != NULL)
2250 mm_free(req->uri);
2251 if ((req->uri = mm_strdup(uri)) == NULL) {
2252 event_warn("%s: strdup", __func__);
2253 evhttp_request_free(req);
2254 return (-1);
2255 }
2256
2257 /* Set the protocol version if it is not supplied */
2258 if (!req->major && !req->minor) {
2259 req->major = 1;
2260 req->minor = 1;
2261 }
2262
2263 EVUTIL_ASSERT(req->evcon == NULL);
2264 req->evcon = evcon;
2265 EVUTIL_ASSERT(!(req->flags & EVHTTP_REQ_OWN_CONNECTION));
2266
2267 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
2268
2269 /* If the connection object is not connected; make it so */
2270 if (!evhttp_connected(evcon)) {
2271 int res = evhttp_connection_connect(evcon);
2272 /* evhttp_connection_fail(), which is called through
2273 * evhttp_connection_connect(), assumes that req lies in
2274 * evcon->requests. Thus, enqueue the request in advance and r
2275 * it in the error case. */
2276 if (res != 0)
2277 TAILQ_REMOVE(&evcon->requests, req, next);
2278
2279 return res;
2280 }
2281
2282 /*
2283 * If it's connected already and we are the first in the queue,
2284 * then we can dispatch this request immediately. Otherwise, it
2285 * will be dispatched once the pending requests are completed.
2286 */
2287 if (TAILQ_FIRST(&evcon->requests) == req)
2288 evhttp_request_dispatch(evcon);
2289
2290 return (0);
2291 }
2292
2293 void
2294 evhttp_cancel_request(struct evhttp_request *req)
2295 {
2296 struct evhttp_connection *evcon = req->evcon;
2297 if (evcon != NULL) {
2298 /* We need to remove it from the connection */
2299 if (TAILQ_FIRST(&evcon->requests) == req) {
2300 /* it's currently being worked on, so reset
2301 * the connection.
2302 */
2303 evhttp_connection_fail(evcon,
2304 EVCON_HTTP_REQUEST_CANCEL);
2305
2306 /* connection fail freed the request */
2307 return;
2308 } else {
2309 /* otherwise, we can just remove it from the
2310 * queue
2311 */
2312 TAILQ_REMOVE(&evcon->requests, req, next);
2313 }
2314 }
2315
2316 evhttp_request_free(req);
2317 }
2318
2319 /*
2320 * Reads data from file descriptor into request structure
2321 * Request structure needs to be set up correctly.
2322 */
2323
2324 void
2325 evhttp_start_read(struct evhttp_connection *evcon)
2326 {
2327 /* Set up an event to read the headers */
2328 bufferevent_disable(evcon->bufev, EV_WRITE);
2329 bufferevent_enable(evcon->bufev, EV_READ);
2330 evcon->state = EVCON_READING_FIRSTLINE;
2331 /* Reset the bufferevent callbacks */
2332 bufferevent_setcb(evcon->bufev,
2333 evhttp_read_cb,
2334 evhttp_write_cb,
2335 evhttp_error_cb,
2336 evcon);
2337
2338 /* If there's still data pending, process it next time through the
2339 * loop. Don't do it now; that could get recusive. */
2340 if (evbuffer_get_length(bufferevent_get_input(evcon->bufev))) {
2341 event_deferred_cb_schedule(get_deferred_queue(evcon),
2342 &evcon->read_more_deferred_cb);
2343 }
2344 }
2345
2346 static void
2347 evhttp_send_done(struct evhttp_connection *evcon, void *arg)
2348 {
2349 int need_close;
2350 struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
2351 TAILQ_REMOVE(&evcon->requests, req, next);
2352
2353 need_close =
2354 (REQ_VERSION_BEFORE(req, 1, 1) &&
2355 !evhttp_is_connection_keepalive(req->input_headers))||
2356 evhttp_is_connection_close(req->flags, req->input_headers) ||
2357 evhttp_is_connection_close(req->flags, req->output_headers);
2358
2359 EVUTIL_ASSERT(req->flags & EVHTTP_REQ_OWN_CONNECTION);
2360 evhttp_request_free(req);
2361
2362 if (need_close) {
2363 evhttp_connection_free(evcon);
2364 return;
2365 }
2366
2367 /* we have a persistent connection; try to accept another request. */
2368 if (evhttp_associate_new_request_with_connection(evcon) == -1) {
2369 evhttp_connection_free(evcon);
2370 }
2371 }
2372
2373 /*
2374 * Returns an error page.
2375 */
2376
2377 void
2378 evhttp_send_error(struct evhttp_request *req, int error, const char *reason)
2379 {
2380
2381 #define ERR_FORMAT "<HTML><HEAD>\n" \
2382 "<TITLE>%d %s</TITLE>\n" \
2383 "</HEAD><BODY>\n" \
2384 "<H1>%s</H1>\n" \
2385 "</BODY></HTML>\n"
2386
2387 struct evbuffer *buf = evbuffer_new();
2388 if (buf == NULL) {
2389 /* if we cannot allocate memory; we just drop the connection */
2390 evhttp_connection_free(req->evcon);
2391 return;
2392 }
2393 if (reason == NULL) {
2394 reason = evhttp_response_phrase_internal(error);
2395 }
2396
2397 evhttp_response_code(req, error, reason);
2398
2399 evbuffer_add_printf(buf, ERR_FORMAT, error, reason, reason);
2400
2401 evhttp_send_page(req, buf);
2402
2403 evbuffer_free(buf);
2404 #undef ERR_FORMAT
2405 }
2406
2407 /* Requires that headers and response code are already set up */
2408
2409 static inline void
2410 evhttp_send(struct evhttp_request *req, struct evbuffer *databuf)
2411 {
2412 struct evhttp_connection *evcon = req->evcon;
2413
2414 if (evcon == NULL) {
2415 evhttp_request_free(req);
2416 return;
2417 }
2418
2419 EVUTIL_ASSERT(TAILQ_FIRST(&evcon->requests) == req);
2420
2421 /* we expect no more calls form the user on this request */
2422 req->userdone = 1;
2423
2424 /* xxx: not sure if we really should expose the data buffer this way */
2425 if (databuf != NULL)
2426 evbuffer_add_buffer(req->output_buffer, databuf);
2427
2428 /* Adds headers to the response */
2429 evhttp_make_header(evcon, req);
2430
2431 evhttp_write_buffer(evcon, evhttp_send_done, NULL);
2432 }
2433
2434 void
2435 evhttp_send_reply(struct evhttp_request *req, int code, const char *reason,
2436 struct evbuffer *databuf)
2437 {
2438 evhttp_response_code(req, code, reason);
2439
2440 evhttp_send(req, databuf);
2441 }
2442
2443 void
2444 evhttp_send_reply_start(struct evhttp_request *req, int code,
2445 const char *reason)
2446 {
2447 evhttp_response_code(req, code, reason);
2448 if (evhttp_find_header(req->output_headers, "Content-Length") == NULL &&
2449 REQ_VERSION_ATLEAST(req, 1, 1) &&
2450 evhttp_response_needs_body(req)) {
2451 /*
2452 * prefer HTTP/1.1 chunked encoding to closing the connection;
2453 * note RFC 2616 section 4.4 forbids it with Content-Length:
2454 * and it's not necessary then anyway.
2455 */
2456 evhttp_add_header(req->output_headers, "Transfer-Encoding",
2457 "chunked");
2458 req->chunked = 1;
2459 } else {
2460 req->chunked = 0;
2461 }
2462 evhttp_make_header(req->evcon, req);
2463 evhttp_write_buffer(req->evcon, NULL, NULL);
2464 }
2465
2466 void
2467 evhttp_send_reply_chunk(struct evhttp_request *req, struct evbuffer *databuf)
2468 {
2469 struct evhttp_connection *evcon = req->evcon;
2470 struct evbuffer *output;
2471
2472 if (evcon == NULL)
2473 return;
2474
2475 output = bufferevent_get_output(evcon->bufev);
2476
2477 if (evbuffer_get_length(databuf) == 0)
2478 return;
2479 if (!evhttp_response_needs_body(req))
2480 return;
2481 if (req->chunked) {
2482 evbuffer_add_printf(output, "%x\r\n",
2483 (unsigned)evbuffer_get_length(databuf));
2484 }
2485 evbuffer_add_buffer(output, databuf);
2486 if (req->chunked) {
2487 evbuffer_add(output, "\r\n", 2);
2488 }
2489 evhttp_write_buffer(evcon, NULL, NULL);
2490 }
2491
2492 void
2493 evhttp_send_reply_end(struct evhttp_request *req)
2494 {
2495 struct evhttp_connection *evcon = req->evcon;
2496 struct evbuffer *output;
2497
2498 if (evcon == NULL) {
2499 evhttp_request_free(req);
2500 return;
2501 }
2502
2503 output = bufferevent_get_output(evcon->bufev);
2504
2505 /* we expect no more calls form the user on this request */
2506 req->userdone = 1;
2507
2508 if (req->chunked) {
2509 evbuffer_add(output, "0\r\n\r\n", 5);
2510 evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);
2511 req->chunked = 0;
2512 } else if (evbuffer_get_length(output) == 0) {
2513 /* let the connection know that we are done with the request */
2514 evhttp_send_done(evcon, NULL);
2515 } else {
2516 /* make the callback execute after all data has been written */
2517 evcon->cb = evhttp_send_done;
2518 evcon->cb_arg = NULL;
2519 }
2520 }
2521
2522 static const char *informational_phrases[] = {
2523 /* 100 */ "Continue",
2524 /* 101 */ "Switching Protocols"
2525 };
2526
2527 static const char *success_phrases[] = {
2528 /* 200 */ "OK",
2529 /* 201 */ "Created",
2530 /* 202 */ "Accepted",
2531 /* 203 */ "Non-Authoritative Information",
2532 /* 204 */ "No Content",
2533 /* 205 */ "Reset Content",
2534 /* 206 */ "Partial Content"
2535 };
2536
2537 static const char *redirection_phrases[] = {
2538 /* 300 */ "Multiple Choices",
2539 /* 301 */ "Moved Permanently",
2540 /* 302 */ "Found",
2541 /* 303 */ "See Other",
2542 /* 304 */ "Not Modified",
2543 /* 305 */ "Use Proxy",
2544 /* 307 */ "Temporary Redirect"
2545 };
2546
2547 static const char *client_error_phrases[] = {
2548 /* 400 */ "Bad Request",
2549 /* 401 */ "Unauthorized",
2550 /* 402 */ "Payment Required",
2551 /* 403 */ "Forbidden",
2552 /* 404 */ "Not Found",
2553 /* 405 */ "Method Not Allowed",
2554 /* 406 */ "Not Acceptable",
2555 /* 407 */ "Proxy Authentication Required",
2556 /* 408 */ "Request Time-out",
2557 /* 409 */ "Conflict",
2558 /* 410 */ "Gone",
2559 /* 411 */ "Length Required",
2560 /* 412 */ "Precondition Failed",
2561 /* 413 */ "Request Entity Too Large",
2562 /* 414 */ "Request-URI Too Large",
2563 /* 415 */ "Unsupported Media Type",
2564 /* 416 */ "Requested range not satisfiable",
2565 /* 417 */ "Expectation Failed"
2566 };
2567
2568 static const char *server_error_phrases[] = {
2569 /* 500 */ "Internal Server Error",
2570 /* 501 */ "Not Implemented",
2571 /* 502 */ "Bad Gateway",
2572 /* 503 */ "Service Unavailable",
2573 /* 504 */ "Gateway Time-out",
2574 /* 505 */ "HTTP Version not supported"
2575 };
2576
2577 struct response_class {
2578 const char *name;
2579 size_t num_responses;
2580 const char **responses;
2581 };
2582
2583 #ifndef MEMBERSOF
2584 #define MEMBERSOF(x) (sizeof(x)/sizeof(x[0]))
2585 #endif
2586
2587 static const struct response_class response_classes[] = {
2588 /* 1xx */ { "Informational", MEMBERSOF(informational_phrases), informational_phrases },
2589 /* 2xx */ { "Success", MEMBERSOF(success_phrases), success_phrases },
2590 /* 3xx */ { "Redirection", MEMBERSOF(redirection_phrases), redirection_phrases },
2591 /* 4xx */ { "Client Error", MEMBERSOF(client_error_phrases), client_error_phrases },
2592 /* 5xx */ { "Server Error", MEMBERSOF(server_error_phrases), server_error_phrases }
2593 };
2594
2595 static const char *
2596 evhttp_response_phrase_internal(int code)
2597 {
2598 int klass = code / 100 - 1;
2599 int subcode = code % 100;
2600
2601 /* Unknown class - can't do any better here */
2602 if (klass < 0 || klass >= (int) MEMBERSOF(response_classes))
2603 return "Unknown Status Class";
2604
2605 /* Unknown sub-code, return class name at least */
2606 if (subcode >= (int) response_classes[klass].num_responses)
2607 return response_classes[klass].name;
2608
2609 return response_classes[klass].responses[subcode];
2610 }
2611
2612 void
2613 evhttp_response_code(struct evhttp_request *req, int code, const char *reason)
2614 {
2615 req->kind = EVHTTP_RESPONSE;
2616 req->response_code = code;
2617 if (req->response_code_line != NULL)
2618 mm_free(req->response_code_line);
2619 if (reason == NULL)
2620 reason = evhttp_response_phrase_internal(code);
2621 req->response_code_line = mm_strdup(reason);
2622 if (req->response_code_line == NULL) {
2623 event_warn("%s: strdup", __func__);
2624 /* XXX what else can we do? */
2625 }
2626 }
2627
2628 void
2629 evhttp_send_page(struct evhttp_request *req, struct evbuffer *databuf)
2630 {
2631 if (!req->major || !req->minor) {
2632 req->major = 1;
2633 req->minor = 1;
2634 }
2635
2636 if (req->kind != EVHTTP_RESPONSE)
2637 evhttp_response_code(req, 200, "OK");
2638
2639 evhttp_clear_headers(req->output_headers);
2640 evhttp_add_header(req->output_headers, "Content-Type", "text/html");
2641 evhttp_add_header(req->output_headers, "Connection", "close");
2642
2643 evhttp_send(req, databuf);
2644 }
2645
2646 static const char uri_chars[256] = {
2647 /* 0 */
2648 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2649 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2650 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0,
2651 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
2652 /* 64 */
2653 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2654 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
2655 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2656 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,
2657 /* 128 */
2658 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2659 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2660 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2661 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2662 /* 192 */
2663 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2664 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2665 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2666 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2667 };
2668
2669 #define CHAR_IS_UNRESERVED(c) \
2670 (uri_chars[(unsigned char)(c)])
2671
2672 /*
2673 * Helper functions to encode/decode a string for inclusion in a URI.
2674 * The returned string must be freed by the caller.
2675 */
2676 char *
2677 evhttp_uriencode(const char *uri, ev_ssize_t len, int space_as_plus)
2678 {
2679 struct evbuffer *buf = evbuffer_new();
2680 const char *p, *end;
2681 char *result;
2682
2683 if (buf == NULL)
2684 return (NULL);
2685
2686 if (len >= 0)
2687 end = uri+len;
2688 else
2689 end = uri+strlen(uri);
2690
2691 for (p = uri; p < end; p++) {
2692 if (CHAR_IS_UNRESERVED(*p)) {
2693 evbuffer_add(buf, p, 1);
2694 } else if (*p == ' ' && space_as_plus) {
2695 evbuffer_add(buf, "+", 1);
2696 } else {
2697 evbuffer_add_printf(buf, "%%%02X", (unsigned char)(*p));
2698 }
2699 }
2700 evbuffer_add(buf, "", 1); /* NUL-terminator. */
2701 result = mm_malloc(evbuffer_get_length(buf));
2702 if (result)
2703 evbuffer_remove(buf, result, evbuffer_get_length(buf));
2704 evbuffer_free(buf);
2705
2706 return (result);
2707 }
2708
2709 char *
2710 evhttp_encode_uri(const char *str)
2711 {
2712 return evhttp_uriencode(str, -1, 0);
2713 }
2714
2715 /*
2716 * @param decode_plus_ctl: if 1, we decode plus into space. If 0, we don't.
2717 * If -1, when true we transform plus to space only after we've seen
2718 * a ?. -1 is deprecated.
2719 * @return the number of bytes written to 'ret'.
2720 */
2721 static int
2722 evhttp_decode_uri_internal(
2723 const char *uri, size_t length, char *ret, int decode_plus_ctl)
2724 {
2725 char c;
2726 int j;
2727 int decode_plus = (decode_plus_ctl == 1) ? 1: 0;
2728 unsigned i;
2729
2730 for (i = j = 0; i < length; i++) {
2731 c = uri[i];
2732 if (c == '?') {
2733 if (decode_plus_ctl < 0)
2734 decode_plus = 1;
2735 } else if (c == '+' && decode_plus) {
2736 c = ' ';
2737 } else if (c == '%' && EVUTIL_ISXDIGIT(uri[i+1]) &&
2738 EVUTIL_ISXDIGIT(uri[i+2])) {
2739 char tmp[3];
2740 tmp[0] = uri[i+1];
2741 tmp[1] = uri[i+2];
2742 tmp[2] = '\0';
2743 c = (char)strtol(tmp, NULL, 16);
2744 i += 2;
2745 }
2746 ret[j++] = c;
2747 }
2748 ret[j] = '\0';
2749
2750 return (j);
2751 }
2752
2753 /* deprecated */
2754 char *
2755 evhttp_decode_uri(const char *uri)
2756 {
2757 char *ret;
2758
2759 if ((ret = mm_malloc(strlen(uri) + 1)) == NULL) {
2760 event_warn("%s: malloc(%lu)", __func__,
2761 (unsigned long)(strlen(uri) + 1));
2762 return (NULL);
2763 }
2764
2765 evhttp_decode_uri_internal(uri, strlen(uri),
2766 ret, -1 /*always_decode_plus*/);
2767
2768 return (ret);
2769 }
2770
2771 char *
2772 evhttp_uridecode(const char *uri, int decode_plus, size_t *size_out)
2773 {
2774 char *ret;
2775 int n;
2776
2777 if ((ret = mm_malloc(strlen(uri) + 1)) == NULL) {
2778 event_warn("%s: malloc(%lu)", __func__,
2779 (unsigned long)(strlen(uri) + 1));
2780 return (NULL);
2781 }
2782
2783 n = evhttp_decode_uri_internal(uri, strlen(uri),
2784 ret, !!decode_plus/*always_decode_plus*/);
2785
2786 if (size_out) {
2787 EVUTIL_ASSERT(n >= 0);
2788 *size_out = (size_t)n;
2789 }
2790
2791 return (ret);
2792 }
2793
2794 /*
2795 * Helper function to parse out arguments in a query.
2796 * The arguments are separated by key and value.
2797 */
2798
2799 static int
2800 evhttp_parse_query_impl(const char *str, struct evkeyvalq *headers,
2801 int is_whole_uri)
2802 {
2803 char *line=NULL;
2804 char *argument;
2805 char *p;
2806 const char *query_part;
2807 int result = -1;
2808 struct evhttp_uri *uri=NULL;
2809
2810 TAILQ_INIT(headers);
2811
2812 if (is_whole_uri) {
2813 uri = evhttp_uri_parse(str);
2814 if (!uri)
2815 goto error;
2816 query_part = evhttp_uri_get_query(uri);
2817 } else {
2818 query_part = str;
2819 }
2820
2821 /* No arguments - we are done */
2822 if (!query_part || !strlen(query_part)) {
2823 result = 0;
2824 goto done;
2825 }
2826
2827 if ((line = mm_strdup(query_part)) == NULL) {
2828 event_warn("%s: strdup", __func__);
2829 goto error;
2830 }
2831
2832 p = argument = line;
2833 while (p != NULL && *p != '\0') {
2834 char *key, *value, *decoded_value;
2835 argument = strsep(&p, "&");
2836
2837 value = argument;
2838 key = strsep(&value, "=");
2839 if (value == NULL || *key == '\0') {
2840 goto error;
2841 }
2842
2843 if ((decoded_value = mm_malloc(strlen(value) + 1)) == NULL) {
2844 event_warn("%s: mm_malloc", __func__);
2845 goto error;
2846 }
2847 evhttp_decode_uri_internal(value, strlen(value),
2848 decoded_value, 1 /*always_decode_plus*/);
2849 event_debug(("Query Param: %s -> %s\n", key, decoded_value));
2850 evhttp_add_header_internal(headers, key, decoded_value);
2851 mm_free(decoded_value);
2852 }
2853
2854 result = 0;
2855 goto done;
2856 error:
2857 evhttp_clear_headers(headers);
2858 done:
2859 if (line)
2860 mm_free(line);
2861 if (uri)
2862 evhttp_uri_free(uri);
2863 return result;
2864 }
2865
2866 int
2867 evhttp_parse_query(const char *uri, struct evkeyvalq *headers)
2868 {
2869 return evhttp_parse_query_impl(uri, headers, 1);
2870 }
2871 int
2872 evhttp_parse_query_str(const char *uri, struct evkeyvalq *headers)
2873 {
2874 return evhttp_parse_query_impl(uri, headers, 0);
2875 }
2876
2877 static struct evhttp_cb *
2878 evhttp_dispatch_callback(struct httpcbq *callbacks, struct evhttp_request *req)
2879 {
2880 struct evhttp_cb *cb;
2881 size_t offset = 0;
2882 char *translated;
2883 const char *path;
2884
2885 /* Test for different URLs */
2886 path = evhttp_uri_get_path(req->uri_elems);
2887 offset = strlen(path);
2888 if ((translated = mm_malloc(offset + 1)) == NULL)
2889 return (NULL);
2890 evhttp_decode_uri_internal(path, offset, translated,
2891 0 /* decode_plus */);
2892
2893 TAILQ_FOREACH(cb, callbacks, next) {
2894 if (!strcmp(cb->what, translated)) {
2895 mm_free(translated);
2896 return (cb);
2897 }
2898 }
2899
2900 mm_free(translated);
2901 return (NULL);
2902 }
2903
2904
2905 static int
2906 prefix_suffix_match(const char *pattern, const char *name, int ignorecase)
2907 {
2908 char c;
2909
2910 while (1) {
2911 switch (c = *pattern++) {
2912 case '\0':
2913 return *name == '\0';
2914
2915 case '*':
2916 while (*name != '\0') {
2917 if (prefix_suffix_match(pattern, name,
2918 ignorecase))
2919 return (1);
2920 ++name;
2921 }
2922 return (0);
2923 default:
2924 if (c != *name) {
2925 if (!ignorecase ||
2926 EVUTIL_TOLOWER(c) != EVUTIL_TOLOWER(*name))
2927 return (0);
2928 }
2929 ++name;
2930 }
2931 }
2932 /* NOTREACHED */
2933 }
2934
2935 /*
2936 Search the vhost hierarchy beginning with http for a server alias
2937 matching hostname. If a match is found, and outhttp is non-null,
2938 outhttp is set to the matching http object and 1 is returned.
2939 */
2940
2941 static int
2942 evhttp_find_alias(struct evhttp *http, struct evhttp **outhttp,
2943 const char *hostname)
2944 {
2945 struct evhttp_server_alias *alias;
2946 struct evhttp *vhost;
2947
2948 TAILQ_FOREACH(alias, &http->aliases, next) {
2949 /* XXX Do we need to handle IP addresses? */
2950 if (!evutil_ascii_strcasecmp(alias->alias, hostname)) {
2951 if (outhttp)
2952 *outhttp = http;
2953 return 1;
2954 }
2955 }
2956
2957 /* XXX It might be good to avoid recursion here, but I don't
2958 see a way to do that w/o a list. */
2959 TAILQ_FOREACH(vhost, &http->virtualhosts, next_vhost) {
2960 if (evhttp_find_alias(vhost, outhttp, hostname))
2961 return 1;
2962 }
2963
2964 return 0;
2965 }
2966
2967 /*
2968 Attempts to find the best http object to handle a request for a hostname.
2969 All aliases for the root http object and vhosts are searched for an exact
2970 match. Then, the vhost hierarchy is traversed again for a matching
2971 pattern.
2972
2973 If an alias or vhost is matched, 1 is returned, and outhttp, if non-null,
2974 is set with the best matching http object. If there are no matches, the
2975 root http object is stored in outhttp and 0 is returned.
2976 */
2977
2978 static int
2979 evhttp_find_vhost(struct evhttp *http, struct evhttp **outhttp,
2980 const char *hostname)
2981 {
2982 struct evhttp *vhost;
2983 struct evhttp *oldhttp;
2984 int match_found = 0;
2985
2986 if (evhttp_find_alias(http, outhttp, hostname))
2987 return 1;
2988
2989 do {
2990 oldhttp = http;
2991 TAILQ_FOREACH(vhost, &http->virtualhosts, next_vhost) {
2992 if (prefix_suffix_match(vhost->vhost_pattern,
2993 hostname, 1 /* ignorecase */)) {
2994 http = vhost;
2995 match_found = 1;
2996 break;
2997 }
2998 }
2999 } while (oldhttp != http);
3000
3001 if (outhttp)
3002 *outhttp = http;
3003
3004 return match_found;
3005 }
3006
3007 static void
3008 evhttp_handle_request(struct evhttp_request *req, void *arg)
3009 {
3010 struct evhttp *http = arg;
3011 struct evhttp_cb *cb = NULL;
3012 const char *hostname;
3013
3014 /* we have a new request on which the user needs to take action */
3015 req->userdone = 0;
3016
3017 if (req->type == 0 || req->uri == NULL) {
3018 evhttp_send_error(req, HTTP_BADREQUEST, NULL);
3019 return;
3020 }
3021
3022 if ((http->allowed_methods & req->type) == 0) {
3023 event_debug(("Rejecting disallowed method %x (allowed: %x)\n",
3024 (unsigned)req->type, (unsigned)http->allowed_methods));
3025 evhttp_send_error(req, HTTP_NOTIMPLEMENTED, NULL);
3026 return;
3027 }
3028
3029 /* handle potential virtual hosts */
3030 hostname = evhttp_request_get_host(req);
3031 if (hostname != NULL) {
3032 evhttp_find_vhost(http, &http, hostname);
3033 }
3034
3035 if ((cb = evhttp_dispatch_callback(&http->callbacks, req)) != NULL) {
3036 (*cb->cb)(req, cb->cbarg);
3037 return;
3038 }
3039
3040 /* Generic call back */
3041 if (http->gencb) {
3042 (*http->gencb)(req, http->gencbarg);
3043 return;
3044 } else {
3045 /* We need to send a 404 here */
3046 #define ERR_FORMAT "<html><head>" \
3047 "<title>404 Not Found</title>" \
3048 "</head><body>" \
3049 "<h1>Not Found</h1>" \
3050 "<p>The requested URL %s was not found on this server.</p>"\
3051 "</body></html>\n"
3052
3053 char *escaped_html;
3054 struct evbuffer *buf;
3055
3056 if ((escaped_html = evhttp_htmlescape(req->uri)) == NULL) {
3057 evhttp_connection_free(req->evcon);
3058 return;
3059 }
3060
3061 if ((buf = evbuffer_new()) == NULL) {
3062 mm_free(escaped_html);
3063 evhttp_connection_free(req->evcon);
3064 return;
3065 }
3066
3067 evhttp_response_code(req, HTTP_NOTFOUND, "Not Found");
3068
3069 evbuffer_add_printf(buf, ERR_FORMAT, escaped_html);
3070
3071 mm_free(escaped_html);
3072
3073 evhttp_send_page(req, buf);
3074
3075 evbuffer_free(buf);
3076 #undef ERR_FORMAT
3077 }
3078 }
3079
3080 /* Listener callback when a connection arrives at a server. */
3081 static void
3082 accept_socket_cb(struct evconnlistener *listener, evutil_socket_t nfd, struct sockaddr *peer_sa, int peer_socklen, void *arg)
3083 {
3084 struct evhttp *http = arg;
3085
3086 evhttp_get_request(http, nfd, peer_sa, peer_socklen);
3087 }
3088
3089 int
3090 evhttp_bind_socket(struct evhttp *http, const char *address, ev_uint16_t port)
3091 {
3092 struct evhttp_bound_socket *bound =
3093 evhttp_bind_socket_with_handle(http, address, port);
3094 if (bound == NULL)
3095 return (-1);
3096 return (0);
3097 }
3098
3099 struct evhttp_bound_socket *
3100 evhttp_bind_socket_with_handle(struct evhttp *http, const char *address, ev_uint16_t port)
3101 {
3102 evutil_socket_t fd;
3103 struct evhttp_bound_socket *bound;
3104
3105 if ((fd = bind_socket(address, port, 1 /*reuse*/)) == -1)
3106 return (NULL);
3107
3108 if (listen(fd, 128) == -1) {
3109 event_sock_warn(fd, "%s: listen", __func__);
3110 evutil_closesocket(fd);
3111 return (NULL);
3112 }
3113
3114 bound = evhttp_accept_socket_with_handle(http, fd);
3115
3116 if (bound != NULL) {
3117 event_debug(("Bound to port %d - Awaiting connections ... ",
3118 port));
3119 return (bound);
3120 }
3121
3122 return (NULL);
3123 }
3124
3125 int
3126 evhttp_accept_socket(struct evhttp *http, evutil_socket_t fd)
3127 {
3128 struct evhttp_bound_socket *bound =
3129 evhttp_accept_socket_with_handle(http, fd);
3130 if (bound == NULL)
3131 return (-1);
3132 return (0);
3133 }
3134
3135
3136 struct evhttp_bound_socket *
3137 evhttp_accept_socket_with_handle(struct evhttp *http, evutil_socket_t fd)
3138 {
3139 struct evhttp_bound_socket *bound;
3140 struct evconnlistener *listener;
3141 const int flags =
3142 LEV_OPT_REUSEABLE|LEV_OPT_CLOSE_ON_EXEC|LEV_OPT_CLOSE_ON_FREE;
3143
3144 listener = evconnlistener_new(http->base, NULL, NULL,
3145 flags,
3146 0, /* Backlog is '0' because we already said 'listen' */
3147 fd);
3148 if (!listener)
3149 return (NULL);
3150
3151 bound = evhttp_bind_listener(http, listener);
3152 if (!bound) {
3153 evconnlistener_free(listener);
3154 return (NULL);
3155 }
3156 return (bound);
3157 }
3158
3159 struct evhttp_bound_socket *
3160 evhttp_bind_listener(struct evhttp *http, struct evconnlistener *listener)
3161 {
3162 struct evhttp_bound_socket *bound;
3163
3164 bound = mm_malloc(sizeof(struct evhttp_bound_socket));
3165 if (bound == NULL)
3166 return (NULL);
3167
3168 bound->listener = listener;
3169 TAILQ_INSERT_TAIL(&http->sockets, bound, next);
3170
3171 evconnlistener_set_cb(listener, accept_socket_cb, http);
3172 return bound;
3173 }
3174
3175 evutil_socket_t
3176 evhttp_bound_socket_get_fd(struct evhttp_bound_socket *bound)
3177 {
3178 return evconnlistener_get_fd(bound->listener);
3179 }
3180
3181 struct evconnlistener *
3182 evhttp_bound_socket_get_listener(struct evhttp_bound_socket *bound)
3183 {
3184 return bound->listener;
3185 }
3186
3187 void
3188 evhttp_del_accept_socket(struct evhttp *http, struct evhttp_bound_socket *bound)
3189 {
3190 TAILQ_REMOVE(&http->sockets, bound, next);
3191 evconnlistener_free(bound->listener);
3192 mm_free(bound);
3193 }
3194
3195 static struct evhttp*
3196 evhttp_new_object(void)
3197 {
3198 struct evhttp *http = NULL;
3199
3200 if ((http = mm_calloc(1, sizeof(struct evhttp))) == NULL) {
3201 event_warn("%s: calloc", __func__);
3202 return (NULL);
3203 }
3204
3205 http->timeout = -1;
3206 evhttp_set_max_headers_size(http, EV_SIZE_MAX);
3207 evhttp_set_max_body_size(http, EV_SIZE_MAX);
3208 evhttp_set_allowed_methods(http,
3209 EVHTTP_REQ_GET |
3210 EVHTTP_REQ_POST |
3211 EVHTTP_REQ_HEAD |
3212 EVHTTP_REQ_PUT |
3213 EVHTTP_REQ_DELETE);
3214
3215 TAILQ_INIT(&http->sockets);
3216 TAILQ_INIT(&http->callbacks);
3217 TAILQ_INIT(&http->connections);
3218 TAILQ_INIT(&http->virtualhosts);
3219 TAILQ_INIT(&http->aliases);
3220
3221 return (http);
3222 }
3223
3224 struct evhttp *
3225 evhttp_new(struct event_base *base)
3226 {
3227 struct evhttp *http = NULL;
3228
3229 http = evhttp_new_object();
3230 if (http == NULL)
3231 return (NULL);
3232 http->base = base;
3233
3234 return (http);
3235 }
3236
3237 /*
3238 * Start a web server on the specified address and port.
3239 */
3240
3241 struct evhttp *
3242 evhttp_start(const char *address, unsigned short port)
3243 {
3244 struct evhttp *http = NULL;
3245
3246 http = evhttp_new_object();
3247 if (http == NULL)
3248 return (NULL);
3249 if (evhttp_bind_socket(http, address, port) == -1) {
3250 mm_free(http);
3251 return (NULL);
3252 }
3253
3254 return (http);
3255 }
3256
3257 void
3258 evhttp_free(struct evhttp* http)
3259 {
3260 struct evhttp_cb *http_cb;
3261 struct evhttp_connection *evcon;
3262 struct evhttp_bound_socket *bound;
3263 struct evhttp* vhost;
3264 struct evhttp_server_alias *alias;
3265
3266 /* Remove the accepting part */
3267 while ((bound = TAILQ_FIRST(&http->sockets)) != NULL) {
3268 TAILQ_REMOVE(&http->sockets, bound, next);
3269
3270 evconnlistener_free(bound->listener);
3271
3272 mm_free(bound);
3273 }
3274
3275 while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) {
3276 /* evhttp_connection_free removes the connection */
3277 evhttp_connection_free(evcon);
3278 }
3279
3280 while ((http_cb = TAILQ_FIRST(&http->callbacks)) != NULL) {
3281 TAILQ_REMOVE(&http->callbacks, http_cb, next);
3282 mm_free(http_cb->what);
3283 mm_free(http_cb);
3284 }
3285
3286 while ((vhost = TAILQ_FIRST(&http->virtualhosts)) != NULL) {
3287 TAILQ_REMOVE(&http->virtualhosts, vhost, next_vhost);
3288
3289 evhttp_free(vhost);
3290 }
3291
3292 if (http->vhost_pattern != NULL)
3293 mm_free(http->vhost_pattern);
3294
3295 while ((alias = TAILQ_FIRST(&http->aliases)) != NULL) {
3296 TAILQ_REMOVE(&http->aliases, alias, next);
3297 mm_free(alias->alias);
3298 mm_free(alias);
3299 }
3300
3301 mm_free(http);
3302 }
3303
3304 int
3305 evhttp_add_virtual_host(struct evhttp* http, const char *pattern,
3306 struct evhttp* vhost)
3307 {
3308 /* a vhost can only be a vhost once and should not have bound sockets */
3309 if (vhost->vhost_pattern != NULL ||
3310 TAILQ_FIRST(&vhost->sockets) != NULL)
3311 return (-1);
3312
3313 vhost->vhost_pattern = mm_strdup(pattern);
3314 if (vhost->vhost_pattern == NULL)
3315 return (-1);
3316
3317 TAILQ_INSERT_TAIL(&http->virtualhosts, vhost, next_vhost);
3318
3319 return (0);
3320 }
3321
3322 int
3323 evhttp_remove_virtual_host(struct evhttp* http, struct evhttp* vhost)
3324 {
3325 if (vhost->vhost_pattern == NULL)
3326 return (-1);
3327
3328 TAILQ_REMOVE(&http->virtualhosts, vhost, next_vhost);
3329
3330 mm_free(vhost->vhost_pattern);
3331 vhost->vhost_pattern = NULL;
3332
3333 return (0);
3334 }
3335
3336 int
3337 evhttp_add_server_alias(struct evhttp *http, const char *alias)
3338 {
3339 struct evhttp_server_alias *evalias;
3340
3341 evalias = mm_calloc(1, sizeof(*evalias));
3342 if (!evalias)
3343 return -1;
3344
3345 evalias->alias = mm_strdup(alias);
3346 if (!evalias->alias) {
3347 mm_free(evalias);
3348 return -1;
3349 }
3350
3351 TAILQ_INSERT_TAIL(&http->aliases, evalias, next);
3352
3353 return 0;
3354 }
3355
3356 int
3357 evhttp_remove_server_alias(struct evhttp *http, const char *alias)
3358 {
3359 struct evhttp_server_alias *evalias;
3360
3361 TAILQ_FOREACH(evalias, &http->aliases, next) {
3362 if (evutil_ascii_strcasecmp(evalias->alias, alias) == 0) {
3363 TAILQ_REMOVE(&http->aliases, evalias, next);
3364 mm_free(evalias->alias);
3365 mm_free(evalias);
3366 return 0;
3367 }
3368 }
3369
3370 return -1;
3371 }
3372
3373 void
3374 evhttp_set_timeout(struct evhttp* http, int timeout_in_secs)
3375 {
3376 http->timeout = timeout_in_secs;
3377 }
3378
3379 void
3380 evhttp_set_max_headers_size(struct evhttp* http, ev_ssize_t max_headers_size)
3381 {
3382 if (max_headers_size < 0)
3383 http->default_max_headers_size = EV_SIZE_MAX;
3384 else
3385 http->default_max_headers_size = max_headers_size;
3386 }
3387
3388 void
3389 evhttp_set_max_body_size(struct evhttp* http, ev_ssize_t max_body_size)
3390 {
3391 if (max_body_size < 0)
3392 http->default_max_body_size = EV_UINT64_MAX;
3393 else
3394 http->default_max_body_size = max_body_size;
3395 }
3396
3397 void
3398 evhttp_set_allowed_methods(struct evhttp* http, ev_uint16_t methods)
3399 {
3400 http->allowed_methods = methods;
3401 }
3402
3403 int
3404 evhttp_set_cb(struct evhttp *http, const char *uri,
3405 void (*cb)(struct evhttp_request *, void *), void *cbarg)
3406 {
3407 struct evhttp_cb *http_cb;
3408
3409 TAILQ_FOREACH(http_cb, &http->callbacks, next) {
3410 if (strcmp(http_cb->what, uri) == 0)
3411 return (-1);
3412 }
3413
3414 if ((http_cb = mm_calloc(1, sizeof(struct evhttp_cb))) == NULL) {
3415 event_warn("%s: calloc", __func__);
3416 return (-2);
3417 }
3418
3419 http_cb->what = mm_strdup(uri);
3420 if (http_cb->what == NULL) {
3421 event_warn("%s: strdup", __func__);
3422 mm_free(http_cb);
3423 return (-3);
3424 }
3425 http_cb->cb = cb;
3426 http_cb->cbarg = cbarg;
3427
3428 TAILQ_INSERT_TAIL(&http->callbacks, http_cb, next);
3429
3430 return (0);
3431 }
3432
3433 int
3434 evhttp_del_cb(struct evhttp *http, const char *uri)
3435 {
3436 struct evhttp_cb *http_cb;
3437
3438 TAILQ_FOREACH(http_cb, &http->callbacks, next) {
3439 if (strcmp(http_cb->what, uri) == 0)
3440 break;
3441 }
3442 if (http_cb == NULL)
3443 return (-1);
3444
3445 TAILQ_REMOVE(&http->callbacks, http_cb, next);
3446 mm_free(http_cb->what);
3447 mm_free(http_cb);
3448
3449 return (0);
3450 }
3451
3452 void
3453 evhttp_set_gencb(struct evhttp *http,
3454 void (*cb)(struct evhttp_request *, void *), void *cbarg)
3455 {
3456 http->gencb = cb;
3457 http->gencbarg = cbarg;
3458 }
3459
3460 /*
3461 * Request related functions
3462 */
3463
3464 struct evhttp_request *
3465 evhttp_request_new(void (*cb)(struct evhttp_request *, void *), void *arg)
3466 {
3467 struct evhttp_request *req = NULL;
3468
3469 /* Allocate request structure */
3470 if ((req = mm_calloc(1, sizeof(struct evhttp_request))) == NULL) {
3471 event_warn("%s: calloc", __func__);
3472 goto error;
3473 }
3474
3475 req->headers_size = 0;
3476 req->body_size = 0;
3477
3478 req->kind = EVHTTP_RESPONSE;
3479 req->input_headers = mm_calloc(1, sizeof(struct evkeyvalq));
3480 if (req->input_headers == NULL) {
3481 event_warn("%s: calloc", __func__);
3482 goto error;
3483 }
3484 TAILQ_INIT(req->input_headers);
3485
3486 req->output_headers = mm_calloc(1, sizeof(struct evkeyvalq));
3487 if (req->output_headers == NULL) {
3488 event_warn("%s: calloc", __func__);
3489 goto error;
3490 }
3491 TAILQ_INIT(req->output_headers);
3492
3493 if ((req->input_buffer = evbuffer_new()) == NULL) {
3494 event_warn("%s: evbuffer_new", __func__);
3495 goto error;
3496 }
3497
3498 if ((req->output_buffer = evbuffer_new()) == NULL) {
3499 event_warn("%s: evbuffer_new", __func__);
3500 goto error;
3501 }
3502
3503 req->cb = cb;
3504 req->cb_arg = arg;
3505
3506 return (req);
3507
3508 error:
3509 if (req != NULL)
3510 evhttp_request_free(req);
3511 return (NULL);
3512 }
3513
3514 void
3515 evhttp_request_free(struct evhttp_request *req)
3516 {
3517 if ((req->flags & EVHTTP_REQ_DEFER_FREE) != 0) {
3518 req->flags |= EVHTTP_REQ_NEEDS_FREE;
3519 return;
3520 }
3521
3522 if (req->remote_host != NULL)
3523 mm_free(req->remote_host);
3524 if (req->uri != NULL)
3525 mm_free(req->uri);
3526 if (req->uri_elems != NULL)
3527 evhttp_uri_free(req->uri_elems);
3528 if (req->response_code_line != NULL)
3529 mm_free(req->response_code_line);
3530 if (req->host_cache != NULL)
3531 mm_free(req->host_cache);
3532
3533 evhttp_clear_headers(req->input_headers);
3534 mm_free(req->input_headers);
3535
3536 evhttp_clear_headers(req->output_headers);
3537 mm_free(req->output_headers);
3538
3539 if (req->input_buffer != NULL)
3540 evbuffer_free(req->input_buffer);
3541
3542 if (req->output_buffer != NULL)
3543 evbuffer_free(req->output_buffer);
3544
3545 mm_free(req);
3546 }
3547
3548 void
3549 evhttp_request_own(struct evhttp_request *req)
3550 {
3551 req->flags |= EVHTTP_USER_OWNED;
3552 }
3553
3554 int
3555 evhttp_request_is_owned(struct evhttp_request *req)
3556 {
3557 return (req->flags & EVHTTP_USER_OWNED) != 0;
3558 }
3559
3560 struct evhttp_connection *
3561 evhttp_request_get_connection(struct evhttp_request *req)
3562 {
3563 return req->evcon;
3564 }
3565
3566 struct event_base *
3567 evhttp_connection_get_base(struct evhttp_connection *conn)
3568 {
3569 return conn->base;
3570 }
3571
3572 void
3573 evhttp_request_set_chunked_cb(struct evhttp_request *req,
3574 void (*cb)(struct evhttp_request *, void *))
3575 {
3576 req->chunk_cb = cb;
3577 }
3578
3579 /*
3580 * Allows for inspection of the request URI
3581 */
3582
3583 const char *
3584 evhttp_request_get_uri(const struct evhttp_request *req) {
3585 if (req->uri == NULL)
3586 event_debug(("%s: request %p has no uri\n", __func__, req));
3587 return (req->uri);
3588 }
3589
3590 const struct evhttp_uri *
3591 evhttp_request_get_evhttp_uri(const struct evhttp_request *req) {
3592 if (req->uri_elems == NULL)
3593 event_debug(("%s: request %p has no uri elems\n",
3594 __func__, req));
3595 return (req->uri_elems);
3596 }
3597
3598 const char *
3599 evhttp_request_get_host(struct evhttp_request *req)
3600 {
3601 const char *host = NULL;
3602
3603 if (req->host_cache)
3604 return req->host_cache;
3605
3606 if (req->uri_elems)
3607 host = evhttp_uri_get_host(req->uri_elems);
3608 if (!host && req->input_headers) {
3609 const char *p;
3610 size_t len;
3611
3612 host = evhttp_find_header(req->input_headers, "Host");
3613 /* The Host: header may include a port. Remove it here
3614 to be consistent with uri_elems case above. */
3615 if (host) {
3616 p = host + strlen(host) - 1;
3617 while (p > host && EVUTIL_ISDIGIT(*p))
3618 --p;
3619 if (p > host && *p == ':') {
3620 len = p - host;
3621 req->host_cache = mm_malloc(len + 1);
3622 if (!req->host_cache) {
3623 event_warn("%s: malloc", __func__);
3624 return NULL;
3625 }
3626 memcpy(req->host_cache, host, len);
3627 req->host_cache[len] = '\0';
3628 host = req->host_cache;
3629 }
3630 }
3631 }
3632
3633 return host;
3634 }
3635
3636 enum evhttp_cmd_type
3637 evhttp_request_get_command(const struct evhttp_request *req) {
3638 return (req->type);
3639 }
3640
3641 int
3642 evhttp_request_get_response_code(const struct evhttp_request *req)
3643 {
3644 return req->response_code;
3645 }
3646
3647 /** Returns the input headers */
3648 struct evkeyvalq *evhttp_request_get_input_headers(struct evhttp_request *req)
3649 {
3650 return (req->input_headers);
3651 }
3652
3653 /** Returns the output headers */
3654 struct evkeyvalq *evhttp_request_get_output_headers(struct evhttp_request *req)
3655 {
3656 return (req->output_headers);
3657 }
3658
3659 /** Returns the input buffer */
3660 struct evbuffer *evhttp_request_get_input_buffer(struct evhttp_request *req)
3661 {
3662 return (req->input_buffer);
3663 }
3664
3665 /** Returns the output buffer */
3666 struct evbuffer *evhttp_request_get_output_buffer(struct evhttp_request *req)
3667 {
3668 return (req->output_buffer);
3669 }
3670
3671
3672 /*
3673 * Takes a file descriptor to read a request from.
3674 * The callback is executed once the whole request has been read.
3675 */
3676
3677 static struct evhttp_connection*
3678 evhttp_get_request_connection(
3679 struct evhttp* http,
3680 evutil_socket_t fd, struct sockaddr *sa, ev_socklen_t salen)
3681 {
3682 struct evhttp_connection *evcon;
3683 char *hostname = NULL, *portname = NULL;
3684
3685 name_from_addr(sa, salen, &hostname, &portname);
3686 if (hostname == NULL || portname == NULL) {
3687 if (hostname) mm_free(hostname);
3688 if (portname) mm_free(portname);
3689 return (NULL);
3690 }
3691
3692 event_debug(("%s: new request from %s:%s on "EV_SOCK_FMT"\n",
3693 __func__, hostname, portname, EV_SOCK_ARG(fd)));
3694
3695 /* we need a connection object to put the http request on */
3696 evcon = evhttp_connection_base_new(
3697 http->base, NULL, hostname, atoi(portname));
3698 mm_free(hostname);
3699 mm_free(portname);
3700 if (evcon == NULL)
3701 return (NULL);
3702
3703 evcon->max_headers_size = http->default_max_headers_size;
3704 evcon->max_body_size = http->default_max_body_size;
3705
3706 evcon->flags |= EVHTTP_CON_INCOMING;
3707 evcon->state = EVCON_READING_FIRSTLINE;
3708
3709 evcon->fd = fd;
3710
3711 bufferevent_setfd(evcon->bufev, fd);
3712
3713 return (evcon);
3714 }
3715
3716 static int
3717 evhttp_associate_new_request_with_connection(struct evhttp_connection *evcon)
3718 {
3719 struct evhttp *http = evcon->http_server;
3720 struct evhttp_request *req;
3721 if ((req = evhttp_request_new(evhttp_handle_request, http)) == NULL)
3722 return (-1);
3723
3724 if ((req->remote_host = mm_strdup(evcon->address)) == NULL) {
3725 event_warn("%s: strdup", __func__);
3726 evhttp_request_free(req);
3727 return (-1);
3728 }
3729 req->remote_port = evcon->port;
3730
3731 req->evcon = evcon; /* the request ends up owning the connection */
3732 req->flags |= EVHTTP_REQ_OWN_CONNECTION;
3733
3734 /* We did not present the request to the user user yet, so treat it as
3735 * if the user was done with the request. This allows us to free the
3736 * request on a persistent connection if the client drops it without
3737 * sending a request.
3738 */
3739 req->userdone = 1;
3740
3741 TAILQ_INSERT_TAIL(&evcon->requests, req, next);
3742
3743 req->kind = EVHTTP_REQUEST;
3744
3745
3746 evhttp_start_read(evcon);
3747
3748 return (0);
3749 }
3750
3751 static void
3752 evhttp_get_request(struct evhttp *http, evutil_socket_t fd,
3753 struct sockaddr *sa, ev_socklen_t salen)
3754 {
3755 struct evhttp_connection *evcon;
3756
3757 evcon = evhttp_get_request_connection(http, fd, sa, salen);
3758 if (evcon == NULL) {
3759 event_sock_warn(fd, "%s: cannot get connection on "EV_SOCK_FMT,
3760 __func__, EV_SOCK_ARG(fd));
3761 evutil_closesocket(fd);
3762 return;
3763 }
3764
3765 /* the timeout can be used by the server to close idle connections */
3766 if (http->timeout != -1)
3767 evhttp_connection_set_timeout(evcon, http->timeout);
3768
3769 /*
3770 * if we want to accept more than one request on a connection,
3771 * we need to know which http server it belongs to.
3772 */
3773 evcon->http_server = http;
3774 TAILQ_INSERT_TAIL(&http->connections, evcon, next);
3775
3776 if (evhttp_associate_new_request_with_connection(evcon) == -1)
3777 evhttp_connection_free(evcon);
3778 }
3779
3780
3781 /*
3782 * Network helper functions that we do not want to export to the rest of
3783 * the world.
3784 */
3785
3786 static void
3787 name_from_addr(struct sockaddr *sa, ev_socklen_t salen,
3788 char **phost, char **pport)
3789 {
3790 char ntop[NI_MAXHOST];
3791 char strport[NI_MAXSERV];
3792 int ni_result;
3793
3794 #ifdef _EVENT_HAVE_GETNAMEINFO
3795 ni_result = getnameinfo(sa, salen,
3796 ntop, sizeof(ntop), strport, sizeof(strport),
3797 NI_NUMERICHOST|NI_NUMERICSERV);
3798
3799 if (ni_result != 0) {
3800 #ifdef EAI_SYSTEM
3801 /* Windows doesn't have an EAI_SYSTEM. */
3802 if (ni_result == EAI_SYSTEM)
3803 event_err(1, "getnameinfo failed");
3804 else
3805 #endif
3806 event_errx(1, "getnameinfo failed: %s", gai_strerror(ni_result));
3807 return;
3808 }
3809 #else
3810 ni_result = fake_getnameinfo(sa, salen,
3811 ntop, sizeof(ntop), strport, sizeof(strport),
3812 NI_NUMERICHOST|NI_NUMERICSERV);
3813 if (ni_result != 0)
3814 return;
3815 #endif
3816
3817 *phost = mm_strdup(ntop);
3818 *pport = mm_strdup(strport);
3819 }
3820
3821 /* Create a non-blocking socket and bind it */
3822 /* todo: rename this function */
3823 static evutil_socket_t
3824 bind_socket_ai(struct evutil_addrinfo *ai, int reuse)
3825 {
3826 evutil_socket_t fd;
3827
3828 int on = 1, r;
3829 int serrno;
3830
3831 /* Create listen socket */
3832 fd = socket(ai ? ai->ai_family : AF_INET, SOCK_STREAM, 0);
3833 if (fd == -1) {
3834 event_sock_warn(-1, "socket");
3835 return (-1);
3836 }
3837
3838 if (evutil_make_socket_nonblocking(fd) < 0)
3839 goto out;
3840 if (evutil_make_socket_closeonexec(fd) < 0)
3841 goto out;
3842
3843 if (setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on))<0)
3844 goto out;
3845 if (reuse) {
3846 if (evutil_make_listen_socket_reuseable(fd) < 0)
3847 goto out;
3848 }
3849
3850 if (ai != NULL) {
3851 r = bind(fd, ai->ai_addr, (ev_socklen_t)ai->ai_addrlen);
3852 if (r == -1)
3853 goto out;
3854 }
3855
3856 return (fd);
3857
3858 out:
3859 serrno = EVUTIL_SOCKET_ERROR();
3860 evutil_closesocket(fd);
3861 EVUTIL_SET_SOCKET_ERROR(serrno);
3862 return (-1);
3863 }
3864
3865 static struct evutil_addrinfo *
3866 make_addrinfo(const char *address, ev_uint16_t port)
3867 {
3868 struct evutil_addrinfo *ai = NULL;
3869
3870 struct evutil_addrinfo hints;
3871 char strport[NI_MAXSERV];
3872 int ai_result;
3873
3874 memset(&hints, 0, sizeof(hints));
3875 hints.ai_family = AF_UNSPEC;
3876 hints.ai_socktype = SOCK_STREAM;
3877 /* turn NULL hostname into INADDR_ANY, and skip looking up any address
3878 * types we don't have an interface to connect to. */
3879 hints.ai_flags = EVUTIL_AI_PASSIVE|EVUTIL_AI_ADDRCONFIG;
3880 evutil_snprintf(strport, sizeof(strport), "%d", port);
3881 if ((ai_result = evutil_getaddrinfo(address, strport, &hints, &ai))
3882 != 0) {
3883 if (ai_result == EVUTIL_EAI_SYSTEM)
3884 event_warn("getaddrinfo");
3885 else
3886 event_warnx("getaddrinfo: %s",
3887 evutil_gai_strerror(ai_result));
3888 return (NULL);
3889 }
3890
3891 return (ai);
3892 }
3893
3894 static evutil_socket_t
3895 bind_socket(const char *address, ev_uint16_t port, int reuse)
3896 {
3897 evutil_socket_t fd;
3898 struct evutil_addrinfo *aitop = NULL;
3899
3900 /* just create an unbound socket */
3901 if (address == NULL && port == 0)
3902 return bind_socket_ai(NULL, 0);
3903
3904 aitop = make_addrinfo(address, port);
3905
3906 if (aitop == NULL)
3907 return (-1);
3908
3909 fd = bind_socket_ai(aitop, reuse);
3910
3911 evutil_freeaddrinfo(aitop);
3912
3913 return (fd);
3914 }
3915
3916 struct evhttp_uri {
3917 unsigned flags;
3918 char *scheme; /* scheme; e.g http, ftp etc */
3919 char *userinfo; /* userinfo (typically username:pass), or NULL */
3920 char *host; /* hostname, IP address, or NULL */
3921 int port; /* port, or zero */
3922 char *path; /* path, or "". */
3923 char *query; /* query, or NULL */
3924 char *fragment; /* fragment or NULL */
3925 };
3926
3927 struct evhttp_uri *
3928 evhttp_uri_new(void)
3929 {
3930 struct evhttp_uri *uri = mm_calloc(sizeof(struct evhttp_uri), 1);
3931 if (uri)
3932 uri->port = -1;
3933 return uri;
3934 }
3935
3936 void
3937 evhttp_uri_set_flags(struct evhttp_uri *uri, unsigned flags)
3938 {
3939 uri->flags = flags;
3940 }
3941
3942 /* Return true if the string starting at s and ending immediately before eos
3943 * is a valid URI scheme according to RFC3986
3944 */
3945 static int
3946 scheme_ok(const char *s, const char *eos)
3947 {
3948 /* scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) */
3949 EVUTIL_ASSERT(eos >= s);
3950 if (s == eos)
3951 return 0;
3952 if (!EVUTIL_ISALPHA(*s))
3953 return 0;
3954 while (++s < eos) {
3955 if (! EVUTIL_ISALNUM(*s) &&
3956 *s != '+' && *s != '-' && *s != '.')
3957 return 0;
3958 }
3959 return 1;
3960 }
3961
3962 #define SUBDELIMS "!$&'()*+,;="
3963
3964 /* Return true iff [s..eos) is a valid userinfo */
3965 static int
3966 userinfo_ok(const char *s, const char *eos)
3967 {
3968 while (s < eos) {
3969 if (CHAR_IS_UNRESERVED(*s) ||
3970 strchr(SUBDELIMS, *s) ||
3971 *s == ':')
3972 ++s;
3973 else if (*s == '%' && s+2 < eos &&
3974 EVUTIL_ISXDIGIT(s[1]) &&
3975 EVUTIL_ISXDIGIT(s[2]))
3976 s += 3;
3977 else
3978 return 0;
3979 }
3980 return 1;
3981 }
3982
3983 static int
3984 regname_ok(const char *s, const char *eos)
3985 {
3986 while (s && s<eos) {
3987 if (CHAR_IS_UNRESERVED(*s) ||
3988 strchr(SUBDELIMS, *s))
3989 ++s;
3990 else if (*s == '%' &&
3991 EVUTIL_ISXDIGIT(s[1]) &&
3992 EVUTIL_ISXDIGIT(s[2]))
3993 s += 3;
3994 else
3995 return 0;
3996 }
3997 return 1;
3998 }
3999
4000 static int
4001 parse_port(const char *s, const char *eos)
4002 {
4003 int portnum = 0;
4004 while (s < eos) {
4005 if (! EVUTIL_ISDIGIT(*s))
4006 return -1;
4007 portnum = (portnum * 10) + (*s - '0');
4008 if (portnum < 0)
4009 return -1;
4010 ++s;
4011 }
4012 return portnum;
4013 }
4014
4015 /* returns 0 for bad, 1 for ipv6, 2 for IPvFuture */
4016 static int
4017 bracket_addr_ok(const char *s, const char *eos)
4018 {
4019 if (s + 3 > eos || *s != '[' || *(eos-1) != ']')
4020 return 0;
4021 if (s[1] == 'v') {
4022 /* IPvFuture, or junk.
4023 "v" 1*HEXDIG "." 1*( unreserved / sub-delims / ":" )
4024 */
4025 s += 2; /* skip [v */
4026 --eos;
4027 if (!EVUTIL_ISXDIGIT(*s)) /*require at least one*/
4028 return 0;
4029 while (s < eos && *s != '.') {
4030 if (EVUTIL_ISXDIGIT(*s))
4031 ++s;
4032 else
4033 return 0;
4034 }
4035 if (*s != '.')
4036 return 0;
4037 ++s;
4038 while (s < eos) {
4039 if (CHAR_IS_UNRESERVED(*s) ||
4040 strchr(SUBDELIMS, *s) ||
4041 *s == ':')
4042 ++s;
4043 else
4044 return 0;
4045 }
4046 return 2;
4047 } else {
4048 /* IPv6, or junk */
4049 char buf[64];
4050 ev_ssize_t n_chars = eos-s-2;
4051 struct in6_addr in6;
4052 if (n_chars >= 64) /* way too long */
4053 return 0;
4054 memcpy(buf, s+1, n_chars);
4055 buf[n_chars]='\0';
4056 return (evutil_inet_pton(AF_INET6,buf,&in6)==1) ? 1 : 0;
4057 }
4058 }
4059
4060 static int
4061 parse_authority(struct evhttp_uri *uri, char *s, char *eos)
4062 {
4063 char *cp, *port;
4064 EVUTIL_ASSERT(eos);
4065 if (eos == s) {
4066 uri->host = mm_strdup("");
4067 if (uri->host == NULL) {
4068 event_warn("%s: strdup", __func__);
4069 return -1;
4070 }
4071 return 0;
4072 }
4073
4074 /* Optionally, we start with "userinfo@" */
4075
4076 cp = strchr(s, '@');
4077 if (cp && cp < eos) {
4078 if (! userinfo_ok(s,cp))
4079 return -1;
4080 *cp++ = '\0';
4081 uri->userinfo = mm_strdup(s);
4082 if (uri->userinfo == NULL) {
4083 event_warn("%s: strdup", __func__);
4084 return -1;
4085 }
4086 } else {
4087 cp = s;
4088 }
4089 /* Optionally, we end with ":port" */
4090 for (port=eos-1; port >= cp && EVUTIL_ISDIGIT(*port); --port)
4091 ;
4092 if (port >= cp && *port == ':') {
4093 if (port+1 == eos) /* Leave port unspecified; the RFC allows a
4094 * nil port */
4095 uri->port = -1;
4096 else if ((uri->port = parse_port(port+1, eos))<0)
4097 return -1;
4098 eos = port;
4099 }
4100 /* Now, cp..eos holds the "host" port, which can be an IPv4Address,
4101 * an IP-Literal, or a reg-name */
4102 EVUTIL_ASSERT(eos >= cp);
4103 if (*cp == '[' && eos >= cp+2 && *(eos-1) == ']') {
4104 /* IPv6address, IP-Literal, or junk. */
4105 if (! bracket_addr_ok(cp, eos))
4106 return -1;
4107 } else {
4108 /* Make sure the host part is ok. */
4109 if (! regname_ok(cp,eos)) /* Match IPv4Address or reg-name */
4110 return -1;
4111 }
4112 uri->host = mm_malloc(eos-cp+1);
4113 if (uri->host == NULL) {
4114 event_warn("%s: malloc", __func__);
4115 return -1;
4116 }
4117 memcpy(uri->host, cp, eos-cp);
4118 uri->host[eos-cp] = '\0';
4119 return 0;
4120
4121 }
4122
4123 static char *
4124 end_of_authority(char *cp)
4125 {
4126 while (*cp) {
4127 if (*cp == '?' || *cp == '#' || *cp == '/')
4128 return cp;
4129 ++cp;
4130 }
4131 return cp;
4132 }
4133
4134 enum uri_part {
4135 PART_PATH,
4136 PART_QUERY,
4137 PART_FRAGMENT
4138 };
4139
4140 /* Return the character after the longest prefix of 'cp' that matches...
4141 * *pchar / "/" if allow_qchars is false, or
4142 * *(pchar / "/" / "?") if allow_qchars is true.
4143 */
4144 static char *
4145 end_of_path(const char *cp, enum uri_part part, unsigned flags)
4146 {
4147 if (flags & EVHTTP_URI_NONCONFORMANT) {
4148 /* If NONCONFORMANT:
4149 * Path is everything up to a # or ? or nul.
4150 * Query is everything up a # or nul
4151 * Fragment is everything up to a nul.
4152 */
4153 switch (part) {
4154 case PART_PATH:
4155 while (*cp && *cp != '#' && *cp != '?')
4156 ++cp;
4157 break;
4158 case PART_QUERY:
4159 while (*cp && *cp != '#')
4160 ++cp;
4161 break;
4162 case PART_FRAGMENT:
4163 cp += strlen(cp);
4164 break;
4165 };
4166 return __UNCONST(cp);
4167 }
4168
4169 while (*cp) {
4170 if (CHAR_IS_UNRESERVED(*cp) ||
4171 strchr(SUBDELIMS, *cp) ||
4172 *cp == ':' || *cp == '@' || *cp == '/')
4173 ++cp;
4174 else if (*cp == '%' && EVUTIL_ISXDIGIT(cp[1]) &&
4175 EVUTIL_ISXDIGIT(cp[2]))
4176 cp += 3;
4177 else if (*cp == '?' && part != PART_PATH)
4178 ++cp;
4179 else
4180 return __UNCONST(cp);
4181 }
4182 return __UNCONST(cp);
4183 }
4184
4185 static int
4186 path_matches_noscheme(const char *cp)
4187 {
4188 while (*cp) {
4189 if (*cp == ':')
4190 return 0;
4191 else if (*cp == '/')
4192 return 1;
4193 ++cp;
4194 }
4195 return 1;
4196 }
4197
4198 struct evhttp_uri *
4199 evhttp_uri_parse(const char *source_uri)
4200 {
4201 return evhttp_uri_parse_with_flags(source_uri, 0);
4202 }
4203
4204 struct evhttp_uri *
4205 evhttp_uri_parse_with_flags(const char *source_uri, unsigned flags)
4206 {
4207 char *readbuf = NULL, *readp = NULL, *token = NULL, *query = NULL;
4208 char *path = NULL, *fragment = NULL;
4209 int got_authority = 0;
4210
4211 struct evhttp_uri *uri = mm_calloc(1, sizeof(struct evhttp_uri));
4212 if (uri == NULL) {
4213 event_warn("%s: calloc", __func__);
4214 goto err;
4215 }
4216 uri->port = -1;
4217 uri->flags = flags;
4218
4219 readbuf = mm_strdup(source_uri);
4220 if (readbuf == NULL) {
4221 event_warn("%s: strdup", __func__);
4222 goto err;
4223 }
4224
4225 readp = readbuf;
4226 token = NULL;
4227
4228 /* We try to follow RFC3986 here as much as we can, and match
4229 the productions
4230
4231 URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
4232
4233 relative-ref = relative-part [ "?" query ] [ "#" fragment ]
4234 */
4235
4236 /* 1. scheme: */
4237 token = strchr(readp, ':');
4238 if (token && scheme_ok(readp,token)) {
4239 *token = '\0';
4240 uri->scheme = mm_strdup(readp);
4241 if (uri->scheme == NULL) {
4242 event_warn("%s: strdup", __func__);
4243 goto err;
4244 }
4245 readp = token+1; /* eat : */
4246 }
4247
4248 /* 2. Optionally, "//" then an 'authority' part. */
4249 if (readp[0]=='/' && readp[1] == '/') {
4250 char *authority;
4251 readp += 2;
4252 authority = readp;
4253 path = end_of_authority(readp);
4254 if (parse_authority(uri, authority, path) < 0)
4255 goto err;
4256 readp = path;
4257 got_authority = 1;
4258 }
4259
4260 /* 3. Query: path-abempty, path-absolute, path-rootless, or path-empty
4261 */
4262 path = readp;
4263 readp = end_of_path(path, PART_PATH, flags);
4264
4265 /* Query */
4266 if (*readp == '?') {
4267 *readp = '\0';
4268 ++readp;
4269 query = readp;
4270 readp = end_of_path(readp, PART_QUERY, flags);
4271 }
4272 /* fragment */
4273 if (*readp == '#') {
4274 *readp = '\0';
4275 ++readp;
4276 fragment = readp;
4277 readp = end_of_path(readp, PART_FRAGMENT, flags);
4278 }
4279 if (*readp != '\0') {
4280 goto err;
4281 }
4282
4283 /* These next two cases may be unreachable; I'm leaving them
4284 * in to be defensive. */
4285 /* If you didn't get an authority, the path can't begin with "//" */
4286 if (!got_authority && path[0]=='/' && path[1]=='/')
4287 goto err;
4288 /* If you did get an authority, the path must begin with "/" or be
4289 * empty. */
4290 if (got_authority && path[0] != '/' && path[0] != '\0')
4291 goto err;
4292 /* (End of maybe-unreachable cases) */
4293
4294 /* If there was no scheme, the first part of the path (if any) must
4295 * have no colon in it. */
4296 if (! uri->scheme && !path_matches_noscheme(path))
4297 goto err;
4298
4299 EVUTIL_ASSERT(path);
4300 uri->path = mm_strdup(path);
4301 if (uri->path == NULL) {
4302 event_warn("%s: strdup", __func__);
4303 goto err;
4304 }
4305
4306 if (query) {
4307 uri->query = mm_strdup(query);
4308 if (uri->query == NULL) {
4309 event_warn("%s: strdup", __func__);
4310 goto err;
4311 }
4312 }
4313 if (fragment) {
4314 uri->fragment = mm_strdup(fragment);
4315 if (uri->fragment == NULL) {
4316 event_warn("%s: strdup", __func__);
4317 goto err;
4318 }
4319 }
4320
4321 mm_free(readbuf);
4322
4323 return uri;
4324 err:
4325 if (uri)
4326 evhttp_uri_free(uri);
4327 if (readbuf)
4328 mm_free(readbuf);
4329 return NULL;
4330 }
4331
4332 void
4333 evhttp_uri_free(struct evhttp_uri *uri)
4334 {
4335 #define _URI_FREE_STR(f) \
4336 if (uri->f) { \
4337 mm_free(uri->f); \
4338 }
4339
4340 _URI_FREE_STR(scheme);
4341 _URI_FREE_STR(userinfo);
4342 _URI_FREE_STR(host);
4343 _URI_FREE_STR(path);
4344 _URI_FREE_STR(query);
4345 _URI_FREE_STR(fragment);
4346
4347 mm_free(uri);
4348 #undef _URI_FREE_STR
4349 }
4350
4351 char *
4352 evhttp_uri_join(struct evhttp_uri *uri, char *buf, size_t limit)
4353 {
4354 struct evbuffer *tmp = 0;
4355 size_t joined_size = 0;
4356 char *output = NULL;
4357
4358 #define _URI_ADD(f) evbuffer_add(tmp, uri->f, strlen(uri->f))
4359
4360 if (!uri || !buf || !limit)
4361 return NULL;
4362
4363 tmp = evbuffer_new();
4364 if (!tmp)
4365 return NULL;
4366
4367 if (uri->scheme) {
4368 _URI_ADD(scheme);
4369 evbuffer_add(tmp, ":", 1);
4370 }
4371 if (uri->host) {
4372 evbuffer_add(tmp, "//", 2);
4373 if (uri->userinfo)
4374 evbuffer_add_printf(tmp,"%s@", uri->userinfo);
4375 _URI_ADD(host);
4376 if (uri->port >= 0)
4377 evbuffer_add_printf(tmp,":%d", uri->port);
4378
4379 if (uri->path && uri->path[0] != '/' && uri->path[0] != '\0')
4380 goto err;
4381 }
4382
4383 if (uri->path)
4384 _URI_ADD(path);
4385
4386 if (uri->query) {
4387 evbuffer_add(tmp, "?", 1);
4388 _URI_ADD(query);
4389 }
4390
4391 if (uri->fragment) {
4392 evbuffer_add(tmp, "#", 1);
4393 _URI_ADD(fragment);
4394 }
4395
4396 evbuffer_add(tmp, "\0", 1); /* NUL */
4397
4398 joined_size = evbuffer_get_length(tmp);
4399
4400 if (joined_size > limit) {
4401 /* It doesn't fit. */
4402 evbuffer_free(tmp);
4403 return NULL;
4404 }
4405 evbuffer_remove(tmp, buf, joined_size);
4406
4407 output = buf;
4408 err:
4409 evbuffer_free(tmp);
4410
4411 return output;
4412 #undef _URI_ADD
4413 }
4414
4415 const char *
4416 evhttp_uri_get_scheme(const struct evhttp_uri *uri)
4417 {
4418 return uri->scheme;
4419 }
4420 const char *
4421 evhttp_uri_get_userinfo(const struct evhttp_uri *uri)
4422 {
4423 return uri->userinfo;
4424 }
4425 const char *
4426 evhttp_uri_get_host(const struct evhttp_uri *uri)
4427 {
4428 return uri->host;
4429 }
4430 int
4431 evhttp_uri_get_port(const struct evhttp_uri *uri)
4432 {
4433 return uri->port;
4434 }
4435 const char *
4436 evhttp_uri_get_path(const struct evhttp_uri *uri)
4437 {
4438 return uri->path;
4439 }
4440 const char *
4441 evhttp_uri_get_query(const struct evhttp_uri *uri)
4442 {
4443 return uri->query;
4444 }
4445 const char *
4446 evhttp_uri_get_fragment(const struct evhttp_uri *uri)
4447 {
4448 return uri->fragment;
4449 }
4450
4451 #define _URI_SET_STR(f) do { \
4452 if (uri->f) \
4453 mm_free(uri->f); \
4454 if (f) { \
4455 if ((uri->f = mm_strdup(f)) == NULL) { \
4456 event_warn("%s: strdup()", __func__); \
4457 return -1; \
4458 } \
4459 } else { \
4460 uri->f = NULL; \
4461 } \
4462 } while(0)
4463
4464 int
4465 evhttp_uri_set_scheme(struct evhttp_uri *uri, const char *scheme)
4466 {
4467 if (scheme && !scheme_ok(scheme, scheme+strlen(scheme)))
4468 return -1;
4469
4470 _URI_SET_STR(scheme);
4471 return 0;
4472 }
4473 int
4474 evhttp_uri_set_userinfo(struct evhttp_uri *uri, const char *userinfo)
4475 {
4476 if (userinfo && !userinfo_ok(userinfo, userinfo+strlen(userinfo)))
4477 return -1;
4478 _URI_SET_STR(userinfo);
4479 return 0;
4480 }
4481 int
4482 evhttp_uri_set_host(struct evhttp_uri *uri, const char *host)
4483 {
4484 if (host) {
4485 if (host[0] == '[') {
4486 if (! bracket_addr_ok(host, host+strlen(host)))
4487 return -1;
4488 } else {
4489 if (! regname_ok(host, host+strlen(host)))
4490 return -1;
4491 }
4492 }
4493
4494 _URI_SET_STR(host);
4495 return 0;
4496 }
4497 int
4498 evhttp_uri_set_port(struct evhttp_uri *uri, int port)
4499 {
4500 if (port < -1)
4501 return -1;
4502 uri->port = port;
4503 return 0;
4504 }
4505 #define end_of_cpath(cp,p,f) \
4506 ((const char*)(end_of_path(((const char*)(cp)), (p), (f))))
4507
4508 int
4509 evhttp_uri_set_path(struct evhttp_uri *uri, const char *path)
4510 {
4511 if (path && end_of_cpath(path, PART_PATH, uri->flags) != path+strlen(path))
4512 return -1;
4513
4514 _URI_SET_STR(path);
4515 return 0;
4516 }
4517 int
4518 evhttp_uri_set_query(struct evhttp_uri *uri, const char *query)
4519 {
4520 if (query && end_of_cpath(query, PART_QUERY, uri->flags) != query+strlen(query))
4521 return -1;
4522 _URI_SET_STR(query);
4523 return 0;
4524 }
4525 int
4526 evhttp_uri_set_fragment(struct evhttp_uri *uri, const char *fragment)
4527 {
4528 if (fragment && end_of_cpath(fragment, PART_FRAGMENT, uri->flags) != fragment+strlen(fragment))
4529 return -1;
4530 _URI_SET_STR(fragment);
4531 return 0;
4532 }
MINIX 3 (repo.or.cz mirror)