Annotation of embedaddon/libevent/http.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 2002-2006 Niels Provos <provos@citi.umich.edu>
! 3: * All rights reserved.
! 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: #ifdef HAVE_CONFIG_H
! 29: #include "config.h"
! 30: #endif
! 31:
! 32: #ifdef HAVE_SYS_PARAM_H
! 33: #include <sys/param.h>
! 34: #endif
! 35: #ifdef HAVE_SYS_TYPES_H
! 36: #include <sys/types.h>
! 37: #endif
! 38:
! 39: #ifdef HAVE_SYS_TIME_H
! 40: #include <sys/time.h>
! 41: #endif
! 42: #ifdef HAVE_SYS_IOCCOM_H
! 43: #include <sys/ioccom.h>
! 44: #endif
! 45:
! 46: #ifndef WIN32
! 47: #include <sys/resource.h>
! 48: #include <sys/socket.h>
! 49: #include <sys/stat.h>
! 50: #include <sys/wait.h>
! 51: #endif
! 52:
! 53: #include <sys/queue.h>
! 54:
! 55: #ifndef WIN32
! 56: #include <netinet/in.h>
! 57: #include <netdb.h>
! 58: #endif
! 59:
! 60: #ifdef WIN32
! 61: #include <winsock2.h>
! 62: #endif
! 63:
! 64: #include <assert.h>
! 65: #include <ctype.h>
! 66: #include <errno.h>
! 67: #include <stdio.h>
! 68: #include <stdlib.h>
! 69: #include <string.h>
! 70: #ifndef WIN32
! 71: #include <syslog.h>
! 72: #endif
! 73: #include <signal.h>
! 74: #include <time.h>
! 75: #ifdef HAVE_UNISTD_H
! 76: #include <unistd.h>
! 77: #endif
! 78: #ifdef HAVE_FCNTL_H
! 79: #include <fcntl.h>
! 80: #endif
! 81:
! 82: #undef timeout_pending
! 83: #undef timeout_initialized
! 84:
! 85: #include "strlcpy-internal.h"
! 86: #include "event.h"
! 87: #include "evhttp.h"
! 88: #include "evutil.h"
! 89: #include "log.h"
! 90: #include "http-internal.h"
! 91:
! 92: #ifdef WIN32
! 93: #define strcasecmp _stricmp
! 94: #define strncasecmp _strnicmp
! 95: #define strdup _strdup
! 96: #endif
! 97:
! 98: #ifndef HAVE_GETNAMEINFO
! 99: #define NI_MAXSERV 32
! 100: #define NI_MAXHOST 1025
! 101:
! 102: #define NI_NUMERICHOST 1
! 103: #define NI_NUMERICSERV 2
! 104:
! 105: static int
! 106: fake_getnameinfo(const struct sockaddr *sa, size_t salen, char *host,
! 107: size_t hostlen, char *serv, size_t servlen, int flags)
! 108: {
! 109: struct sockaddr_in *sin = (struct sockaddr_in *)sa;
! 110:
! 111: if (serv != NULL) {
! 112: char tmpserv[16];
! 113: evutil_snprintf(tmpserv, sizeof(tmpserv),
! 114: "%d", ntohs(sin->sin_port));
! 115: if (strlcpy(serv, tmpserv, servlen) >= servlen)
! 116: return (-1);
! 117: }
! 118:
! 119: if (host != NULL) {
! 120: if (flags & NI_NUMERICHOST) {
! 121: if (strlcpy(host, inet_ntoa(sin->sin_addr),
! 122: hostlen) >= hostlen)
! 123: return (-1);
! 124: else
! 125: return (0);
! 126: } else {
! 127: struct hostent *hp;
! 128: hp = gethostbyaddr((char *)&sin->sin_addr,
! 129: sizeof(struct in_addr), AF_INET);
! 130: if (hp == NULL)
! 131: return (-2);
! 132:
! 133: if (strlcpy(host, hp->h_name, hostlen) >= hostlen)
! 134: return (-1);
! 135: else
! 136: return (0);
! 137: }
! 138: }
! 139: return (0);
! 140: }
! 141:
! 142: #endif
! 143:
! 144: #ifndef HAVE_GETADDRINFO
! 145: struct addrinfo {
! 146: int ai_family;
! 147: int ai_socktype;
! 148: int ai_protocol;
! 149: size_t ai_addrlen;
! 150: struct sockaddr *ai_addr;
! 151: struct addrinfo *ai_next;
! 152: };
! 153: static int
! 154: fake_getaddrinfo(const char *hostname, struct addrinfo *ai)
! 155: {
! 156: struct hostent *he = NULL;
! 157: struct sockaddr_in *sa;
! 158: if (hostname) {
! 159: he = gethostbyname(hostname);
! 160: if (!he)
! 161: return (-1);
! 162: }
! 163: ai->ai_family = he ? he->h_addrtype : AF_INET;
! 164: ai->ai_socktype = SOCK_STREAM;
! 165: ai->ai_protocol = 0;
! 166: ai->ai_addrlen = sizeof(struct sockaddr_in);
! 167: if (NULL == (ai->ai_addr = malloc(ai->ai_addrlen)))
! 168: return (-1);
! 169: sa = (struct sockaddr_in*)ai->ai_addr;
! 170: memset(sa, 0, ai->ai_addrlen);
! 171: if (he) {
! 172: sa->sin_family = he->h_addrtype;
! 173: memcpy(&sa->sin_addr, he->h_addr_list[0], he->h_length);
! 174: } else {
! 175: sa->sin_family = AF_INET;
! 176: sa->sin_addr.s_addr = INADDR_ANY;
! 177: }
! 178: ai->ai_next = NULL;
! 179: return (0);
! 180: }
! 181: static void
! 182: fake_freeaddrinfo(struct addrinfo *ai)
! 183: {
! 184: free(ai->ai_addr);
! 185: }
! 186: #endif
! 187:
! 188: #ifndef MIN
! 189: #define MIN(a,b) (((a)<(b))?(a):(b))
! 190: #endif
! 191:
! 192: /* wrapper for setting the base from the http server */
! 193: #define EVHTTP_BASE_SET(x, y) do { \
! 194: if ((x)->base != NULL) event_base_set((x)->base, y); \
! 195: } while (0)
! 196:
! 197: extern int debug;
! 198:
! 199: static int socket_connect(int fd, const char *address, unsigned short port);
! 200: static int bind_socket_ai(struct addrinfo *, int reuse);
! 201: static int bind_socket(const char *, u_short, int reuse);
! 202: static void name_from_addr(struct sockaddr *, socklen_t, char **, char **);
! 203: static int evhttp_associate_new_request_with_connection(
! 204: struct evhttp_connection *evcon);
! 205: static void evhttp_connection_start_detectclose(
! 206: struct evhttp_connection *evcon);
! 207: static void evhttp_connection_stop_detectclose(
! 208: struct evhttp_connection *evcon);
! 209: static void evhttp_request_dispatch(struct evhttp_connection* evcon);
! 210: static void evhttp_read_firstline(struct evhttp_connection *evcon,
! 211: struct evhttp_request *req);
! 212: static void evhttp_read_header(struct evhttp_connection *evcon,
! 213: struct evhttp_request *req);
! 214: static int evhttp_add_header_internal(struct evkeyvalq *headers,
! 215: const char *key, const char *value);
! 216: static int evhttp_decode_uri_internal(const char *uri, size_t length,
! 217: char *ret, int always_decode_plus);
! 218:
! 219: void evhttp_read(int, short, void *);
! 220: void evhttp_write(int, short, void *);
! 221:
! 222: #ifndef HAVE_STRSEP
! 223: /* strsep replacement for platforms that lack it. Only works if
! 224: * del is one character long. */
! 225: static char *
! 226: strsep(char **s, const char *del)
! 227: {
! 228: char *d, *tok;
! 229: assert(strlen(del) == 1);
! 230: if (!s || !*s)
! 231: return NULL;
! 232: tok = *s;
! 233: d = strstr(tok, del);
! 234: if (d) {
! 235: *d = '\0';
! 236: *s = d + 1;
! 237: } else
! 238: *s = NULL;
! 239: return tok;
! 240: }
! 241: #endif
! 242:
! 243: static const char *
! 244: html_replace(char ch, char *buf)
! 245: {
! 246: switch (ch) {
! 247: case '<':
! 248: return "<";
! 249: case '>':
! 250: return ">";
! 251: case '"':
! 252: return """;
! 253: case '\'':
! 254: return "'";
! 255: case '&':
! 256: return "&";
! 257: default:
! 258: break;
! 259: }
! 260:
! 261: /* Echo the character back */
! 262: buf[0] = ch;
! 263: buf[1] = '\0';
! 264:
! 265: return buf;
! 266: }
! 267:
! 268: /*
! 269: * Replaces <, >, ", ' and & with <, >, ",
! 270: * ' and & correspondingly.
! 271: *
! 272: * The returned string needs to be freed by the caller.
! 273: */
! 274:
! 275: char *
! 276: evhttp_htmlescape(const char *html)
! 277: {
! 278: int i, new_size = 0, old_size = strlen(html);
! 279: char *escaped_html, *p;
! 280: char scratch_space[2];
! 281:
! 282: for (i = 0; i < old_size; ++i)
! 283: new_size += strlen(html_replace(html[i], scratch_space));
! 284:
! 285: p = escaped_html = malloc(new_size + 1);
! 286: if (escaped_html == NULL)
! 287: event_err(1, "%s: malloc(%d)", __func__, new_size + 1);
! 288: for (i = 0; i < old_size; ++i) {
! 289: const char *replaced = html_replace(html[i], scratch_space);
! 290: /* this is length checked */
! 291: strcpy(p, replaced);
! 292: p += strlen(replaced);
! 293: }
! 294:
! 295: *p = '\0';
! 296:
! 297: return (escaped_html);
! 298: }
! 299:
! 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: default:
! 316: method = NULL;
! 317: break;
! 318: }
! 319:
! 320: return (method);
! 321: }
! 322:
! 323: static void
! 324: evhttp_add_event(struct event *ev, int timeout, int default_timeout)
! 325: {
! 326: if (timeout != 0) {
! 327: struct timeval tv;
! 328:
! 329: evutil_timerclear(&tv);
! 330: tv.tv_sec = timeout != -1 ? timeout : default_timeout;
! 331: event_add(ev, &tv);
! 332: } else {
! 333: event_add(ev, NULL);
! 334: }
! 335: }
! 336:
! 337: void
! 338: evhttp_write_buffer(struct evhttp_connection *evcon,
! 339: void (*cb)(struct evhttp_connection *, void *), void *arg)
! 340: {
! 341: event_debug(("%s: preparing to write buffer\n", __func__));
! 342:
! 343: /* Set call back */
! 344: evcon->cb = cb;
! 345: evcon->cb_arg = arg;
! 346:
! 347: /* check if the event is already pending */
! 348: if (event_pending(&evcon->ev, EV_WRITE|EV_TIMEOUT, NULL))
! 349: event_del(&evcon->ev);
! 350:
! 351: event_set(&evcon->ev, evcon->fd, EV_WRITE, evhttp_write, evcon);
! 352: EVHTTP_BASE_SET(evcon, &evcon->ev);
! 353: evhttp_add_event(&evcon->ev, evcon->timeout, HTTP_WRITE_TIMEOUT);
! 354: }
! 355:
! 356: static int
! 357: evhttp_connected(struct evhttp_connection *evcon)
! 358: {
! 359: switch (evcon->state) {
! 360: case EVCON_DISCONNECTED:
! 361: case EVCON_CONNECTING:
! 362: return (0);
! 363: case EVCON_IDLE:
! 364: case EVCON_READING_FIRSTLINE:
! 365: case EVCON_READING_HEADERS:
! 366: case EVCON_READING_BODY:
! 367: case EVCON_READING_TRAILER:
! 368: case EVCON_WRITING:
! 369: default:
! 370: return (1);
! 371: }
! 372: }
! 373:
! 374: /*
! 375: * Create the headers needed for an HTTP request
! 376: */
! 377: static void
! 378: evhttp_make_header_request(struct evhttp_connection *evcon,
! 379: struct evhttp_request *req)
! 380: {
! 381: const char *method;
! 382:
! 383: evhttp_remove_header(req->output_headers, "Proxy-Connection");
! 384:
! 385: /* Generate request line */
! 386: method = evhttp_method(req->type);
! 387: evbuffer_add_printf(evcon->output_buffer, "%s %s HTTP/%d.%d\r\n",
! 388: method, req->uri, req->major, req->minor);
! 389:
! 390: /* Add the content length on a post request if missing */
! 391: if (req->type == EVHTTP_REQ_POST &&
! 392: evhttp_find_header(req->output_headers, "Content-Length") == NULL){
! 393: char size[12];
! 394: evutil_snprintf(size, sizeof(size), "%ld",
! 395: (long)EVBUFFER_LENGTH(req->output_buffer));
! 396: evhttp_add_header(req->output_headers, "Content-Length", size);
! 397: }
! 398: }
! 399:
! 400: static int
! 401: evhttp_is_connection_close(int flags, struct evkeyvalq* headers)
! 402: {
! 403: if (flags & EVHTTP_PROXY_REQUEST) {
! 404: /* proxy connection */
! 405: const char *connection = evhttp_find_header(headers, "Proxy-Connection");
! 406: return (connection == NULL || strcasecmp(connection, "keep-alive") != 0);
! 407: } else {
! 408: const char *connection = evhttp_find_header(headers, "Connection");
! 409: return (connection != NULL && strcasecmp(connection, "close") == 0);
! 410: }
! 411: }
! 412:
! 413: static int
! 414: evhttp_is_connection_keepalive(struct evkeyvalq* headers)
! 415: {
! 416: const char *connection = evhttp_find_header(headers, "Connection");
! 417: return (connection != NULL
! 418: && strncasecmp(connection, "keep-alive", 10) == 0);
! 419: }
! 420:
! 421: static void
! 422: evhttp_maybe_add_date_header(struct evkeyvalq *headers)
! 423: {
! 424: if (evhttp_find_header(headers, "Date") == NULL) {
! 425: char date[50];
! 426: #ifndef WIN32
! 427: struct tm cur;
! 428: #endif
! 429: struct tm *cur_p;
! 430: time_t t = time(NULL);
! 431: #ifdef WIN32
! 432: cur_p = gmtime(&t);
! 433: #else
! 434: gmtime_r(&t, &cur);
! 435: cur_p = &cur;
! 436: #endif
! 437: if (strftime(date, sizeof(date),
! 438: "%a, %d %b %Y %H:%M:%S GMT", cur_p) != 0) {
! 439: evhttp_add_header(headers, "Date", date);
! 440: }
! 441: }
! 442: }
! 443:
! 444: static void
! 445: evhttp_maybe_add_content_length_header(struct evkeyvalq *headers,
! 446: long content_length)
! 447: {
! 448: if (evhttp_find_header(headers, "Transfer-Encoding") == NULL &&
! 449: evhttp_find_header(headers, "Content-Length") == NULL) {
! 450: char len[12];
! 451: evutil_snprintf(len, sizeof(len), "%ld", content_length);
! 452: evhttp_add_header(headers, "Content-Length", len);
! 453: }
! 454: }
! 455:
! 456: /*
! 457: * Create the headers needed for an HTTP reply
! 458: */
! 459:
! 460: static void
! 461: evhttp_make_header_response(struct evhttp_connection *evcon,
! 462: struct evhttp_request *req)
! 463: {
! 464: int is_keepalive = evhttp_is_connection_keepalive(req->input_headers);
! 465: evbuffer_add_printf(evcon->output_buffer, "HTTP/%d.%d %d %s\r\n",
! 466: req->major, req->minor, req->response_code,
! 467: req->response_code_line);
! 468:
! 469: if (req->major == 1) {
! 470: if (req->minor == 1)
! 471: evhttp_maybe_add_date_header(req->output_headers);
! 472:
! 473: /*
! 474: * if the protocol is 1.0; and the connection was keep-alive
! 475: * we need to add a keep-alive header, too.
! 476: */
! 477: if (req->minor == 0 && is_keepalive)
! 478: evhttp_add_header(req->output_headers,
! 479: "Connection", "keep-alive");
! 480:
! 481: if (req->minor == 1 || is_keepalive) {
! 482: /*
! 483: * we need to add the content length if the
! 484: * user did not give it, this is required for
! 485: * persistent connections to work.
! 486: */
! 487: evhttp_maybe_add_content_length_header(
! 488: req->output_headers,
! 489: (long)EVBUFFER_LENGTH(req->output_buffer));
! 490: }
! 491: }
! 492:
! 493: /* Potentially add headers for unidentified content. */
! 494: if (EVBUFFER_LENGTH(req->output_buffer)) {
! 495: if (evhttp_find_header(req->output_headers,
! 496: "Content-Type") == NULL) {
! 497: evhttp_add_header(req->output_headers,
! 498: "Content-Type", "text/html; charset=ISO-8859-1");
! 499: }
! 500: }
! 501:
! 502: /* if the request asked for a close, we send a close, too */
! 503: if (evhttp_is_connection_close(req->flags, req->input_headers)) {
! 504: evhttp_remove_header(req->output_headers, "Connection");
! 505: if (!(req->flags & EVHTTP_PROXY_REQUEST))
! 506: evhttp_add_header(req->output_headers, "Connection", "close");
! 507: evhttp_remove_header(req->output_headers, "Proxy-Connection");
! 508: }
! 509: }
! 510:
! 511: void
! 512: evhttp_make_header(struct evhttp_connection *evcon, struct evhttp_request *req)
! 513: {
! 514: struct evkeyval *header;
! 515:
! 516: /*
! 517: * Depending if this is a HTTP request or response, we might need to
! 518: * add some new headers or remove existing headers.
! 519: */
! 520: if (req->kind == EVHTTP_REQUEST) {
! 521: evhttp_make_header_request(evcon, req);
! 522: } else {
! 523: evhttp_make_header_response(evcon, req);
! 524: }
! 525:
! 526: TAILQ_FOREACH(header, req->output_headers, next) {
! 527: evbuffer_add_printf(evcon->output_buffer, "%s: %s\r\n",
! 528: header->key, header->value);
! 529: }
! 530: evbuffer_add(evcon->output_buffer, "\r\n", 2);
! 531:
! 532: if (EVBUFFER_LENGTH(req->output_buffer) > 0) {
! 533: /*
! 534: * For a request, we add the POST data, for a reply, this
! 535: * is the regular data.
! 536: */
! 537: evbuffer_add_buffer(evcon->output_buffer, req->output_buffer);
! 538: }
! 539: }
! 540:
! 541: /* Separated host, port and file from URI */
! 542:
! 543: int
! 544: evhttp_hostportfile(char *url, char **phost, u_short *pport, char **pfile)
! 545: {
! 546: /* XXX not threadsafe. */
! 547: static char host[1024];
! 548: static char file[1024];
! 549: char *p;
! 550: const char *p2;
! 551: int len;
! 552: u_short port;
! 553:
! 554: len = strlen(HTTP_PREFIX);
! 555: if (strncasecmp(url, HTTP_PREFIX, len))
! 556: return (-1);
! 557:
! 558: url += len;
! 559:
! 560: /* We might overrun */
! 561: if (strlcpy(host, url, sizeof (host)) >= sizeof(host))
! 562: return (-1);
! 563:
! 564: p = strchr(host, '/');
! 565: if (p != NULL) {
! 566: *p = '\0';
! 567: p2 = p + 1;
! 568: } else
! 569: p2 = NULL;
! 570:
! 571: if (pfile != NULL) {
! 572: /* Generate request file */
! 573: if (p2 == NULL)
! 574: p2 = "";
! 575: evutil_snprintf(file, sizeof(file), "/%s", p2);
! 576: }
! 577:
! 578: p = strchr(host, ':');
! 579: if (p != NULL) {
! 580: *p = '\0';
! 581: port = atoi(p + 1);
! 582:
! 583: if (port == 0)
! 584: return (-1);
! 585: } else
! 586: port = HTTP_DEFAULTPORT;
! 587:
! 588: if (phost != NULL)
! 589: *phost = host;
! 590: if (pport != NULL)
! 591: *pport = port;
! 592: if (pfile != NULL)
! 593: *pfile = file;
! 594:
! 595: return (0);
! 596: }
! 597:
! 598: static int
! 599: evhttp_connection_incoming_fail(struct evhttp_request *req,
! 600: enum evhttp_connection_error error)
! 601: {
! 602: switch (error) {
! 603: case EVCON_HTTP_TIMEOUT:
! 604: case EVCON_HTTP_EOF:
! 605: /*
! 606: * these are cases in which we probably should just
! 607: * close the connection and not send a reply. this
! 608: * case may happen when a browser keeps a persistent
! 609: * connection open and we timeout on the read. when
! 610: * the request is still being used for sending, we
! 611: * need to disassociated it from the connection here.
! 612: */
! 613: if (!req->userdone) {
! 614: /* remove it so that it will not be freed */
! 615: TAILQ_REMOVE(&req->evcon->requests, req, next);
! 616: /* indicate that this request no longer has a
! 617: * connection object
! 618: */
! 619: req->evcon = NULL;
! 620: }
! 621: return (-1);
! 622: case EVCON_HTTP_INVALID_HEADER:
! 623: default: /* xxx: probably should just error on default */
! 624: /* the callback looks at the uri to determine errors */
! 625: if (req->uri) {
! 626: free(req->uri);
! 627: req->uri = NULL;
! 628: }
! 629:
! 630: /*
! 631: * the callback needs to send a reply, once the reply has
! 632: * been send, the connection should get freed.
! 633: */
! 634: (*req->cb)(req, req->cb_arg);
! 635: }
! 636:
! 637: return (0);
! 638: }
! 639:
! 640: void
! 641: evhttp_connection_fail(struct evhttp_connection *evcon,
! 642: enum evhttp_connection_error error)
! 643: {
! 644: struct evhttp_request* req = TAILQ_FIRST(&evcon->requests);
! 645: void (*cb)(struct evhttp_request *, void *);
! 646: void *cb_arg;
! 647: assert(req != NULL);
! 648:
! 649: if (evcon->flags & EVHTTP_CON_INCOMING) {
! 650: /*
! 651: * for incoming requests, there are two different
! 652: * failure cases. it's either a network level error
! 653: * or an http layer error. for problems on the network
! 654: * layer like timeouts we just drop the connections.
! 655: * For HTTP problems, we might have to send back a
! 656: * reply before the connection can be freed.
! 657: */
! 658: if (evhttp_connection_incoming_fail(req, error) == -1)
! 659: evhttp_connection_free(evcon);
! 660: return;
! 661: }
! 662:
! 663: /* save the callback for later; the cb might free our object */
! 664: cb = req->cb;
! 665: cb_arg = req->cb_arg;
! 666:
! 667: /* do not fail all requests; the next request is going to get
! 668: * send over a new connection. when a user cancels a request,
! 669: * all other pending requests should be processed as normal
! 670: */
! 671: TAILQ_REMOVE(&evcon->requests, req, next);
! 672: evhttp_request_free(req);
! 673:
! 674: /* reset the connection */
! 675: evhttp_connection_reset(evcon);
! 676:
! 677: /* We are trying the next request that was queued on us */
! 678: if (TAILQ_FIRST(&evcon->requests) != NULL)
! 679: evhttp_connection_connect(evcon);
! 680:
! 681: /* inform the user */
! 682: if (cb != NULL)
! 683: (*cb)(NULL, cb_arg);
! 684: }
! 685:
! 686: void
! 687: evhttp_write(int fd, short what, void *arg)
! 688: {
! 689: struct evhttp_connection *evcon = arg;
! 690: int n;
! 691:
! 692: if (what == EV_TIMEOUT) {
! 693: evhttp_connection_fail(evcon, EVCON_HTTP_TIMEOUT);
! 694: return;
! 695: }
! 696:
! 697: n = evbuffer_write(evcon->output_buffer, fd);
! 698: if (n == -1) {
! 699: event_debug(("%s: evbuffer_write", __func__));
! 700: evhttp_connection_fail(evcon, EVCON_HTTP_EOF);
! 701: return;
! 702: }
! 703:
! 704: if (n == 0) {
! 705: event_debug(("%s: write nothing", __func__));
! 706: evhttp_connection_fail(evcon, EVCON_HTTP_EOF);
! 707: return;
! 708: }
! 709:
! 710: if (EVBUFFER_LENGTH(evcon->output_buffer) != 0) {
! 711: evhttp_add_event(&evcon->ev,
! 712: evcon->timeout, HTTP_WRITE_TIMEOUT);
! 713: return;
! 714: }
! 715:
! 716: /* Activate our call back */
! 717: if (evcon->cb != NULL)
! 718: (*evcon->cb)(evcon, evcon->cb_arg);
! 719: }
! 720:
! 721: /**
! 722: * Advance the connection state.
! 723: * - If this is an outgoing connection, we've just processed the response;
! 724: * idle or close the connection.
! 725: * - If this is an incoming connection, we've just processed the request;
! 726: * respond.
! 727: */
! 728: static void
! 729: evhttp_connection_done(struct evhttp_connection *evcon)
! 730: {
! 731: struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
! 732: int con_outgoing = evcon->flags & EVHTTP_CON_OUTGOING;
! 733:
! 734: if (con_outgoing) {
! 735: /* idle or close the connection */
! 736: int need_close;
! 737: TAILQ_REMOVE(&evcon->requests, req, next);
! 738: req->evcon = NULL;
! 739:
! 740: evcon->state = EVCON_IDLE;
! 741:
! 742: need_close =
! 743: evhttp_is_connection_close(req->flags, req->input_headers)||
! 744: evhttp_is_connection_close(req->flags, req->output_headers);
! 745:
! 746: /* check if we got asked to close the connection */
! 747: if (need_close)
! 748: evhttp_connection_reset(evcon);
! 749:
! 750: if (TAILQ_FIRST(&evcon->requests) != NULL) {
! 751: /*
! 752: * We have more requests; reset the connection
! 753: * and deal with the next request.
! 754: */
! 755: if (!evhttp_connected(evcon))
! 756: evhttp_connection_connect(evcon);
! 757: else
! 758: evhttp_request_dispatch(evcon);
! 759: } else if (!need_close) {
! 760: /*
! 761: * The connection is going to be persistent, but we
! 762: * need to detect if the other side closes it.
! 763: */
! 764: evhttp_connection_start_detectclose(evcon);
! 765: }
! 766: } else if (evcon->state != EVCON_DISCONNECTED) {
! 767: /*
! 768: * incoming connection - we need to leave the request on the
! 769: * connection so that we can reply to it.
! 770: */
! 771: evcon->state = EVCON_WRITING;
! 772: }
! 773:
! 774: /* notify the user of the request */
! 775: (*req->cb)(req, req->cb_arg);
! 776:
! 777: /* if this was an outgoing request, we own and it's done. so free it */
! 778: if (con_outgoing) {
! 779: evhttp_request_free(req);
! 780: }
! 781: }
! 782:
! 783: /*
! 784: * Handles reading from a chunked request.
! 785: * return ALL_DATA_READ:
! 786: * all data has been read
! 787: * return MORE_DATA_EXPECTED:
! 788: * more data is expected
! 789: * return DATA_CORRUPTED:
! 790: * data is corrupted
! 791: * return REQUEST_CANCLED:
! 792: * request was canceled by the user calling evhttp_cancel_request
! 793: */
! 794:
! 795: static enum message_read_status
! 796: evhttp_handle_chunked_read(struct evhttp_request *req, struct evbuffer *buf)
! 797: {
! 798: int len;
! 799:
! 800: while ((len = EVBUFFER_LENGTH(buf)) > 0) {
! 801: if (req->ntoread < 0) {
! 802: /* Read chunk size */
! 803: ev_int64_t ntoread;
! 804: char *p = evbuffer_readline(buf);
! 805: char *endp;
! 806: int error;
! 807: if (p == NULL)
! 808: break;
! 809: /* the last chunk is on a new line? */
! 810: if (strlen(p) == 0) {
! 811: free(p);
! 812: continue;
! 813: }
! 814: ntoread = evutil_strtoll(p, &endp, 16);
! 815: error = (*p == '\0' ||
! 816: (*endp != '\0' && *endp != ' ') ||
! 817: ntoread < 0);
! 818: free(p);
! 819: if (error) {
! 820: /* could not get chunk size */
! 821: return (DATA_CORRUPTED);
! 822: }
! 823: req->ntoread = ntoread;
! 824: if (req->ntoread == 0) {
! 825: /* Last chunk */
! 826: return (ALL_DATA_READ);
! 827: }
! 828: continue;
! 829: }
! 830:
! 831: /* don't have enough to complete a chunk; wait for more */
! 832: if (len < req->ntoread)
! 833: return (MORE_DATA_EXPECTED);
! 834:
! 835: /* Completed chunk */
! 836: evbuffer_add(req->input_buffer,
! 837: EVBUFFER_DATA(buf), (size_t)req->ntoread);
! 838: evbuffer_drain(buf, (size_t)req->ntoread);
! 839: req->ntoread = -1;
! 840: if (req->chunk_cb != NULL) {
! 841: (*req->chunk_cb)(req, req->cb_arg);
! 842: evbuffer_drain(req->input_buffer,
! 843: EVBUFFER_LENGTH(req->input_buffer));
! 844: }
! 845: }
! 846:
! 847: return (MORE_DATA_EXPECTED);
! 848: }
! 849:
! 850: static void
! 851: evhttp_read_trailer(struct evhttp_connection *evcon, struct evhttp_request *req)
! 852: {
! 853: struct evbuffer *buf = evcon->input_buffer;
! 854:
! 855: switch (evhttp_parse_headers(req, buf)) {
! 856: case DATA_CORRUPTED:
! 857: evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
! 858: break;
! 859: case ALL_DATA_READ:
! 860: event_del(&evcon->ev);
! 861: evhttp_connection_done(evcon);
! 862: break;
! 863: case MORE_DATA_EXPECTED:
! 864: default:
! 865: evhttp_add_event(&evcon->ev, evcon->timeout,
! 866: HTTP_READ_TIMEOUT);
! 867: break;
! 868: }
! 869: }
! 870:
! 871: static void
! 872: evhttp_read_body(struct evhttp_connection *evcon, struct evhttp_request *req)
! 873: {
! 874: struct evbuffer *buf = evcon->input_buffer;
! 875:
! 876: if (req->chunked) {
! 877: switch (evhttp_handle_chunked_read(req, buf)) {
! 878: case ALL_DATA_READ:
! 879: /* finished last chunk */
! 880: evcon->state = EVCON_READING_TRAILER;
! 881: evhttp_read_trailer(evcon, req);
! 882: return;
! 883: case DATA_CORRUPTED:
! 884: /* corrupted data */
! 885: evhttp_connection_fail(evcon,
! 886: EVCON_HTTP_INVALID_HEADER);
! 887: return;
! 888: case REQUEST_CANCELED:
! 889: /* request canceled */
! 890: evhttp_request_free(req);
! 891: return;
! 892: case MORE_DATA_EXPECTED:
! 893: default:
! 894: break;
! 895: }
! 896: } else if (req->ntoread < 0) {
! 897: /* Read until connection close. */
! 898: evbuffer_add_buffer(req->input_buffer, buf);
! 899: } else if (EVBUFFER_LENGTH(buf) >= req->ntoread) {
! 900: /* Completed content length */
! 901: evbuffer_add(req->input_buffer, EVBUFFER_DATA(buf),
! 902: (size_t)req->ntoread);
! 903: evbuffer_drain(buf, (size_t)req->ntoread);
! 904: req->ntoread = 0;
! 905: evhttp_connection_done(evcon);
! 906: return;
! 907: }
! 908: /* Read more! */
! 909: event_set(&evcon->ev, evcon->fd, EV_READ, evhttp_read, evcon);
! 910: EVHTTP_BASE_SET(evcon, &evcon->ev);
! 911: evhttp_add_event(&evcon->ev, evcon->timeout, HTTP_READ_TIMEOUT);
! 912: }
! 913:
! 914: /*
! 915: * Reads data into a buffer structure until no more data
! 916: * can be read on the file descriptor or we have read all
! 917: * the data that we wanted to read.
! 918: * Execute callback when done.
! 919: */
! 920:
! 921: void
! 922: evhttp_read(int fd, short what, void *arg)
! 923: {
! 924: struct evhttp_connection *evcon = arg;
! 925: struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
! 926: struct evbuffer *buf = evcon->input_buffer;
! 927: int n, len;
! 928:
! 929: if (what == EV_TIMEOUT) {
! 930: evhttp_connection_fail(evcon, EVCON_HTTP_TIMEOUT);
! 931: return;
! 932: }
! 933: n = evbuffer_read(buf, fd, -1);
! 934: len = EVBUFFER_LENGTH(buf);
! 935: event_debug(("%s: got %d on %d\n", __func__, n, fd));
! 936:
! 937: if (n == -1) {
! 938: if (errno != EINTR && errno != EAGAIN) {
! 939: event_debug(("%s: evbuffer_read", __func__));
! 940: evhttp_connection_fail(evcon, EVCON_HTTP_EOF);
! 941: } else {
! 942: evhttp_add_event(&evcon->ev, evcon->timeout,
! 943: HTTP_READ_TIMEOUT);
! 944: }
! 945: return;
! 946: } else if (n == 0) {
! 947: /* Connection closed */
! 948: evcon->state = EVCON_DISCONNECTED;
! 949: evhttp_connection_done(evcon);
! 950: return;
! 951: }
! 952:
! 953: switch (evcon->state) {
! 954: case EVCON_READING_FIRSTLINE:
! 955: evhttp_read_firstline(evcon, req);
! 956: break;
! 957: case EVCON_READING_HEADERS:
! 958: evhttp_read_header(evcon, req);
! 959: break;
! 960: case EVCON_READING_BODY:
! 961: evhttp_read_body(evcon, req);
! 962: break;
! 963: case EVCON_READING_TRAILER:
! 964: evhttp_read_trailer(evcon, req);
! 965: break;
! 966: case EVCON_DISCONNECTED:
! 967: case EVCON_CONNECTING:
! 968: case EVCON_IDLE:
! 969: case EVCON_WRITING:
! 970: default:
! 971: event_errx(1, "%s: illegal connection state %d",
! 972: __func__, evcon->state);
! 973: }
! 974: }
! 975:
! 976: static void
! 977: evhttp_write_connectioncb(struct evhttp_connection *evcon, void *arg)
! 978: {
! 979: /* This is after writing the request to the server */
! 980: struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
! 981: assert(req != NULL);
! 982:
! 983: assert(evcon->state == EVCON_WRITING);
! 984:
! 985: /* We are done writing our header and are now expecting the response */
! 986: req->kind = EVHTTP_RESPONSE;
! 987:
! 988: evhttp_start_read(evcon);
! 989: }
! 990:
! 991: /*
! 992: * Clean up a connection object
! 993: */
! 994:
! 995: void
! 996: evhttp_connection_free(struct evhttp_connection *evcon)
! 997: {
! 998: struct evhttp_request *req;
! 999:
! 1000: /* notify interested parties that this connection is going down */
! 1001: if (evcon->fd != -1) {
! 1002: if (evhttp_connected(evcon) && evcon->closecb != NULL)
! 1003: (*evcon->closecb)(evcon, evcon->closecb_arg);
! 1004: }
! 1005:
! 1006: /* remove all requests that might be queued on this
! 1007: * connection. for server connections, this should be empty.
! 1008: * because it gets dequeued either in evhttp_connection_done or
! 1009: * evhttp_connection_fail.
! 1010: */
! 1011: while ((req = TAILQ_FIRST(&evcon->requests)) != NULL) {
! 1012: TAILQ_REMOVE(&evcon->requests, req, next);
! 1013: evhttp_request_free(req);
! 1014: }
! 1015:
! 1016: if (evcon->http_server != NULL) {
! 1017: struct evhttp *http = evcon->http_server;
! 1018: TAILQ_REMOVE(&http->connections, evcon, next);
! 1019: }
! 1020:
! 1021: if (event_initialized(&evcon->close_ev))
! 1022: event_del(&evcon->close_ev);
! 1023:
! 1024: if (event_initialized(&evcon->ev))
! 1025: event_del(&evcon->ev);
! 1026:
! 1027: if (evcon->fd != -1)
! 1028: EVUTIL_CLOSESOCKET(evcon->fd);
! 1029:
! 1030: if (evcon->bind_address != NULL)
! 1031: free(evcon->bind_address);
! 1032:
! 1033: if (evcon->address != NULL)
! 1034: free(evcon->address);
! 1035:
! 1036: if (evcon->input_buffer != NULL)
! 1037: evbuffer_free(evcon->input_buffer);
! 1038:
! 1039: if (evcon->output_buffer != NULL)
! 1040: evbuffer_free(evcon->output_buffer);
! 1041:
! 1042: free(evcon);
! 1043: }
! 1044:
! 1045: void
! 1046: evhttp_connection_set_local_address(struct evhttp_connection *evcon,
! 1047: const char *address)
! 1048: {
! 1049: assert(evcon->state == EVCON_DISCONNECTED);
! 1050: if (evcon->bind_address)
! 1051: free(evcon->bind_address);
! 1052: if ((evcon->bind_address = strdup(address)) == NULL)
! 1053: event_err(1, "%s: strdup", __func__);
! 1054: }
! 1055:
! 1056: void
! 1057: evhttp_connection_set_local_port(struct evhttp_connection *evcon,
! 1058: unsigned short port)
! 1059: {
! 1060: assert(evcon->state == EVCON_DISCONNECTED);
! 1061: evcon->bind_port = port;
! 1062: }
! 1063:
! 1064: static void
! 1065: evhttp_request_dispatch(struct evhttp_connection* evcon)
! 1066: {
! 1067: struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
! 1068:
! 1069: /* this should not usually happy but it's possible */
! 1070: if (req == NULL)
! 1071: return;
! 1072:
! 1073: /* delete possible close detection events */
! 1074: evhttp_connection_stop_detectclose(evcon);
! 1075:
! 1076: /* we assume that the connection is connected already */
! 1077: assert(evcon->state == EVCON_IDLE);
! 1078:
! 1079: evcon->state = EVCON_WRITING;
! 1080:
! 1081: /* Create the header from the store arguments */
! 1082: evhttp_make_header(evcon, req);
! 1083:
! 1084: evhttp_write_buffer(evcon, evhttp_write_connectioncb, NULL);
! 1085: }
! 1086:
! 1087: /* Reset our connection state */
! 1088: void
! 1089: evhttp_connection_reset(struct evhttp_connection *evcon)
! 1090: {
! 1091: if (event_initialized(&evcon->ev))
! 1092: event_del(&evcon->ev);
! 1093:
! 1094: if (evcon->fd != -1) {
! 1095: /* inform interested parties about connection close */
! 1096: if (evhttp_connected(evcon) && evcon->closecb != NULL)
! 1097: (*evcon->closecb)(evcon, evcon->closecb_arg);
! 1098:
! 1099: EVUTIL_CLOSESOCKET(evcon->fd);
! 1100: evcon->fd = -1;
! 1101: }
! 1102: evcon->state = EVCON_DISCONNECTED;
! 1103:
! 1104: evbuffer_drain(evcon->input_buffer,
! 1105: EVBUFFER_LENGTH(evcon->input_buffer));
! 1106: evbuffer_drain(evcon->output_buffer,
! 1107: EVBUFFER_LENGTH(evcon->output_buffer));
! 1108: }
! 1109:
! 1110: static void
! 1111: evhttp_detect_close_cb(int fd, short what, void *arg)
! 1112: {
! 1113: struct evhttp_connection *evcon = arg;
! 1114: evhttp_connection_reset(evcon);
! 1115: }
! 1116:
! 1117: static void
! 1118: evhttp_connection_start_detectclose(struct evhttp_connection *evcon)
! 1119: {
! 1120: evcon->flags |= EVHTTP_CON_CLOSEDETECT;
! 1121:
! 1122: if (event_initialized(&evcon->close_ev))
! 1123: event_del(&evcon->close_ev);
! 1124: event_set(&evcon->close_ev, evcon->fd, EV_READ,
! 1125: evhttp_detect_close_cb, evcon);
! 1126: EVHTTP_BASE_SET(evcon, &evcon->close_ev);
! 1127: event_add(&evcon->close_ev, NULL);
! 1128: }
! 1129:
! 1130: static void
! 1131: evhttp_connection_stop_detectclose(struct evhttp_connection *evcon)
! 1132: {
! 1133: evcon->flags &= ~EVHTTP_CON_CLOSEDETECT;
! 1134: event_del(&evcon->close_ev);
! 1135: }
! 1136:
! 1137: static void
! 1138: evhttp_connection_retry(int fd, short what, void *arg)
! 1139: {
! 1140: struct evhttp_connection *evcon = arg;
! 1141:
! 1142: evcon->state = EVCON_DISCONNECTED;
! 1143: evhttp_connection_connect(evcon);
! 1144: }
! 1145:
! 1146: /*
! 1147: * Call back for asynchronous connection attempt.
! 1148: */
! 1149:
! 1150: static void
! 1151: evhttp_connectioncb(int fd, short what, void *arg)
! 1152: {
! 1153: struct evhttp_connection *evcon = arg;
! 1154: int error;
! 1155: socklen_t errsz = sizeof(error);
! 1156:
! 1157: if (what == EV_TIMEOUT) {
! 1158: event_debug(("%s: connection timeout for \"%s:%d\" on %d",
! 1159: __func__, evcon->address, evcon->port, evcon->fd));
! 1160: goto cleanup;
! 1161: }
! 1162:
! 1163: /* Check if the connection completed */
! 1164: if (getsockopt(evcon->fd, SOL_SOCKET, SO_ERROR, (void*)&error,
! 1165: &errsz) == -1) {
! 1166: event_debug(("%s: getsockopt for \"%s:%d\" on %d",
! 1167: __func__, evcon->address, evcon->port, evcon->fd));
! 1168: goto cleanup;
! 1169: }
! 1170:
! 1171: if (error) {
! 1172: event_debug(("%s: connect failed for \"%s:%d\" on %d: %s",
! 1173: __func__, evcon->address, evcon->port, evcon->fd,
! 1174: strerror(error)));
! 1175: goto cleanup;
! 1176: }
! 1177:
! 1178: /* We are connected to the server now */
! 1179: event_debug(("%s: connected to \"%s:%d\" on %d\n",
! 1180: __func__, evcon->address, evcon->port, evcon->fd));
! 1181:
! 1182: /* Reset the retry count as we were successful in connecting */
! 1183: evcon->retry_cnt = 0;
! 1184: evcon->state = EVCON_IDLE;
! 1185:
! 1186: /* try to start requests that have queued up on this connection */
! 1187: evhttp_request_dispatch(evcon);
! 1188: return;
! 1189:
! 1190: cleanup:
! 1191: if (evcon->retry_max < 0 || evcon->retry_cnt < evcon->retry_max) {
! 1192: evtimer_set(&evcon->ev, evhttp_connection_retry, evcon);
! 1193: EVHTTP_BASE_SET(evcon, &evcon->ev);
! 1194: evhttp_add_event(&evcon->ev, MIN(3600, 2 << evcon->retry_cnt),
! 1195: HTTP_CONNECT_TIMEOUT);
! 1196: evcon->retry_cnt++;
! 1197: return;
! 1198: }
! 1199: evhttp_connection_reset(evcon);
! 1200:
! 1201: /* for now, we just signal all requests by executing their callbacks */
! 1202: while (TAILQ_FIRST(&evcon->requests) != NULL) {
! 1203: struct evhttp_request *request = TAILQ_FIRST(&evcon->requests);
! 1204: TAILQ_REMOVE(&evcon->requests, request, next);
! 1205: request->evcon = NULL;
! 1206:
! 1207: /* we might want to set an error here */
! 1208: request->cb(request, request->cb_arg);
! 1209: evhttp_request_free(request);
! 1210: }
! 1211: }
! 1212:
! 1213: /*
! 1214: * Check if we got a valid response code.
! 1215: */
! 1216:
! 1217: static int
! 1218: evhttp_valid_response_code(int code)
! 1219: {
! 1220: if (code == 0)
! 1221: return (0);
! 1222:
! 1223: return (1);
! 1224: }
! 1225:
! 1226: /* Parses the status line of a web server */
! 1227:
! 1228: static int
! 1229: evhttp_parse_response_line(struct evhttp_request *req, char *line)
! 1230: {
! 1231: char *protocol;
! 1232: char *number;
! 1233: const char *readable = "";
! 1234:
! 1235: protocol = strsep(&line, " ");
! 1236: if (line == NULL)
! 1237: return (-1);
! 1238: number = strsep(&line, " ");
! 1239: if (line != NULL)
! 1240: readable = line;
! 1241:
! 1242: if (strcmp(protocol, "HTTP/1.0") == 0) {
! 1243: req->major = 1;
! 1244: req->minor = 0;
! 1245: } else if (strcmp(protocol, "HTTP/1.1") == 0) {
! 1246: req->major = 1;
! 1247: req->minor = 1;
! 1248: } else {
! 1249: event_debug(("%s: bad protocol \"%s\"",
! 1250: __func__, protocol));
! 1251: return (-1);
! 1252: }
! 1253:
! 1254: req->response_code = atoi(number);
! 1255: if (!evhttp_valid_response_code(req->response_code)) {
! 1256: event_debug(("%s: bad response code \"%s\"",
! 1257: __func__, number));
! 1258: return (-1);
! 1259: }
! 1260:
! 1261: if ((req->response_code_line = strdup(readable)) == NULL)
! 1262: event_err(1, "%s: strdup", __func__);
! 1263:
! 1264: return (0);
! 1265: }
! 1266:
! 1267: /* Parse the first line of a HTTP request */
! 1268:
! 1269: static int
! 1270: evhttp_parse_request_line(struct evhttp_request *req, char *line)
! 1271: {
! 1272: char *method;
! 1273: char *uri;
! 1274: char *version;
! 1275:
! 1276: /* Parse the request line */
! 1277: method = strsep(&line, " ");
! 1278: if (line == NULL)
! 1279: return (-1);
! 1280: uri = strsep(&line, " ");
! 1281: if (line == NULL)
! 1282: return (-1);
! 1283: version = strsep(&line, " ");
! 1284: if (line != NULL)
! 1285: return (-1);
! 1286:
! 1287: /* First line */
! 1288: if (strcmp(method, "GET") == 0) {
! 1289: req->type = EVHTTP_REQ_GET;
! 1290: } else if (strcmp(method, "POST") == 0) {
! 1291: req->type = EVHTTP_REQ_POST;
! 1292: } else if (strcmp(method, "HEAD") == 0) {
! 1293: req->type = EVHTTP_REQ_HEAD;
! 1294: } else {
! 1295: event_debug(("%s: bad method %s on request %p from %s",
! 1296: __func__, method, req, req->remote_host));
! 1297: return (-1);
! 1298: }
! 1299:
! 1300: if (strcmp(version, "HTTP/1.0") == 0) {
! 1301: req->major = 1;
! 1302: req->minor = 0;
! 1303: } else if (strcmp(version, "HTTP/1.1") == 0) {
! 1304: req->major = 1;
! 1305: req->minor = 1;
! 1306: } else {
! 1307: event_debug(("%s: bad version %s on request %p from %s",
! 1308: __func__, version, req, req->remote_host));
! 1309: return (-1);
! 1310: }
! 1311:
! 1312: if ((req->uri = strdup(uri)) == NULL) {
! 1313: event_debug(("%s: strdup", __func__));
! 1314: return (-1);
! 1315: }
! 1316:
! 1317: /* determine if it's a proxy request */
! 1318: if (strlen(req->uri) > 0 && req->uri[0] != '/')
! 1319: req->flags |= EVHTTP_PROXY_REQUEST;
! 1320:
! 1321: return (0);
! 1322: }
! 1323:
! 1324: const char *
! 1325: evhttp_find_header(const struct evkeyvalq *headers, const char *key)
! 1326: {
! 1327: struct evkeyval *header;
! 1328:
! 1329: TAILQ_FOREACH(header, headers, next) {
! 1330: if (strcasecmp(header->key, key) == 0)
! 1331: return (header->value);
! 1332: }
! 1333:
! 1334: return (NULL);
! 1335: }
! 1336:
! 1337: void
! 1338: evhttp_clear_headers(struct evkeyvalq *headers)
! 1339: {
! 1340: struct evkeyval *header;
! 1341:
! 1342: for (header = TAILQ_FIRST(headers);
! 1343: header != NULL;
! 1344: header = TAILQ_FIRST(headers)) {
! 1345: TAILQ_REMOVE(headers, header, next);
! 1346: free(header->key);
! 1347: free(header->value);
! 1348: free(header);
! 1349: }
! 1350: }
! 1351:
! 1352: /*
! 1353: * Returns 0, if the header was successfully removed.
! 1354: * Returns -1, if the header could not be found.
! 1355: */
! 1356:
! 1357: int
! 1358: evhttp_remove_header(struct evkeyvalq *headers, const char *key)
! 1359: {
! 1360: struct evkeyval *header;
! 1361:
! 1362: TAILQ_FOREACH(header, headers, next) {
! 1363: if (strcasecmp(header->key, key) == 0)
! 1364: break;
! 1365: }
! 1366:
! 1367: if (header == NULL)
! 1368: return (-1);
! 1369:
! 1370: /* Free and remove the header that we found */
! 1371: TAILQ_REMOVE(headers, header, next);
! 1372: free(header->key);
! 1373: free(header->value);
! 1374: free(header);
! 1375:
! 1376: return (0);
! 1377: }
! 1378:
! 1379: static int
! 1380: evhttp_header_is_valid_value(const char *value)
! 1381: {
! 1382: const char *p = value;
! 1383:
! 1384: while ((p = strpbrk(p, "\r\n")) != NULL) {
! 1385: /* we really expect only one new line */
! 1386: p += strspn(p, "\r\n");
! 1387: /* we expect a space or tab for continuation */
! 1388: if (*p != ' ' && *p != '\t')
! 1389: return (0);
! 1390: }
! 1391: return (1);
! 1392: }
! 1393:
! 1394: int
! 1395: evhttp_add_header(struct evkeyvalq *headers,
! 1396: const char *key, const char *value)
! 1397: {
! 1398: event_debug(("%s: key: %s val: %s\n", __func__, key, value));
! 1399:
! 1400: if (strchr(key, '\r') != NULL || strchr(key, '\n') != NULL) {
! 1401: /* drop illegal headers */
! 1402: event_debug(("%s: dropping illegal header key\n", __func__));
! 1403: return (-1);
! 1404: }
! 1405:
! 1406: if (!evhttp_header_is_valid_value(value)) {
! 1407: event_debug(("%s: dropping illegal header value\n", __func__));
! 1408: return (-1);
! 1409: }
! 1410:
! 1411: return (evhttp_add_header_internal(headers, key, value));
! 1412: }
! 1413:
! 1414: static int
! 1415: evhttp_add_header_internal(struct evkeyvalq *headers,
! 1416: const char *key, const char *value)
! 1417: {
! 1418: struct evkeyval *header = calloc(1, sizeof(struct evkeyval));
! 1419: if (header == NULL) {
! 1420: event_warn("%s: calloc", __func__);
! 1421: return (-1);
! 1422: }
! 1423: if ((header->key = strdup(key)) == NULL) {
! 1424: free(header);
! 1425: event_warn("%s: strdup", __func__);
! 1426: return (-1);
! 1427: }
! 1428: if ((header->value = strdup(value)) == NULL) {
! 1429: free(header->key);
! 1430: free(header);
! 1431: event_warn("%s: strdup", __func__);
! 1432: return (-1);
! 1433: }
! 1434:
! 1435: TAILQ_INSERT_TAIL(headers, header, next);
! 1436:
! 1437: return (0);
! 1438: }
! 1439:
! 1440: /*
! 1441: * Parses header lines from a request or a response into the specified
! 1442: * request object given an event buffer.
! 1443: *
! 1444: * Returns
! 1445: * DATA_CORRUPTED on error
! 1446: * MORE_DATA_EXPECTED when we need to read more headers
! 1447: * ALL_DATA_READ when all headers have been read.
! 1448: */
! 1449:
! 1450: enum message_read_status
! 1451: evhttp_parse_firstline(struct evhttp_request *req, struct evbuffer *buffer)
! 1452: {
! 1453: char *line;
! 1454: enum message_read_status status = ALL_DATA_READ;
! 1455:
! 1456: line = evbuffer_readline(buffer);
! 1457: if (line == NULL)
! 1458: return (MORE_DATA_EXPECTED);
! 1459:
! 1460: switch (req->kind) {
! 1461: case EVHTTP_REQUEST:
! 1462: if (evhttp_parse_request_line(req, line) == -1)
! 1463: status = DATA_CORRUPTED;
! 1464: break;
! 1465: case EVHTTP_RESPONSE:
! 1466: if (evhttp_parse_response_line(req, line) == -1)
! 1467: status = DATA_CORRUPTED;
! 1468: break;
! 1469: default:
! 1470: status = DATA_CORRUPTED;
! 1471: }
! 1472:
! 1473: free(line);
! 1474: return (status);
! 1475: }
! 1476:
! 1477: static int
! 1478: evhttp_append_to_last_header(struct evkeyvalq *headers, const char *line)
! 1479: {
! 1480: struct evkeyval *header = TAILQ_LAST(headers, evkeyvalq);
! 1481: char *newval;
! 1482: size_t old_len, line_len;
! 1483:
! 1484: if (header == NULL)
! 1485: return (-1);
! 1486:
! 1487: old_len = strlen(header->value);
! 1488: line_len = strlen(line);
! 1489:
! 1490: newval = realloc(header->value, old_len + line_len + 1);
! 1491: if (newval == NULL)
! 1492: return (-1);
! 1493:
! 1494: memcpy(newval + old_len, line, line_len + 1);
! 1495: header->value = newval;
! 1496:
! 1497: return (0);
! 1498: }
! 1499:
! 1500: enum message_read_status
! 1501: evhttp_parse_headers(struct evhttp_request *req, struct evbuffer* buffer)
! 1502: {
! 1503: char *line;
! 1504: enum message_read_status status = MORE_DATA_EXPECTED;
! 1505:
! 1506: struct evkeyvalq* headers = req->input_headers;
! 1507: while ((line = evbuffer_readline(buffer))
! 1508: != NULL) {
! 1509: char *skey, *svalue;
! 1510:
! 1511: if (*line == '\0') { /* Last header - Done */
! 1512: status = ALL_DATA_READ;
! 1513: free(line);
! 1514: break;
! 1515: }
! 1516:
! 1517: /* Check if this is a continuation line */
! 1518: if (*line == ' ' || *line == '\t') {
! 1519: if (evhttp_append_to_last_header(headers, line) == -1)
! 1520: goto error;
! 1521: free(line);
! 1522: continue;
! 1523: }
! 1524:
! 1525: /* Processing of header lines */
! 1526: svalue = line;
! 1527: skey = strsep(&svalue, ":");
! 1528: if (svalue == NULL)
! 1529: goto error;
! 1530:
! 1531: svalue += strspn(svalue, " ");
! 1532:
! 1533: if (evhttp_add_header(headers, skey, svalue) == -1)
! 1534: goto error;
! 1535:
! 1536: free(line);
! 1537: }
! 1538:
! 1539: return (status);
! 1540:
! 1541: error:
! 1542: free(line);
! 1543: return (DATA_CORRUPTED);
! 1544: }
! 1545:
! 1546: static int
! 1547: evhttp_get_body_length(struct evhttp_request *req)
! 1548: {
! 1549: struct evkeyvalq *headers = req->input_headers;
! 1550: const char *content_length;
! 1551: const char *connection;
! 1552:
! 1553: content_length = evhttp_find_header(headers, "Content-Length");
! 1554: connection = evhttp_find_header(headers, "Connection");
! 1555:
! 1556: if (content_length == NULL && connection == NULL)
! 1557: req->ntoread = -1;
! 1558: else if (content_length == NULL &&
! 1559: strcasecmp(connection, "Close") != 0) {
! 1560: /* Bad combination, we don't know when it will end */
! 1561: event_warnx("%s: we got no content length, but the "
! 1562: "server wants to keep the connection open: %s.",
! 1563: __func__, connection);
! 1564: return (-1);
! 1565: } else if (content_length == NULL) {
! 1566: req->ntoread = -1;
! 1567: } else {
! 1568: char *endp;
! 1569: ev_int64_t ntoread = evutil_strtoll(content_length, &endp, 10);
! 1570: if (*content_length == '\0' || *endp != '\0' || ntoread < 0) {
! 1571: event_debug(("%s: illegal content length: %s",
! 1572: __func__, content_length));
! 1573: return (-1);
! 1574: }
! 1575: req->ntoread = ntoread;
! 1576: }
! 1577:
! 1578: event_debug(("%s: bytes to read: %lld (in buffer %ld)\n",
! 1579: __func__, req->ntoread,
! 1580: EVBUFFER_LENGTH(req->evcon->input_buffer)));
! 1581:
! 1582: return (0);
! 1583: }
! 1584:
! 1585: static void
! 1586: evhttp_get_body(struct evhttp_connection *evcon, struct evhttp_request *req)
! 1587: {
! 1588: const char *xfer_enc;
! 1589:
! 1590: /* If this is a request without a body, then we are done */
! 1591: if (req->kind == EVHTTP_REQUEST && req->type != EVHTTP_REQ_POST) {
! 1592: evhttp_connection_done(evcon);
! 1593: return;
! 1594: }
! 1595: evcon->state = EVCON_READING_BODY;
! 1596: xfer_enc = evhttp_find_header(req->input_headers, "Transfer-Encoding");
! 1597: if (xfer_enc != NULL && strcasecmp(xfer_enc, "chunked") == 0) {
! 1598: req->chunked = 1;
! 1599: req->ntoread = -1;
! 1600: } else {
! 1601: if (evhttp_get_body_length(req) == -1) {
! 1602: evhttp_connection_fail(evcon,
! 1603: EVCON_HTTP_INVALID_HEADER);
! 1604: return;
! 1605: }
! 1606: }
! 1607: evhttp_read_body(evcon, req);
! 1608: }
! 1609:
! 1610: static void
! 1611: evhttp_read_firstline(struct evhttp_connection *evcon,
! 1612: struct evhttp_request *req)
! 1613: {
! 1614: enum message_read_status res;
! 1615:
! 1616: res = evhttp_parse_firstline(req, evcon->input_buffer);
! 1617: if (res == DATA_CORRUPTED) {
! 1618: /* Error while reading, terminate */
! 1619: event_debug(("%s: bad header lines on %d\n",
! 1620: __func__, evcon->fd));
! 1621: evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
! 1622: return;
! 1623: } else if (res == MORE_DATA_EXPECTED) {
! 1624: /* Need more header lines */
! 1625: evhttp_add_event(&evcon->ev,
! 1626: evcon->timeout, HTTP_READ_TIMEOUT);
! 1627: return;
! 1628: }
! 1629:
! 1630: evcon->state = EVCON_READING_HEADERS;
! 1631: evhttp_read_header(evcon, req);
! 1632: }
! 1633:
! 1634: static void
! 1635: evhttp_read_header(struct evhttp_connection *evcon, struct evhttp_request *req)
! 1636: {
! 1637: enum message_read_status res;
! 1638: int fd = evcon->fd;
! 1639:
! 1640: res = evhttp_parse_headers(req, evcon->input_buffer);
! 1641: if (res == DATA_CORRUPTED) {
! 1642: /* Error while reading, terminate */
! 1643: event_debug(("%s: bad header lines on %d\n", __func__, fd));
! 1644: evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
! 1645: return;
! 1646: } else if (res == MORE_DATA_EXPECTED) {
! 1647: /* Need more header lines */
! 1648: evhttp_add_event(&evcon->ev,
! 1649: evcon->timeout, HTTP_READ_TIMEOUT);
! 1650: return;
! 1651: }
! 1652:
! 1653: /* Done reading headers, do the real work */
! 1654: switch (req->kind) {
! 1655: case EVHTTP_REQUEST:
! 1656: event_debug(("%s: checking for post data on %d\n",
! 1657: __func__, fd));
! 1658: evhttp_get_body(evcon, req);
! 1659: break;
! 1660:
! 1661: case EVHTTP_RESPONSE:
! 1662: if (req->response_code == HTTP_NOCONTENT ||
! 1663: req->response_code == HTTP_NOTMODIFIED ||
! 1664: (req->response_code >= 100 && req->response_code < 200)) {
! 1665: event_debug(("%s: skipping body for code %d\n",
! 1666: __func__, req->response_code));
! 1667: evhttp_connection_done(evcon);
! 1668: } else {
! 1669: event_debug(("%s: start of read body for %s on %d\n",
! 1670: __func__, req->remote_host, fd));
! 1671: evhttp_get_body(evcon, req);
! 1672: }
! 1673: break;
! 1674:
! 1675: default:
! 1676: event_warnx("%s: bad header on %d", __func__, fd);
! 1677: evhttp_connection_fail(evcon, EVCON_HTTP_INVALID_HEADER);
! 1678: break;
! 1679: }
! 1680: }
! 1681:
! 1682: /*
! 1683: * Creates a TCP connection to the specified port and executes a callback
! 1684: * when finished. Failure or sucess is indicate by the passed connection
! 1685: * object.
! 1686: *
! 1687: * Although this interface accepts a hostname, it is intended to take
! 1688: * only numeric hostnames so that non-blocking DNS resolution can
! 1689: * happen elsewhere.
! 1690: */
! 1691:
! 1692: struct evhttp_connection *
! 1693: evhttp_connection_new(const char *address, unsigned short port)
! 1694: {
! 1695: struct evhttp_connection *evcon = NULL;
! 1696:
! 1697: event_debug(("Attempting connection to %s:%d\n", address, port));
! 1698:
! 1699: if ((evcon = calloc(1, sizeof(struct evhttp_connection))) == NULL) {
! 1700: event_warn("%s: calloc failed", __func__);
! 1701: goto error;
! 1702: }
! 1703:
! 1704: evcon->fd = -1;
! 1705: evcon->port = port;
! 1706:
! 1707: evcon->timeout = -1;
! 1708: evcon->retry_cnt = evcon->retry_max = 0;
! 1709:
! 1710: if ((evcon->address = strdup(address)) == NULL) {
! 1711: event_warn("%s: strdup failed", __func__);
! 1712: goto error;
! 1713: }
! 1714:
! 1715: if ((evcon->input_buffer = evbuffer_new()) == NULL) {
! 1716: event_warn("%s: evbuffer_new failed", __func__);
! 1717: goto error;
! 1718: }
! 1719:
! 1720: if ((evcon->output_buffer = evbuffer_new()) == NULL) {
! 1721: event_warn("%s: evbuffer_new failed", __func__);
! 1722: goto error;
! 1723: }
! 1724:
! 1725: evcon->state = EVCON_DISCONNECTED;
! 1726: TAILQ_INIT(&evcon->requests);
! 1727:
! 1728: return (evcon);
! 1729:
! 1730: error:
! 1731: if (evcon != NULL)
! 1732: evhttp_connection_free(evcon);
! 1733: return (NULL);
! 1734: }
! 1735:
! 1736: void evhttp_connection_set_base(struct evhttp_connection *evcon,
! 1737: struct event_base *base)
! 1738: {
! 1739: assert(evcon->base == NULL);
! 1740: assert(evcon->state == EVCON_DISCONNECTED);
! 1741: evcon->base = base;
! 1742: }
! 1743:
! 1744: void
! 1745: evhttp_connection_set_timeout(struct evhttp_connection *evcon,
! 1746: int timeout_in_secs)
! 1747: {
! 1748: evcon->timeout = timeout_in_secs;
! 1749: }
! 1750:
! 1751: void
! 1752: evhttp_connection_set_retries(struct evhttp_connection *evcon,
! 1753: int retry_max)
! 1754: {
! 1755: evcon->retry_max = retry_max;
! 1756: }
! 1757:
! 1758: void
! 1759: evhttp_connection_set_closecb(struct evhttp_connection *evcon,
! 1760: void (*cb)(struct evhttp_connection *, void *), void *cbarg)
! 1761: {
! 1762: evcon->closecb = cb;
! 1763: evcon->closecb_arg = cbarg;
! 1764: }
! 1765:
! 1766: void
! 1767: evhttp_connection_get_peer(struct evhttp_connection *evcon,
! 1768: char **address, u_short *port)
! 1769: {
! 1770: *address = evcon->address;
! 1771: *port = evcon->port;
! 1772: }
! 1773:
! 1774: int
! 1775: evhttp_connection_connect(struct evhttp_connection *evcon)
! 1776: {
! 1777: if (evcon->state == EVCON_CONNECTING)
! 1778: return (0);
! 1779:
! 1780: evhttp_connection_reset(evcon);
! 1781:
! 1782: assert(!(evcon->flags & EVHTTP_CON_INCOMING));
! 1783: evcon->flags |= EVHTTP_CON_OUTGOING;
! 1784:
! 1785: evcon->fd = bind_socket(
! 1786: evcon->bind_address, evcon->bind_port, 0 /*reuse*/);
! 1787: if (evcon->fd == -1) {
! 1788: event_debug(("%s: failed to bind to \"%s\"",
! 1789: __func__, evcon->bind_address));
! 1790: return (-1);
! 1791: }
! 1792:
! 1793: if (socket_connect(evcon->fd, evcon->address, evcon->port) == -1) {
! 1794: EVUTIL_CLOSESOCKET(evcon->fd); evcon->fd = -1;
! 1795: return (-1);
! 1796: }
! 1797:
! 1798: /* Set up a callback for successful connection setup */
! 1799: event_set(&evcon->ev, evcon->fd, EV_WRITE, evhttp_connectioncb, evcon);
! 1800: EVHTTP_BASE_SET(evcon, &evcon->ev);
! 1801: evhttp_add_event(&evcon->ev, evcon->timeout, HTTP_CONNECT_TIMEOUT);
! 1802:
! 1803: evcon->state = EVCON_CONNECTING;
! 1804:
! 1805: return (0);
! 1806: }
! 1807:
! 1808: /*
! 1809: * Starts an HTTP request on the provided evhttp_connection object.
! 1810: * If the connection object is not connected to the web server already,
! 1811: * this will start the connection.
! 1812: */
! 1813:
! 1814: int
! 1815: evhttp_make_request(struct evhttp_connection *evcon,
! 1816: struct evhttp_request *req,
! 1817: enum evhttp_cmd_type type, const char *uri)
! 1818: {
! 1819: /* We are making a request */
! 1820: req->kind = EVHTTP_REQUEST;
! 1821: req->type = type;
! 1822: if (req->uri != NULL)
! 1823: free(req->uri);
! 1824: if ((req->uri = strdup(uri)) == NULL)
! 1825: event_err(1, "%s: strdup", __func__);
! 1826:
! 1827: /* Set the protocol version if it is not supplied */
! 1828: if (!req->major && !req->minor) {
! 1829: req->major = 1;
! 1830: req->minor = 1;
! 1831: }
! 1832:
! 1833: assert(req->evcon == NULL);
! 1834: req->evcon = evcon;
! 1835: assert(!(req->flags & EVHTTP_REQ_OWN_CONNECTION));
! 1836:
! 1837: TAILQ_INSERT_TAIL(&evcon->requests, req, next);
! 1838:
! 1839: /* If the connection object is not connected; make it so */
! 1840: if (!evhttp_connected(evcon))
! 1841: return (evhttp_connection_connect(evcon));
! 1842:
! 1843: /*
! 1844: * If it's connected already and we are the first in the queue,
! 1845: * then we can dispatch this request immediately. Otherwise, it
! 1846: * will be dispatched once the pending requests are completed.
! 1847: */
! 1848: if (TAILQ_FIRST(&evcon->requests) == req)
! 1849: evhttp_request_dispatch(evcon);
! 1850:
! 1851: return (0);
! 1852: }
! 1853:
! 1854: /*
! 1855: * Reads data from file descriptor into request structure
! 1856: * Request structure needs to be set up correctly.
! 1857: */
! 1858:
! 1859: void
! 1860: evhttp_start_read(struct evhttp_connection *evcon)
! 1861: {
! 1862: /* Set up an event to read the headers */
! 1863: if (event_initialized(&evcon->ev))
! 1864: event_del(&evcon->ev);
! 1865: event_set(&evcon->ev, evcon->fd, EV_READ, evhttp_read, evcon);
! 1866: EVHTTP_BASE_SET(evcon, &evcon->ev);
! 1867:
! 1868: evhttp_add_event(&evcon->ev, evcon->timeout, HTTP_READ_TIMEOUT);
! 1869: evcon->state = EVCON_READING_FIRSTLINE;
! 1870: }
! 1871:
! 1872: static void
! 1873: evhttp_send_done(struct evhttp_connection *evcon, void *arg)
! 1874: {
! 1875: int need_close;
! 1876: struct evhttp_request *req = TAILQ_FIRST(&evcon->requests);
! 1877: TAILQ_REMOVE(&evcon->requests, req, next);
! 1878:
! 1879: /* delete possible close detection events */
! 1880: evhttp_connection_stop_detectclose(evcon);
! 1881:
! 1882: need_close =
! 1883: (req->minor == 0 &&
! 1884: !evhttp_is_connection_keepalive(req->input_headers))||
! 1885: evhttp_is_connection_close(req->flags, req->input_headers) ||
! 1886: evhttp_is_connection_close(req->flags, req->output_headers);
! 1887:
! 1888: assert(req->flags & EVHTTP_REQ_OWN_CONNECTION);
! 1889: evhttp_request_free(req);
! 1890:
! 1891: if (need_close) {
! 1892: evhttp_connection_free(evcon);
! 1893: return;
! 1894: }
! 1895:
! 1896: /* we have a persistent connection; try to accept another request. */
! 1897: if (evhttp_associate_new_request_with_connection(evcon) == -1)
! 1898: evhttp_connection_free(evcon);
! 1899: }
! 1900:
! 1901: /*
! 1902: * Returns an error page.
! 1903: */
! 1904:
! 1905: void
! 1906: evhttp_send_error(struct evhttp_request *req, int error, const char *reason)
! 1907: {
! 1908: #define ERR_FORMAT "<HTML><HEAD>\n" \
! 1909: "<TITLE>%d %s</TITLE>\n" \
! 1910: "</HEAD><BODY>\n" \
! 1911: "<H1>Method Not Implemented</H1>\n" \
! 1912: "Invalid method in request<P>\n" \
! 1913: "</BODY></HTML>\n"
! 1914:
! 1915: struct evbuffer *buf = evbuffer_new();
! 1916:
! 1917: /* close the connection on error */
! 1918: evhttp_add_header(req->output_headers, "Connection", "close");
! 1919:
! 1920: evhttp_response_code(req, error, reason);
! 1921:
! 1922: evbuffer_add_printf(buf, ERR_FORMAT, error, reason);
! 1923:
! 1924: evhttp_send_page(req, buf);
! 1925:
! 1926: evbuffer_free(buf);
! 1927: #undef ERR_FORMAT
! 1928: }
! 1929:
! 1930: /* Requires that headers and response code are already set up */
! 1931:
! 1932: static inline void
! 1933: evhttp_send(struct evhttp_request *req, struct evbuffer *databuf)
! 1934: {
! 1935: struct evhttp_connection *evcon = req->evcon;
! 1936:
! 1937: if (evcon == NULL) {
! 1938: evhttp_request_free(req);
! 1939: return;
! 1940: }
! 1941:
! 1942: assert(TAILQ_FIRST(&evcon->requests) == req);
! 1943:
! 1944: /* we expect no more calls form the user on this request */
! 1945: req->userdone = 1;
! 1946:
! 1947: /* xxx: not sure if we really should expose the data buffer this way */
! 1948: if (databuf != NULL)
! 1949: evbuffer_add_buffer(req->output_buffer, databuf);
! 1950:
! 1951: /* Adds headers to the response */
! 1952: evhttp_make_header(evcon, req);
! 1953:
! 1954: evhttp_write_buffer(evcon, evhttp_send_done, NULL);
! 1955: }
! 1956:
! 1957: void
! 1958: evhttp_send_reply(struct evhttp_request *req, int code, const char *reason,
! 1959: struct evbuffer *databuf)
! 1960: {
! 1961: evhttp_response_code(req, code, reason);
! 1962:
! 1963: evhttp_send(req, databuf);
! 1964: }
! 1965:
! 1966: void
! 1967: evhttp_send_reply_start(struct evhttp_request *req, int code,
! 1968: const char *reason)
! 1969: {
! 1970: evhttp_response_code(req, code, reason);
! 1971: if (req->major == 1 && req->minor == 1) {
! 1972: /* use chunked encoding for HTTP/1.1 */
! 1973: evhttp_add_header(req->output_headers, "Transfer-Encoding",
! 1974: "chunked");
! 1975: req->chunked = 1;
! 1976: }
! 1977: evhttp_make_header(req->evcon, req);
! 1978: evhttp_write_buffer(req->evcon, NULL, NULL);
! 1979: }
! 1980:
! 1981: void
! 1982: evhttp_send_reply_chunk(struct evhttp_request *req, struct evbuffer *databuf)
! 1983: {
! 1984: struct evhttp_connection *evcon = req->evcon;
! 1985:
! 1986: if (evcon == NULL)
! 1987: return;
! 1988:
! 1989: if (req->chunked) {
! 1990: evbuffer_add_printf(evcon->output_buffer, "%x\r\n",
! 1991: (unsigned)EVBUFFER_LENGTH(databuf));
! 1992: }
! 1993: evbuffer_add_buffer(evcon->output_buffer, databuf);
! 1994: if (req->chunked) {
! 1995: evbuffer_add(evcon->output_buffer, "\r\n", 2);
! 1996: }
! 1997: evhttp_write_buffer(evcon, NULL, NULL);
! 1998: }
! 1999:
! 2000: void
! 2001: evhttp_send_reply_end(struct evhttp_request *req)
! 2002: {
! 2003: struct evhttp_connection *evcon = req->evcon;
! 2004:
! 2005: if (evcon == NULL) {
! 2006: evhttp_request_free(req);
! 2007: return;
! 2008: }
! 2009:
! 2010: /* we expect no more calls form the user on this request */
! 2011: req->userdone = 1;
! 2012:
! 2013: if (req->chunked) {
! 2014: evbuffer_add(req->evcon->output_buffer, "0\r\n\r\n", 5);
! 2015: evhttp_write_buffer(req->evcon, evhttp_send_done, NULL);
! 2016: req->chunked = 0;
! 2017: } else if (!event_pending(&evcon->ev, EV_WRITE|EV_TIMEOUT, NULL)) {
! 2018: /* let the connection know that we are done with the request */
! 2019: evhttp_send_done(evcon, NULL);
! 2020: } else {
! 2021: /* make the callback execute after all data has been written */
! 2022: evcon->cb = evhttp_send_done;
! 2023: evcon->cb_arg = NULL;
! 2024: }
! 2025: }
! 2026:
! 2027: void
! 2028: evhttp_response_code(struct evhttp_request *req, int code, const char *reason)
! 2029: {
! 2030: req->kind = EVHTTP_RESPONSE;
! 2031: req->response_code = code;
! 2032: if (req->response_code_line != NULL)
! 2033: free(req->response_code_line);
! 2034: req->response_code_line = strdup(reason);
! 2035: }
! 2036:
! 2037: void
! 2038: evhttp_send_page(struct evhttp_request *req, struct evbuffer *databuf)
! 2039: {
! 2040: if (!req->major || !req->minor) {
! 2041: req->major = 1;
! 2042: req->minor = 1;
! 2043: }
! 2044:
! 2045: if (req->kind != EVHTTP_RESPONSE)
! 2046: evhttp_response_code(req, 200, "OK");
! 2047:
! 2048: evhttp_clear_headers(req->output_headers);
! 2049: evhttp_add_header(req->output_headers, "Content-Type", "text/html");
! 2050: evhttp_add_header(req->output_headers, "Connection", "close");
! 2051:
! 2052: evhttp_send(req, databuf);
! 2053: }
! 2054:
! 2055: static const char uri_chars[256] = {
! 2056: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2057: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2058: 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 2059: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0,
! 2060: /* 64 */
! 2061: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 2062: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
! 2063: 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
! 2064: 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0,
! 2065: /* 128 */
! 2066: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2067: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2068: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2069: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2070: /* 192 */
! 2071: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2072: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2073: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2074: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
! 2075: };
! 2076:
! 2077: /*
! 2078: * Helper functions to encode/decode a URI.
! 2079: * The returned string must be freed by the caller.
! 2080: */
! 2081: char *
! 2082: evhttp_encode_uri(const char *uri)
! 2083: {
! 2084: struct evbuffer *buf = evbuffer_new();
! 2085: char *p;
! 2086:
! 2087: for (p = (char *)uri; *p != '\0'; p++) {
! 2088: if (uri_chars[(u_char)(*p)]) {
! 2089: evbuffer_add(buf, p, 1);
! 2090: } else {
! 2091: evbuffer_add_printf(buf, "%%%02X", (u_char)(*p));
! 2092: }
! 2093: }
! 2094: evbuffer_add(buf, "", 1);
! 2095: p = strdup((char *)EVBUFFER_DATA(buf));
! 2096: evbuffer_free(buf);
! 2097:
! 2098: return (p);
! 2099: }
! 2100:
! 2101: /*
! 2102: * @param always_decode_plus: when true we transform plus to space even
! 2103: * if we have not seen a ?.
! 2104: */
! 2105: static int
! 2106: evhttp_decode_uri_internal(
! 2107: const char *uri, size_t length, char *ret, int always_decode_plus)
! 2108: {
! 2109: char c;
! 2110: int i, j, in_query = always_decode_plus;
! 2111:
! 2112: for (i = j = 0; uri[i] != '\0'; i++) {
! 2113: c = uri[i];
! 2114: if (c == '?') {
! 2115: in_query = 1;
! 2116: } else if (c == '+' && in_query) {
! 2117: c = ' ';
! 2118: } else if (c == '%' && isxdigit((unsigned char)uri[i+1]) &&
! 2119: isxdigit((unsigned char)uri[i+2])) {
! 2120: char tmp[] = { uri[i+1], uri[i+2], '\0' };
! 2121: c = (char)strtol(tmp, NULL, 16);
! 2122: i += 2;
! 2123: }
! 2124: ret[j++] = c;
! 2125: }
! 2126: ret[j] = '\0';
! 2127:
! 2128: return (j);
! 2129: }
! 2130:
! 2131: char *
! 2132: evhttp_decode_uri(const char *uri)
! 2133: {
! 2134: char *ret;
! 2135:
! 2136: if ((ret = malloc(strlen(uri) + 1)) == NULL)
! 2137: event_err(1, "%s: malloc(%lu)", __func__,
! 2138: (unsigned long)(strlen(uri) + 1));
! 2139:
! 2140: evhttp_decode_uri_internal(uri, strlen(uri),
! 2141: ret, 0 /*always_decode_plus*/);
! 2142:
! 2143: return (ret);
! 2144: }
! 2145:
! 2146: /*
! 2147: * Helper function to parse out arguments in a query.
! 2148: * The arguments are separated by key and value.
! 2149: */
! 2150:
! 2151: void
! 2152: evhttp_parse_query(const char *uri, struct evkeyvalq *headers)
! 2153: {
! 2154: char *line;
! 2155: char *argument;
! 2156: char *p;
! 2157:
! 2158: TAILQ_INIT(headers);
! 2159:
! 2160: /* No arguments - we are done */
! 2161: if (strchr(uri, '?') == NULL)
! 2162: return;
! 2163:
! 2164: if ((line = strdup(uri)) == NULL)
! 2165: event_err(1, "%s: strdup", __func__);
! 2166:
! 2167:
! 2168: argument = line;
! 2169:
! 2170: /* We already know that there has to be a ? */
! 2171: strsep(&argument, "?");
! 2172:
! 2173: p = argument;
! 2174: while (p != NULL && *p != '\0') {
! 2175: char *key, *value, *decoded_value;
! 2176: argument = strsep(&p, "&");
! 2177:
! 2178: value = argument;
! 2179: key = strsep(&value, "=");
! 2180: if (value == NULL)
! 2181: goto error;
! 2182:
! 2183: if ((decoded_value = malloc(strlen(value) + 1)) == NULL)
! 2184: event_err(1, "%s: malloc", __func__);
! 2185:
! 2186: evhttp_decode_uri_internal(value, strlen(value),
! 2187: decoded_value, 1 /*always_decode_plus*/);
! 2188: event_debug(("Query Param: %s -> %s\n", key, decoded_value));
! 2189: evhttp_add_header_internal(headers, key, decoded_value);
! 2190: free(decoded_value);
! 2191: }
! 2192:
! 2193: error:
! 2194: free(line);
! 2195: }
! 2196:
! 2197: static struct evhttp_cb *
! 2198: evhttp_dispatch_callback(struct httpcbq *callbacks, struct evhttp_request *req)
! 2199: {
! 2200: struct evhttp_cb *cb;
! 2201: size_t offset = 0;
! 2202:
! 2203: /* Test for different URLs */
! 2204: char *p = strchr(req->uri, '?');
! 2205: if (p != NULL)
! 2206: offset = (size_t)(p - req->uri);
! 2207:
! 2208: TAILQ_FOREACH(cb, callbacks, next) {
! 2209: int res = 0;
! 2210: if (p == NULL) {
! 2211: res = strcmp(cb->what, req->uri) == 0;
! 2212: } else {
! 2213: res = ((strncmp(cb->what, req->uri, offset) == 0) &&
! 2214: (cb->what[offset] == '\0'));
! 2215: }
! 2216:
! 2217: if (res)
! 2218: return (cb);
! 2219: }
! 2220:
! 2221: return (NULL);
! 2222: }
! 2223:
! 2224: static void
! 2225: evhttp_handle_request(struct evhttp_request *req, void *arg)
! 2226: {
! 2227: struct evhttp *http = arg;
! 2228: struct evhttp_cb *cb = NULL;
! 2229:
! 2230: event_debug(("%s: req->uri=%s", __func__, req->uri));
! 2231: if (req->uri == NULL) {
! 2232: event_debug(("%s: bad request", __func__));
! 2233: if (req->evcon->state == EVCON_DISCONNECTED) {
! 2234: evhttp_connection_fail(req->evcon, EVCON_HTTP_EOF);
! 2235: } else {
! 2236: event_debug(("%s: sending error", __func__));
! 2237: evhttp_send_error(req, HTTP_BADREQUEST, "Bad Request");
! 2238: }
! 2239: return;
! 2240: }
! 2241:
! 2242: if ((cb = evhttp_dispatch_callback(&http->callbacks, req)) != NULL) {
! 2243: (*cb->cb)(req, cb->cbarg);
! 2244: return;
! 2245: }
! 2246:
! 2247: /* Generic call back */
! 2248: if (http->gencb) {
! 2249: (*http->gencb)(req, http->gencbarg);
! 2250: return;
! 2251: } else {
! 2252: /* We need to send a 404 here */
! 2253: #define ERR_FORMAT "<html><head>" \
! 2254: "<title>404 Not Found</title>" \
! 2255: "</head><body>" \
! 2256: "<h1>Not Found</h1>" \
! 2257: "<p>The requested URL %s was not found on this server.</p>"\
! 2258: "</body></html>\n"
! 2259:
! 2260: char *escaped_html = evhttp_htmlescape(req->uri);
! 2261: struct evbuffer *buf = evbuffer_new();
! 2262:
! 2263: evhttp_response_code(req, HTTP_NOTFOUND, "Not Found");
! 2264:
! 2265: evbuffer_add_printf(buf, ERR_FORMAT, escaped_html);
! 2266:
! 2267: free(escaped_html);
! 2268:
! 2269: evhttp_send_page(req, buf);
! 2270:
! 2271: evbuffer_free(buf);
! 2272: #undef ERR_FORMAT
! 2273: }
! 2274: }
! 2275:
! 2276: static void
! 2277: accept_socket(int fd, short what, void *arg)
! 2278: {
! 2279: struct evhttp *http = arg;
! 2280: struct sockaddr_storage ss;
! 2281: socklen_t addrlen = sizeof(ss);
! 2282: int nfd;
! 2283:
! 2284: if ((nfd = accept(fd, (struct sockaddr *)&ss, &addrlen)) == -1) {
! 2285: if (errno != EAGAIN && errno != EINTR)
! 2286: event_warn("%s: bad accept", __func__);
! 2287: return;
! 2288: }
! 2289: if (evutil_make_socket_nonblocking(nfd) < 0)
! 2290: return;
! 2291:
! 2292: evhttp_get_request(http, nfd, (struct sockaddr *)&ss, addrlen);
! 2293: }
! 2294:
! 2295: int
! 2296: evhttp_bind_socket(struct evhttp *http, const char *address, u_short port)
! 2297: {
! 2298: int fd;
! 2299: int res;
! 2300:
! 2301: if ((fd = bind_socket(address, port, 1 /*reuse*/)) == -1)
! 2302: return (-1);
! 2303:
! 2304: if (listen(fd, 128) == -1) {
! 2305: event_warn("%s: listen", __func__);
! 2306: EVUTIL_CLOSESOCKET(fd);
! 2307: return (-1);
! 2308: }
! 2309:
! 2310: res = evhttp_accept_socket(http, fd);
! 2311:
! 2312: if (res != -1)
! 2313: event_debug(("Bound to port %d - Awaiting connections ... ",
! 2314: port));
! 2315:
! 2316: return (res);
! 2317: }
! 2318:
! 2319: int
! 2320: evhttp_accept_socket(struct evhttp *http, int fd)
! 2321: {
! 2322: struct evhttp_bound_socket *bound;
! 2323: struct event *ev;
! 2324: int res;
! 2325:
! 2326: bound = malloc(sizeof(struct evhttp_bound_socket));
! 2327: if (bound == NULL)
! 2328: return (-1);
! 2329:
! 2330: ev = &bound->bind_ev;
! 2331:
! 2332: /* Schedule the socket for accepting */
! 2333: event_set(ev, fd, EV_READ | EV_PERSIST, accept_socket, http);
! 2334: EVHTTP_BASE_SET(http, ev);
! 2335:
! 2336: res = event_add(ev, NULL);
! 2337:
! 2338: if (res == -1) {
! 2339: free(bound);
! 2340: return (-1);
! 2341: }
! 2342:
! 2343: TAILQ_INSERT_TAIL(&http->sockets, bound, next);
! 2344:
! 2345: return (0);
! 2346: }
! 2347:
! 2348: static struct evhttp*
! 2349: evhttp_new_object(void)
! 2350: {
! 2351: struct evhttp *http = NULL;
! 2352:
! 2353: if ((http = calloc(1, sizeof(struct evhttp))) == NULL) {
! 2354: event_warn("%s: calloc", __func__);
! 2355: return (NULL);
! 2356: }
! 2357:
! 2358: http->timeout = -1;
! 2359:
! 2360: TAILQ_INIT(&http->sockets);
! 2361: TAILQ_INIT(&http->callbacks);
! 2362: TAILQ_INIT(&http->connections);
! 2363:
! 2364: return (http);
! 2365: }
! 2366:
! 2367: struct evhttp *
! 2368: evhttp_new(struct event_base *base)
! 2369: {
! 2370: struct evhttp *http = evhttp_new_object();
! 2371:
! 2372: http->base = base;
! 2373:
! 2374: return (http);
! 2375: }
! 2376:
! 2377: /*
! 2378: * Start a web server on the specified address and port.
! 2379: */
! 2380:
! 2381: struct evhttp *
! 2382: evhttp_start(const char *address, u_short port)
! 2383: {
! 2384: struct evhttp *http = evhttp_new_object();
! 2385:
! 2386: if (evhttp_bind_socket(http, address, port) == -1) {
! 2387: free(http);
! 2388: return (NULL);
! 2389: }
! 2390:
! 2391: return (http);
! 2392: }
! 2393:
! 2394: void
! 2395: evhttp_free(struct evhttp* http)
! 2396: {
! 2397: struct evhttp_cb *http_cb;
! 2398: struct evhttp_connection *evcon;
! 2399: struct evhttp_bound_socket *bound;
! 2400: int fd;
! 2401:
! 2402: /* Remove the accepting part */
! 2403: while ((bound = TAILQ_FIRST(&http->sockets)) != NULL) {
! 2404: TAILQ_REMOVE(&http->sockets, bound, next);
! 2405:
! 2406: fd = bound->bind_ev.ev_fd;
! 2407: event_del(&bound->bind_ev);
! 2408: EVUTIL_CLOSESOCKET(fd);
! 2409:
! 2410: free(bound);
! 2411: }
! 2412:
! 2413: while ((evcon = TAILQ_FIRST(&http->connections)) != NULL) {
! 2414: /* evhttp_connection_free removes the connection */
! 2415: evhttp_connection_free(evcon);
! 2416: }
! 2417:
! 2418: while ((http_cb = TAILQ_FIRST(&http->callbacks)) != NULL) {
! 2419: TAILQ_REMOVE(&http->callbacks, http_cb, next);
! 2420: free(http_cb->what);
! 2421: free(http_cb);
! 2422: }
! 2423:
! 2424: free(http);
! 2425: }
! 2426:
! 2427: void
! 2428: evhttp_set_timeout(struct evhttp* http, int timeout_in_secs)
! 2429: {
! 2430: http->timeout = timeout_in_secs;
! 2431: }
! 2432:
! 2433: void
! 2434: evhttp_set_cb(struct evhttp *http, const char *uri,
! 2435: void (*cb)(struct evhttp_request *, void *), void *cbarg)
! 2436: {
! 2437: struct evhttp_cb *http_cb;
! 2438:
! 2439: if ((http_cb = calloc(1, sizeof(struct evhttp_cb))) == NULL)
! 2440: event_err(1, "%s: calloc", __func__);
! 2441:
! 2442: http_cb->what = strdup(uri);
! 2443: http_cb->cb = cb;
! 2444: http_cb->cbarg = cbarg;
! 2445:
! 2446: TAILQ_INSERT_TAIL(&http->callbacks, http_cb, next);
! 2447: }
! 2448:
! 2449: int
! 2450: evhttp_del_cb(struct evhttp *http, const char *uri)
! 2451: {
! 2452: struct evhttp_cb *http_cb;
! 2453:
! 2454: TAILQ_FOREACH(http_cb, &http->callbacks, next) {
! 2455: if (strcmp(http_cb->what, uri) == 0)
! 2456: break;
! 2457: }
! 2458: if (http_cb == NULL)
! 2459: return (-1);
! 2460:
! 2461: TAILQ_REMOVE(&http->callbacks, http_cb, next);
! 2462: free(http_cb->what);
! 2463: free(http_cb);
! 2464:
! 2465: return (0);
! 2466: }
! 2467:
! 2468: void
! 2469: evhttp_set_gencb(struct evhttp *http,
! 2470: void (*cb)(struct evhttp_request *, void *), void *cbarg)
! 2471: {
! 2472: http->gencb = cb;
! 2473: http->gencbarg = cbarg;
! 2474: }
! 2475:
! 2476: /*
! 2477: * Request related functions
! 2478: */
! 2479:
! 2480: struct evhttp_request *
! 2481: evhttp_request_new(void (*cb)(struct evhttp_request *, void *), void *arg)
! 2482: {
! 2483: struct evhttp_request *req = NULL;
! 2484:
! 2485: /* Allocate request structure */
! 2486: if ((req = calloc(1, sizeof(struct evhttp_request))) == NULL) {
! 2487: event_warn("%s: calloc", __func__);
! 2488: goto error;
! 2489: }
! 2490:
! 2491: req->kind = EVHTTP_RESPONSE;
! 2492: req->input_headers = calloc(1, sizeof(struct evkeyvalq));
! 2493: if (req->input_headers == NULL) {
! 2494: event_warn("%s: calloc", __func__);
! 2495: goto error;
! 2496: }
! 2497: TAILQ_INIT(req->input_headers);
! 2498:
! 2499: req->output_headers = calloc(1, sizeof(struct evkeyvalq));
! 2500: if (req->output_headers == NULL) {
! 2501: event_warn("%s: calloc", __func__);
! 2502: goto error;
! 2503: }
! 2504: TAILQ_INIT(req->output_headers);
! 2505:
! 2506: if ((req->input_buffer = evbuffer_new()) == NULL) {
! 2507: event_warn("%s: evbuffer_new", __func__);
! 2508: goto error;
! 2509: }
! 2510:
! 2511: if ((req->output_buffer = evbuffer_new()) == NULL) {
! 2512: event_warn("%s: evbuffer_new", __func__);
! 2513: goto error;
! 2514: }
! 2515:
! 2516: req->cb = cb;
! 2517: req->cb_arg = arg;
! 2518:
! 2519: return (req);
! 2520:
! 2521: error:
! 2522: if (req != NULL)
! 2523: evhttp_request_free(req);
! 2524: return (NULL);
! 2525: }
! 2526:
! 2527: void
! 2528: evhttp_request_free(struct evhttp_request *req)
! 2529: {
! 2530: if (req->remote_host != NULL)
! 2531: free(req->remote_host);
! 2532: if (req->uri != NULL)
! 2533: free(req->uri);
! 2534: if (req->response_code_line != NULL)
! 2535: free(req->response_code_line);
! 2536:
! 2537: evhttp_clear_headers(req->input_headers);
! 2538: free(req->input_headers);
! 2539:
! 2540: evhttp_clear_headers(req->output_headers);
! 2541: free(req->output_headers);
! 2542:
! 2543: if (req->input_buffer != NULL)
! 2544: evbuffer_free(req->input_buffer);
! 2545:
! 2546: if (req->output_buffer != NULL)
! 2547: evbuffer_free(req->output_buffer);
! 2548:
! 2549: free(req);
! 2550: }
! 2551:
! 2552: struct evhttp_connection *
! 2553: evhttp_request_get_connection(struct evhttp_request *req)
! 2554: {
! 2555: return req->evcon;
! 2556: }
! 2557:
! 2558:
! 2559: void
! 2560: evhttp_request_set_chunked_cb(struct evhttp_request *req,
! 2561: void (*cb)(struct evhttp_request *, void *))
! 2562: {
! 2563: req->chunk_cb = cb;
! 2564: }
! 2565:
! 2566: /*
! 2567: * Allows for inspection of the request URI
! 2568: */
! 2569:
! 2570: const char *
! 2571: evhttp_request_uri(struct evhttp_request *req) {
! 2572: if (req->uri == NULL)
! 2573: event_debug(("%s: request %p has no uri\n", __func__, req));
! 2574: return (req->uri);
! 2575: }
! 2576:
! 2577: /*
! 2578: * Takes a file descriptor to read a request from.
! 2579: * The callback is executed once the whole request has been read.
! 2580: */
! 2581:
! 2582: static struct evhttp_connection*
! 2583: evhttp_get_request_connection(
! 2584: struct evhttp* http,
! 2585: int fd, struct sockaddr *sa, socklen_t salen)
! 2586: {
! 2587: struct evhttp_connection *evcon;
! 2588: char *hostname = NULL, *portname = NULL;
! 2589:
! 2590: name_from_addr(sa, salen, &hostname, &portname);
! 2591: if (hostname == NULL || portname == NULL) {
! 2592: if (hostname) free(hostname);
! 2593: if (portname) free(portname);
! 2594: return (NULL);
! 2595: }
! 2596:
! 2597: event_debug(("%s: new request from %s:%s on %d\n",
! 2598: __func__, hostname, portname, fd));
! 2599:
! 2600: /* we need a connection object to put the http request on */
! 2601: evcon = evhttp_connection_new(hostname, atoi(portname));
! 2602: free(hostname);
! 2603: free(portname);
! 2604: if (evcon == NULL)
! 2605: return (NULL);
! 2606:
! 2607: /* associate the base if we have one*/
! 2608: evhttp_connection_set_base(evcon, http->base);
! 2609:
! 2610: evcon->flags |= EVHTTP_CON_INCOMING;
! 2611: evcon->state = EVCON_READING_FIRSTLINE;
! 2612:
! 2613: evcon->fd = fd;
! 2614:
! 2615: return (evcon);
! 2616: }
! 2617:
! 2618: static int
! 2619: evhttp_associate_new_request_with_connection(struct evhttp_connection *evcon)
! 2620: {
! 2621: struct evhttp *http = evcon->http_server;
! 2622: struct evhttp_request *req;
! 2623: if ((req = evhttp_request_new(evhttp_handle_request, http)) == NULL)
! 2624: return (-1);
! 2625:
! 2626: req->evcon = evcon; /* the request ends up owning the connection */
! 2627: req->flags |= EVHTTP_REQ_OWN_CONNECTION;
! 2628:
! 2629: TAILQ_INSERT_TAIL(&evcon->requests, req, next);
! 2630:
! 2631: req->kind = EVHTTP_REQUEST;
! 2632:
! 2633: if ((req->remote_host = strdup(evcon->address)) == NULL)
! 2634: event_err(1, "%s: strdup", __func__);
! 2635: req->remote_port = evcon->port;
! 2636:
! 2637: evhttp_start_read(evcon);
! 2638:
! 2639: return (0);
! 2640: }
! 2641:
! 2642: void
! 2643: evhttp_get_request(struct evhttp *http, int fd,
! 2644: struct sockaddr *sa, socklen_t salen)
! 2645: {
! 2646: struct evhttp_connection *evcon;
! 2647:
! 2648: evcon = evhttp_get_request_connection(http, fd, sa, salen);
! 2649: if (evcon == NULL)
! 2650: return;
! 2651:
! 2652: /* the timeout can be used by the server to close idle connections */
! 2653: if (http->timeout != -1)
! 2654: evhttp_connection_set_timeout(evcon, http->timeout);
! 2655:
! 2656: /*
! 2657: * if we want to accept more than one request on a connection,
! 2658: * we need to know which http server it belongs to.
! 2659: */
! 2660: evcon->http_server = http;
! 2661: TAILQ_INSERT_TAIL(&http->connections, evcon, next);
! 2662:
! 2663: if (evhttp_associate_new_request_with_connection(evcon) == -1)
! 2664: evhttp_connection_free(evcon);
! 2665: }
! 2666:
! 2667:
! 2668: /*
! 2669: * Network helper functions that we do not want to export to the rest of
! 2670: * the world.
! 2671: */
! 2672: #if 0 /* Unused */
! 2673: static struct addrinfo *
! 2674: addr_from_name(char *address)
! 2675: {
! 2676: #ifdef HAVE_GETADDRINFO
! 2677: struct addrinfo ai, *aitop;
! 2678: int ai_result;
! 2679:
! 2680: memset(&ai, 0, sizeof(ai));
! 2681: ai.ai_family = AF_INET;
! 2682: ai.ai_socktype = SOCK_RAW;
! 2683: ai.ai_flags = 0;
! 2684: if ((ai_result = getaddrinfo(address, NULL, &ai, &aitop)) != 0) {
! 2685: if ( ai_result == EAI_SYSTEM )
! 2686: event_warn("getaddrinfo");
! 2687: else
! 2688: event_warnx("getaddrinfo: %s", gai_strerror(ai_result));
! 2689: }
! 2690:
! 2691: return (aitop);
! 2692: #else
! 2693: assert(0);
! 2694: return NULL; /* XXXXX Use gethostbyname, if this function is ever used. */
! 2695: #endif
! 2696: }
! 2697: #endif
! 2698:
! 2699: static void
! 2700: name_from_addr(struct sockaddr *sa, socklen_t salen,
! 2701: char **phost, char **pport)
! 2702: {
! 2703: char ntop[NI_MAXHOST];
! 2704: char strport[NI_MAXSERV];
! 2705: int ni_result;
! 2706:
! 2707: #ifdef HAVE_GETNAMEINFO
! 2708: ni_result = getnameinfo(sa, salen,
! 2709: ntop, sizeof(ntop), strport, sizeof(strport),
! 2710: NI_NUMERICHOST|NI_NUMERICSERV);
! 2711:
! 2712: if (ni_result != 0) {
! 2713: if (ni_result == EAI_SYSTEM)
! 2714: event_err(1, "getnameinfo failed");
! 2715: else
! 2716: event_errx(1, "getnameinfo failed: %s", gai_strerror(ni_result));
! 2717: return;
! 2718: }
! 2719: #else
! 2720: ni_result = fake_getnameinfo(sa, salen,
! 2721: ntop, sizeof(ntop), strport, sizeof(strport),
! 2722: NI_NUMERICHOST|NI_NUMERICSERV);
! 2723: if (ni_result != 0)
! 2724: return;
! 2725: #endif
! 2726: *phost = strdup(ntop);
! 2727: *pport = strdup(strport);
! 2728: }
! 2729:
! 2730: /* Create a non-blocking socket and bind it */
! 2731: /* todo: rename this function */
! 2732: static int
! 2733: bind_socket_ai(struct addrinfo *ai, int reuse)
! 2734: {
! 2735: int fd, on = 1, r;
! 2736: int serrno;
! 2737:
! 2738: /* Create listen socket */
! 2739: fd = socket(AF_INET, SOCK_STREAM, 0);
! 2740: if (fd == -1) {
! 2741: event_warn("socket");
! 2742: return (-1);
! 2743: }
! 2744:
! 2745: if (evutil_make_socket_nonblocking(fd) < 0)
! 2746: goto out;
! 2747:
! 2748: #ifndef WIN32
! 2749: if (fcntl(fd, F_SETFD, 1) == -1) {
! 2750: event_warn("fcntl(F_SETFD)");
! 2751: goto out;
! 2752: }
! 2753: #endif
! 2754:
! 2755: setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, (void *)&on, sizeof(on));
! 2756: if (reuse) {
! 2757: setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
! 2758: (void *)&on, sizeof(on));
! 2759: }
! 2760:
! 2761: if (ai != NULL) {
! 2762: r = bind(fd, ai->ai_addr, ai->ai_addrlen);
! 2763: if (r == -1)
! 2764: goto out;
! 2765: }
! 2766:
! 2767: return (fd);
! 2768:
! 2769: out:
! 2770: serrno = EVUTIL_SOCKET_ERROR();
! 2771: EVUTIL_CLOSESOCKET(fd);
! 2772: EVUTIL_SET_SOCKET_ERROR(serrno);
! 2773: return (-1);
! 2774: }
! 2775:
! 2776: static struct addrinfo *
! 2777: make_addrinfo(const char *address, u_short port)
! 2778: {
! 2779: struct addrinfo *aitop = NULL;
! 2780:
! 2781: #ifdef HAVE_GETADDRINFO
! 2782: struct addrinfo ai;
! 2783: char strport[NI_MAXSERV];
! 2784: int ai_result;
! 2785:
! 2786: memset(&ai, 0, sizeof(ai));
! 2787: ai.ai_family = AF_INET;
! 2788: ai.ai_socktype = SOCK_STREAM;
! 2789: ai.ai_flags = AI_PASSIVE; /* turn NULL host name into INADDR_ANY */
! 2790: evutil_snprintf(strport, sizeof(strport), "%d", port);
! 2791: if ((ai_result = getaddrinfo(address, strport, &ai, &aitop)) != 0) {
! 2792: if ( ai_result == EAI_SYSTEM )
! 2793: event_warn("getaddrinfo");
! 2794: else
! 2795: event_warnx("getaddrinfo: %s", gai_strerror(ai_result));
! 2796: return (NULL);
! 2797: }
! 2798: #else
! 2799: static int cur;
! 2800: static struct addrinfo ai[2]; /* We will be returning the address of some of this memory so it has to last even after this call. */
! 2801: if (++cur == 2) cur = 0; /* allow calling this function twice */
! 2802:
! 2803: if (fake_getaddrinfo(address, &ai[cur]) < 0) {
! 2804: event_warn("fake_getaddrinfo");
! 2805: return (NULL);
! 2806: }
! 2807: aitop = &ai[cur];
! 2808: ((struct sockaddr_in *) aitop->ai_addr)->sin_port = htons(port);
! 2809: #endif
! 2810:
! 2811: return (aitop);
! 2812: }
! 2813:
! 2814: static int
! 2815: bind_socket(const char *address, u_short port, int reuse)
! 2816: {
! 2817: int fd;
! 2818: struct addrinfo *aitop = NULL;
! 2819:
! 2820: /* just create an unbound socket */
! 2821: if (address == NULL && port == 0)
! 2822: return bind_socket_ai(NULL, 0);
! 2823:
! 2824: aitop = make_addrinfo(address, port);
! 2825:
! 2826: if (aitop == NULL)
! 2827: return (-1);
! 2828:
! 2829: fd = bind_socket_ai(aitop, reuse);
! 2830:
! 2831: #ifdef HAVE_GETADDRINFO
! 2832: freeaddrinfo(aitop);
! 2833: #else
! 2834: fake_freeaddrinfo(aitop);
! 2835: #endif
! 2836:
! 2837: return (fd);
! 2838: }
! 2839:
! 2840: static int
! 2841: socket_connect(int fd, const char *address, unsigned short port)
! 2842: {
! 2843: struct addrinfo *ai = make_addrinfo(address, port);
! 2844: int res = -1;
! 2845:
! 2846: if (ai == NULL) {
! 2847: event_debug(("%s: make_addrinfo: \"%s:%d\"",
! 2848: __func__, address, port));
! 2849: return (-1);
! 2850: }
! 2851:
! 2852: if (connect(fd, ai->ai_addr, ai->ai_addrlen) == -1) {
! 2853: #ifdef WIN32
! 2854: int tmp_error = WSAGetLastError();
! 2855: if (tmp_error != WSAEWOULDBLOCK && tmp_error != WSAEINVAL &&
! 2856: tmp_error != WSAEINPROGRESS) {
! 2857: goto out;
! 2858: }
! 2859: #else
! 2860: if (errno != EINPROGRESS) {
! 2861: goto out;
! 2862: }
! 2863: #endif
! 2864: }
! 2865:
! 2866: /* everything is fine */
! 2867: res = 0;
! 2868:
! 2869: out:
! 2870: #ifdef HAVE_GETADDRINFO
! 2871: freeaddrinfo(ai);
! 2872: #else
! 2873: fake_freeaddrinfo(ai);
! 2874: #endif
! 2875:
! 2876: return (res);
! 2877: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent