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