Annotation of embedaddon/libevent/test/regress_http.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 2003-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 WIN32
! 29: #include <winsock2.h>
! 30: #include <windows.h>
! 31: #endif
! 32:
! 33: #ifdef HAVE_CONFIG_H
! 34: #include "config.h"
! 35: #endif
! 36:
! 37: #include <sys/types.h>
! 38: #include <sys/stat.h>
! 39: #ifdef HAVE_SYS_TIME_H
! 40: #include <sys/time.h>
! 41: #endif
! 42: #include <sys/queue.h>
! 43: #ifndef WIN32
! 44: #include <sys/socket.h>
! 45: #include <signal.h>
! 46: #include <unistd.h>
! 47: #include <netdb.h>
! 48: #endif
! 49: #include <fcntl.h>
! 50: #include <stdlib.h>
! 51: #include <stdio.h>
! 52: #include <string.h>
! 53: #include <errno.h>
! 54:
! 55: #include "event.h"
! 56: #include "evhttp.h"
! 57: #include "log.h"
! 58: #include "http-internal.h"
! 59:
! 60: extern int pair[];
! 61: extern int test_ok;
! 62:
! 63: static struct evhttp *http;
! 64: /* set if a test needs to call loopexit on a base */
! 65: static struct event_base *base;
! 66:
! 67: void http_suite(void);
! 68:
! 69: void http_basic_cb(struct evhttp_request *req, void *arg);
! 70: static void http_chunked_cb(struct evhttp_request *req, void *arg);
! 71: void http_post_cb(struct evhttp_request *req, void *arg);
! 72: void http_dispatcher_cb(struct evhttp_request *req, void *arg);
! 73: static void http_large_delay_cb(struct evhttp_request *req, void *arg);
! 74: static void http_badreq_cb(struct evhttp_request *req, void *arg);
! 75:
! 76: static struct evhttp *
! 77: http_setup(short *pport, struct event_base *base)
! 78: {
! 79: int i;
! 80: struct evhttp *myhttp;
! 81: short port = -1;
! 82:
! 83: /* Try a few different ports */
! 84: myhttp = evhttp_new(base);
! 85: for (i = 0; i < 50; ++i) {
! 86: if (evhttp_bind_socket(myhttp, "127.0.0.1", 8080 + i) != -1) {
! 87: port = 8080 + i;
! 88: break;
! 89: }
! 90: }
! 91:
! 92: if (port == -1)
! 93: event_errx(1, "Could not start web server");
! 94:
! 95: /* Register a callback for certain types of requests */
! 96: evhttp_set_cb(myhttp, "/test", http_basic_cb, NULL);
! 97: evhttp_set_cb(myhttp, "/chunked", http_chunked_cb, NULL);
! 98: evhttp_set_cb(myhttp, "/postit", http_post_cb, NULL);
! 99: evhttp_set_cb(myhttp, "/largedelay", http_large_delay_cb, NULL);
! 100: evhttp_set_cb(myhttp, "/badrequest", http_badreq_cb, NULL);
! 101: evhttp_set_cb(myhttp, "/", http_dispatcher_cb, NULL);
! 102:
! 103: *pport = port;
! 104: return (myhttp);
! 105: }
! 106:
! 107: #ifndef NI_MAXSERV
! 108: #define NI_MAXSERV 1024
! 109: #endif
! 110:
! 111: static int
! 112: http_connect(const char *address, u_short port)
! 113: {
! 114: /* Stupid code for connecting */
! 115: #ifdef WIN32
! 116: struct hostent *he;
! 117: struct sockaddr_in sin;
! 118: #else
! 119: struct addrinfo ai, *aitop;
! 120: char strport[NI_MAXSERV];
! 121: #endif
! 122: struct sockaddr *sa;
! 123: int slen;
! 124: int fd;
! 125:
! 126: #ifdef WIN32
! 127: if (!(he = gethostbyname(address))) {
! 128: event_warn("gethostbyname");
! 129: }
! 130: memcpy(&sin.sin_addr, he->h_addr_list[0], he->h_length);
! 131: sin.sin_family = AF_INET;
! 132: sin.sin_port = htons(port);
! 133: slen = sizeof(struct sockaddr_in);
! 134: sa = (struct sockaddr*)&sin;
! 135: #else
! 136: memset(&ai, 0, sizeof (ai));
! 137: ai.ai_family = AF_INET;
! 138: ai.ai_socktype = SOCK_STREAM;
! 139: snprintf(strport, sizeof (strport), "%d", port);
! 140: if (getaddrinfo(address, strport, &ai, &aitop) != 0) {
! 141: event_warn("getaddrinfo");
! 142: return (-1);
! 143: }
! 144: sa = aitop->ai_addr;
! 145: slen = aitop->ai_addrlen;
! 146: #endif
! 147:
! 148: fd = socket(AF_INET, SOCK_STREAM, 0);
! 149: if (fd == -1)
! 150: event_err(1, "socket failed");
! 151:
! 152: if (connect(fd, sa, slen) == -1)
! 153: event_err(1, "connect failed");
! 154:
! 155: #ifndef WIN32
! 156: freeaddrinfo(aitop);
! 157: #endif
! 158:
! 159: return (fd);
! 160: }
! 161:
! 162: static void
! 163: http_readcb(struct bufferevent *bev, void *arg)
! 164: {
! 165: const char *what = "This is funny";
! 166:
! 167: event_debug(("%s: %s\n", __func__, EVBUFFER_DATA(bev->input)));
! 168:
! 169: if (evbuffer_find(bev->input,
! 170: (const unsigned char*) what, strlen(what)) != NULL) {
! 171: struct evhttp_request *req = evhttp_request_new(NULL, NULL);
! 172: enum message_read_status done;
! 173:
! 174: req->kind = EVHTTP_RESPONSE;
! 175: done = evhttp_parse_firstline(req, bev->input);
! 176: if (done != ALL_DATA_READ)
! 177: goto out;
! 178:
! 179: done = evhttp_parse_headers(req, bev->input);
! 180: if (done != ALL_DATA_READ)
! 181: goto out;
! 182:
! 183: if (done == 1 &&
! 184: evhttp_find_header(req->input_headers,
! 185: "Content-Type") != NULL)
! 186: test_ok++;
! 187:
! 188: out:
! 189: evhttp_request_free(req);
! 190: bufferevent_disable(bev, EV_READ);
! 191: if (base)
! 192: event_base_loopexit(base, NULL);
! 193: else
! 194: event_loopexit(NULL);
! 195: }
! 196: }
! 197:
! 198: static void
! 199: http_writecb(struct bufferevent *bev, void *arg)
! 200: {
! 201: if (EVBUFFER_LENGTH(bev->output) == 0) {
! 202: /* enable reading of the reply */
! 203: bufferevent_enable(bev, EV_READ);
! 204: test_ok++;
! 205: }
! 206: }
! 207:
! 208: static void
! 209: http_errorcb(struct bufferevent *bev, short what, void *arg)
! 210: {
! 211: test_ok = -2;
! 212: event_loopexit(NULL);
! 213: }
! 214:
! 215: void
! 216: http_basic_cb(struct evhttp_request *req, void *arg)
! 217: {
! 218: struct evbuffer *evb = evbuffer_new();
! 219: int empty = evhttp_find_header(req->input_headers, "Empty") != NULL;
! 220: event_debug(("%s: called\n", __func__));
! 221: evbuffer_add_printf(evb, "This is funny");
! 222:
! 223: /* For multi-line headers test */
! 224: {
! 225: const char *multi =
! 226: evhttp_find_header(req->input_headers,"X-multi");
! 227: if (multi) {
! 228: if (strcmp("END", multi + strlen(multi) - 3) == 0)
! 229: test_ok++;
! 230: if (evhttp_find_header(req->input_headers, "X-Last"))
! 231: test_ok++;
! 232: }
! 233: }
! 234:
! 235: /* injecting a bad content-length */
! 236: if (evhttp_find_header(req->input_headers, "X-Negative"))
! 237: evhttp_add_header(req->output_headers,
! 238: "Content-Length", "-100");
! 239:
! 240: /* allow sending of an empty reply */
! 241: evhttp_send_reply(req, HTTP_OK, "Everything is fine",
! 242: !empty ? evb : NULL);
! 243:
! 244: evbuffer_free(evb);
! 245: }
! 246:
! 247: static char const* const CHUNKS[] = {
! 248: "This is funny",
! 249: "but not hilarious.",
! 250: "bwv 1052"
! 251: };
! 252:
! 253: struct chunk_req_state {
! 254: struct evhttp_request *req;
! 255: int i;
! 256: };
! 257:
! 258: static void
! 259: http_chunked_trickle_cb(int fd, short events, void *arg)
! 260: {
! 261: struct evbuffer *evb = evbuffer_new();
! 262: struct chunk_req_state *state = arg;
! 263: struct timeval when = { 0, 0 };
! 264:
! 265: evbuffer_add_printf(evb, "%s", CHUNKS[state->i]);
! 266: evhttp_send_reply_chunk(state->req, evb);
! 267: evbuffer_free(evb);
! 268:
! 269: if (++state->i < sizeof(CHUNKS)/sizeof(CHUNKS[0])) {
! 270: event_once(-1, EV_TIMEOUT,
! 271: http_chunked_trickle_cb, state, &when);
! 272: } else {
! 273: evhttp_send_reply_end(state->req);
! 274: free(state);
! 275: }
! 276: }
! 277:
! 278: static void
! 279: http_chunked_cb(struct evhttp_request *req, void *arg)
! 280: {
! 281: struct timeval when = { 0, 0 };
! 282: struct chunk_req_state *state = malloc(sizeof(struct chunk_req_state));
! 283: event_debug(("%s: called\n", __func__));
! 284:
! 285: memset(state, 0, sizeof(struct chunk_req_state));
! 286: state->req = req;
! 287:
! 288: /* generate a chunked reply */
! 289: evhttp_send_reply_start(req, HTTP_OK, "Everything is fine");
! 290:
! 291: /* but trickle it across several iterations to ensure we're not
! 292: * assuming it comes all at once */
! 293: event_once(-1, EV_TIMEOUT, http_chunked_trickle_cb, state, &when);
! 294: }
! 295:
! 296: static void
! 297: http_complete_write(int fd, short what, void *arg)
! 298: {
! 299: struct bufferevent *bev = arg;
! 300: const char *http_request = "host\r\n"
! 301: "Connection: close\r\n"
! 302: "\r\n";
! 303: bufferevent_write(bev, http_request, strlen(http_request));
! 304: }
! 305:
! 306: static void
! 307: http_basic_test(void)
! 308: {
! 309: struct timeval tv;
! 310: struct bufferevent *bev;
! 311: int fd;
! 312: const char *http_request;
! 313: short port = -1;
! 314:
! 315: test_ok = 0;
! 316: fprintf(stdout, "Testing Basic HTTP Server: ");
! 317:
! 318: http = http_setup(&port, NULL);
! 319:
! 320: /* bind to a second socket */
! 321: if (evhttp_bind_socket(http, "127.0.0.1", port + 1) == -1) {
! 322: fprintf(stdout, "FAILED (bind)\n");
! 323: exit(1);
! 324: }
! 325:
! 326: fd = http_connect("127.0.0.1", port);
! 327:
! 328: /* Stupid thing to send a request */
! 329: bev = bufferevent_new(fd, http_readcb, http_writecb,
! 330: http_errorcb, NULL);
! 331:
! 332: /* first half of the http request */
! 333: http_request =
! 334: "GET /test HTTP/1.1\r\n"
! 335: "Host: some";
! 336:
! 337: bufferevent_write(bev, http_request, strlen(http_request));
! 338: timerclear(&tv);
! 339: tv.tv_usec = 10000;
! 340: event_once(-1, EV_TIMEOUT, http_complete_write, bev, &tv);
! 341:
! 342: event_dispatch();
! 343:
! 344: if (test_ok != 3) {
! 345: fprintf(stdout, "FAILED\n");
! 346: exit(1);
! 347: }
! 348:
! 349: /* connect to the second port */
! 350: bufferevent_free(bev);
! 351: EVUTIL_CLOSESOCKET(fd);
! 352:
! 353: fd = http_connect("127.0.0.1", port + 1);
! 354:
! 355: /* Stupid thing to send a request */
! 356: bev = bufferevent_new(fd, http_readcb, http_writecb,
! 357: http_errorcb, NULL);
! 358:
! 359: http_request =
! 360: "GET /test HTTP/1.1\r\n"
! 361: "Host: somehost\r\n"
! 362: "Connection: close\r\n"
! 363: "\r\n";
! 364:
! 365: bufferevent_write(bev, http_request, strlen(http_request));
! 366:
! 367: event_dispatch();
! 368:
! 369: bufferevent_free(bev);
! 370: EVUTIL_CLOSESOCKET(fd);
! 371:
! 372: evhttp_free(http);
! 373:
! 374: if (test_ok != 5) {
! 375: fprintf(stdout, "FAILED\n");
! 376: exit(1);
! 377: }
! 378:
! 379: fprintf(stdout, "OK\n");
! 380: }
! 381:
! 382: static void
! 383: http_badreq_cb(struct evhttp_request *req, void *arg)
! 384: {
! 385: struct evbuffer *buf = evbuffer_new();
! 386:
! 387: evhttp_add_header(req->output_headers, "Content-Type", "text/xml; charset=UTF-8");
! 388: evbuffer_add_printf(buf, "Hello, %s!", "127.0.0.1");
! 389:
! 390: evhttp_send_reply(req, HTTP_OK, "OK", buf);
! 391: evbuffer_free(buf);
! 392: }
! 393:
! 394: static void
! 395: http_badreq_errorcb(struct bufferevent *bev, short what, void *arg)
! 396: {
! 397: event_debug(("%s: called (what=%04x, arg=%p)", __func__, what, arg));
! 398: /* ignore */
! 399: }
! 400:
! 401: static void
! 402: http_badreq_readcb(struct bufferevent *bev, void *arg)
! 403: {
! 404: const char *what = "Hello, 127.0.0.1";
! 405: const char *bad_request = "400 Bad Request";
! 406:
! 407: event_debug(("%s: %s\n", __func__, EVBUFFER_DATA(bev->input)));
! 408:
! 409: if (evbuffer_find(bev->input,
! 410: (const unsigned char *) bad_request, strlen(bad_request)) != NULL) {
! 411: event_debug(("%s: bad request detected", __func__));
! 412: test_ok = -10;
! 413: bufferevent_disable(bev, EV_READ);
! 414: event_loopexit(NULL);
! 415: return;
! 416: }
! 417:
! 418: if (evbuffer_find(bev->input,
! 419: (const unsigned char*) what, strlen(what)) != NULL) {
! 420: struct evhttp_request *req = evhttp_request_new(NULL, NULL);
! 421: enum message_read_status done;
! 422:
! 423: req->kind = EVHTTP_RESPONSE;
! 424: done = evhttp_parse_firstline(req, bev->input);
! 425: if (done != ALL_DATA_READ)
! 426: goto out;
! 427:
! 428: done = evhttp_parse_headers(req, bev->input);
! 429: if (done != ALL_DATA_READ)
! 430: goto out;
! 431:
! 432: if (done == 1 &&
! 433: evhttp_find_header(req->input_headers,
! 434: "Content-Type") != NULL)
! 435: test_ok++;
! 436:
! 437: out:
! 438: evhttp_request_free(req);
! 439: evbuffer_drain(bev->input, EVBUFFER_LENGTH(bev->input));
! 440: }
! 441:
! 442: shutdown(bev->ev_read.ev_fd, SHUT_WR);
! 443: }
! 444:
! 445: static void
! 446: http_badreq_successcb(int fd, short what, void *arg)
! 447: {
! 448: event_debug(("%s: called (what=%04x, arg=%p)", __func__, what, arg));
! 449: event_loopexit(NULL);
! 450: }
! 451:
! 452: static void
! 453: http_bad_request(void)
! 454: {
! 455: struct timeval tv;
! 456: struct bufferevent *bev;
! 457: int fd;
! 458: const char *http_request;
! 459: short port = -1;
! 460:
! 461: test_ok = 0;
! 462: fprintf(stdout, "Testing \"Bad Request\" on connection close: ");
! 463:
! 464: http = http_setup(&port, NULL);
! 465:
! 466: /* bind to a second socket */
! 467: if (evhttp_bind_socket(http, "127.0.0.1", port + 1) == -1) {
! 468: fprintf(stdout, "FAILED (bind)\n");
! 469: exit(1);
! 470: }
! 471:
! 472: /* NULL request test */
! 473: fd = http_connect("127.0.0.1", port);
! 474:
! 475: /* Stupid thing to send a request */
! 476: bev = bufferevent_new(fd, http_badreq_readcb, http_writecb,
! 477: http_badreq_errorcb, NULL);
! 478: bufferevent_enable(bev, EV_READ);
! 479:
! 480: /* real NULL request */
! 481: http_request = "";
! 482:
! 483: shutdown(fd, SHUT_WR);
! 484: timerclear(&tv);
! 485: tv.tv_usec = 10000;
! 486: event_once(-1, EV_TIMEOUT, http_badreq_successcb, bev, &tv);
! 487:
! 488: event_dispatch();
! 489:
! 490: bufferevent_free(bev);
! 491: EVUTIL_CLOSESOCKET(fd);
! 492:
! 493: if (test_ok != 0) {
! 494: fprintf(stdout, "FAILED\n");
! 495: exit(1);
! 496: }
! 497:
! 498: /* Second answer (BAD REQUEST) on connection close */
! 499:
! 500: /* connect to the second port */
! 501: fd = http_connect("127.0.0.1", port + 1);
! 502:
! 503: /* Stupid thing to send a request */
! 504: bev = bufferevent_new(fd, http_badreq_readcb, http_writecb,
! 505: http_badreq_errorcb, NULL);
! 506: bufferevent_enable(bev, EV_READ);
! 507:
! 508: /* first half of the http request */
! 509: http_request =
! 510: "GET /badrequest HTTP/1.0\r\n" \
! 511: "Connection: Keep-Alive\r\n" \
! 512: "\r\n";
! 513:
! 514: bufferevent_write(bev, http_request, strlen(http_request));
! 515:
! 516: timerclear(&tv);
! 517: tv.tv_usec = 10000;
! 518: event_once(-1, EV_TIMEOUT, http_badreq_successcb, bev, &tv);
! 519:
! 520: event_dispatch();
! 521:
! 522: evhttp_free(http);
! 523:
! 524: if (test_ok != 2) {
! 525: fprintf(stdout, "FAILED\n");
! 526: exit(1);
! 527: }
! 528:
! 529: fprintf(stdout, "OK\n");
! 530: }
! 531: static struct evhttp_connection *delayed_client;
! 532:
! 533: static void
! 534: http_delay_reply(int fd, short what, void *arg)
! 535: {
! 536: struct evhttp_request *req = arg;
! 537:
! 538: evhttp_send_reply(req, HTTP_OK, "Everything is fine", NULL);
! 539:
! 540: ++test_ok;
! 541: }
! 542:
! 543: static void
! 544: http_large_delay_cb(struct evhttp_request *req, void *arg)
! 545: {
! 546: struct timeval tv;
! 547: timerclear(&tv);
! 548: tv.tv_sec = 3;
! 549:
! 550: event_once(-1, EV_TIMEOUT, http_delay_reply, req, &tv);
! 551:
! 552: /* here we close the client connection which will cause an EOF */
! 553: evhttp_connection_fail(delayed_client, EVCON_HTTP_EOF);
! 554: }
! 555:
! 556: void http_request_done(struct evhttp_request *, void *);
! 557: void http_request_empty_done(struct evhttp_request *, void *);
! 558:
! 559: static void
! 560: http_connection_test(int persistent)
! 561: {
! 562: short port = -1;
! 563: struct evhttp_connection *evcon = NULL;
! 564: struct evhttp_request *req = NULL;
! 565:
! 566: test_ok = 0;
! 567: fprintf(stdout, "Testing Request Connection Pipeline %s: ",
! 568: persistent ? "(persistent)" : "");
! 569:
! 570: http = http_setup(&port, NULL);
! 571:
! 572: evcon = evhttp_connection_new("127.0.0.1", port);
! 573: if (evcon == NULL) {
! 574: fprintf(stdout, "FAILED\n");
! 575: exit(1);
! 576: }
! 577:
! 578: /*
! 579: * At this point, we want to schedule a request to the HTTP
! 580: * server using our make request method.
! 581: */
! 582:
! 583: req = evhttp_request_new(http_request_done, NULL);
! 584:
! 585: /* Add the information that we care about */
! 586: evhttp_add_header(req->output_headers, "Host", "somehost");
! 587:
! 588: /* We give ownership of the request to the connection */
! 589: if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) {
! 590: fprintf(stdout, "FAILED\n");
! 591: exit(1);
! 592: }
! 593:
! 594: event_dispatch();
! 595:
! 596: if (test_ok != 1) {
! 597: fprintf(stdout, "FAILED\n");
! 598: exit(1);
! 599: }
! 600:
! 601: /* try to make another request over the same connection */
! 602: test_ok = 0;
! 603:
! 604: req = evhttp_request_new(http_request_done, NULL);
! 605:
! 606: /* Add the information that we care about */
! 607: evhttp_add_header(req->output_headers, "Host", "somehost");
! 608:
! 609: /*
! 610: * if our connections are not supposed to be persistent; request
! 611: * a close from the server.
! 612: */
! 613: if (!persistent)
! 614: evhttp_add_header(req->output_headers, "Connection", "close");
! 615:
! 616: /* We give ownership of the request to the connection */
! 617: if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) {
! 618: fprintf(stdout, "FAILED\n");
! 619: exit(1);
! 620: }
! 621:
! 622: event_dispatch();
! 623:
! 624: /* make another request: request empty reply */
! 625: test_ok = 0;
! 626:
! 627: req = evhttp_request_new(http_request_empty_done, NULL);
! 628:
! 629: /* Add the information that we care about */
! 630: evhttp_add_header(req->output_headers, "Empty", "itis");
! 631:
! 632: /* We give ownership of the request to the connection */
! 633: if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) {
! 634: fprintf(stdout, "FAILED\n");
! 635: exit(1);
! 636: }
! 637:
! 638: event_dispatch();
! 639:
! 640: if (test_ok != 1) {
! 641: fprintf(stdout, "FAILED\n");
! 642: exit(1);
! 643: }
! 644:
! 645: evhttp_connection_free(evcon);
! 646: evhttp_free(http);
! 647:
! 648: fprintf(stdout, "OK\n");
! 649: }
! 650:
! 651: void
! 652: http_request_done(struct evhttp_request *req, void *arg)
! 653: {
! 654: const char *what = "This is funny";
! 655:
! 656: if (req->response_code != HTTP_OK) {
! 657: fprintf(stderr, "FAILED\n");
! 658: exit(1);
! 659: }
! 660:
! 661: if (evhttp_find_header(req->input_headers, "Content-Type") == NULL) {
! 662: fprintf(stderr, "FAILED\n");
! 663: exit(1);
! 664: }
! 665:
! 666: if (EVBUFFER_LENGTH(req->input_buffer) != strlen(what)) {
! 667: fprintf(stderr, "FAILED\n");
! 668: exit(1);
! 669: }
! 670:
! 671: if (memcmp(EVBUFFER_DATA(req->input_buffer), what, strlen(what)) != 0) {
! 672: fprintf(stderr, "FAILED\n");
! 673: exit(1);
! 674: }
! 675:
! 676: test_ok = 1;
! 677: event_loopexit(NULL);
! 678: }
! 679:
! 680: /* test date header and content length */
! 681:
! 682: void
! 683: http_request_empty_done(struct evhttp_request *req, void *arg)
! 684: {
! 685: if (req->response_code != HTTP_OK) {
! 686: fprintf(stderr, "FAILED\n");
! 687: exit(1);
! 688: }
! 689:
! 690: if (evhttp_find_header(req->input_headers, "Date") == NULL) {
! 691: fprintf(stderr, "FAILED\n");
! 692: exit(1);
! 693: }
! 694:
! 695:
! 696: if (evhttp_find_header(req->input_headers, "Content-Length") == NULL) {
! 697: fprintf(stderr, "FAILED\n");
! 698: exit(1);
! 699: }
! 700:
! 701: if (strcmp(evhttp_find_header(req->input_headers, "Content-Length"),
! 702: "0")) {
! 703: fprintf(stderr, "FAILED\n");
! 704: exit(1);
! 705: }
! 706:
! 707: if (EVBUFFER_LENGTH(req->input_buffer) != 0) {
! 708: fprintf(stderr, "FAILED\n");
! 709: exit(1);
! 710: }
! 711:
! 712: test_ok = 1;
! 713: event_loopexit(NULL);
! 714: }
! 715:
! 716: /*
! 717: * HTTP DISPATCHER test
! 718: */
! 719:
! 720: void
! 721: http_dispatcher_cb(struct evhttp_request *req, void *arg)
! 722: {
! 723:
! 724: struct evbuffer *evb = evbuffer_new();
! 725: event_debug(("%s: called\n", __func__));
! 726: evbuffer_add_printf(evb, "DISPATCHER_TEST");
! 727:
! 728: evhttp_send_reply(req, HTTP_OK, "Everything is fine", evb);
! 729:
! 730: evbuffer_free(evb);
! 731: }
! 732:
! 733: static void
! 734: http_dispatcher_test_done(struct evhttp_request *req, void *arg)
! 735: {
! 736: const char *what = "DISPATCHER_TEST";
! 737:
! 738: if (req->response_code != HTTP_OK) {
! 739: fprintf(stderr, "FAILED\n");
! 740: exit(1);
! 741: }
! 742:
! 743: if (evhttp_find_header(req->input_headers, "Content-Type") == NULL) {
! 744: fprintf(stderr, "FAILED (content type)\n");
! 745: exit(1);
! 746: }
! 747:
! 748: if (EVBUFFER_LENGTH(req->input_buffer) != strlen(what)) {
! 749: fprintf(stderr, "FAILED (length %zu vs %zu)\n",
! 750: EVBUFFER_LENGTH(req->input_buffer), strlen(what));
! 751: exit(1);
! 752: }
! 753:
! 754: if (memcmp(EVBUFFER_DATA(req->input_buffer), what, strlen(what)) != 0) {
! 755: fprintf(stderr, "FAILED (data)\n");
! 756: exit(1);
! 757: }
! 758:
! 759: test_ok = 1;
! 760: event_loopexit(NULL);
! 761: }
! 762:
! 763: static void
! 764: http_dispatcher_test(void)
! 765: {
! 766: short port = -1;
! 767: struct evhttp_connection *evcon = NULL;
! 768: struct evhttp_request *req = NULL;
! 769:
! 770: test_ok = 0;
! 771: fprintf(stdout, "Testing HTTP Dispatcher: ");
! 772:
! 773: http = http_setup(&port, NULL);
! 774:
! 775: evcon = evhttp_connection_new("127.0.0.1", port);
! 776: if (evcon == NULL) {
! 777: fprintf(stdout, "FAILED\n");
! 778: exit(1);
! 779: }
! 780:
! 781: /* also bind to local host */
! 782: evhttp_connection_set_local_address(evcon, "127.0.0.1");
! 783:
! 784: /*
! 785: * At this point, we want to schedule an HTTP GET request
! 786: * server using our make request method.
! 787: */
! 788:
! 789: req = evhttp_request_new(http_dispatcher_test_done, NULL);
! 790: if (req == NULL) {
! 791: fprintf(stdout, "FAILED\n");
! 792: exit(1);
! 793: }
! 794:
! 795: /* Add the information that we care about */
! 796: evhttp_add_header(req->output_headers, "Host", "somehost");
! 797:
! 798: if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/?arg=val") == -1) {
! 799: fprintf(stdout, "FAILED\n");
! 800: exit(1);
! 801: }
! 802:
! 803: event_dispatch();
! 804:
! 805: evhttp_connection_free(evcon);
! 806: evhttp_free(http);
! 807:
! 808: if (test_ok != 1) {
! 809: fprintf(stdout, "FAILED: %d\n", test_ok);
! 810: exit(1);
! 811: }
! 812:
! 813: fprintf(stdout, "OK\n");
! 814: }
! 815:
! 816: /*
! 817: * HTTP POST test.
! 818: */
! 819:
! 820: void http_postrequest_done(struct evhttp_request *, void *);
! 821:
! 822: #define POST_DATA "Okay. Not really printf"
! 823:
! 824: static void
! 825: http_post_test(void)
! 826: {
! 827: short port = -1;
! 828: struct evhttp_connection *evcon = NULL;
! 829: struct evhttp_request *req = NULL;
! 830:
! 831: test_ok = 0;
! 832: fprintf(stdout, "Testing HTTP POST Request: ");
! 833:
! 834: http = http_setup(&port, NULL);
! 835:
! 836: evcon = evhttp_connection_new("127.0.0.1", port);
! 837: if (evcon == NULL) {
! 838: fprintf(stdout, "FAILED\n");
! 839: exit(1);
! 840: }
! 841:
! 842: /*
! 843: * At this point, we want to schedule an HTTP POST request
! 844: * server using our make request method.
! 845: */
! 846:
! 847: req = evhttp_request_new(http_postrequest_done, NULL);
! 848: if (req == NULL) {
! 849: fprintf(stdout, "FAILED\n");
! 850: exit(1);
! 851: }
! 852:
! 853: /* Add the information that we care about */
! 854: evhttp_add_header(req->output_headers, "Host", "somehost");
! 855: evbuffer_add_printf(req->output_buffer, POST_DATA);
! 856:
! 857: if (evhttp_make_request(evcon, req, EVHTTP_REQ_POST, "/postit") == -1) {
! 858: fprintf(stdout, "FAILED\n");
! 859: exit(1);
! 860: }
! 861:
! 862: event_dispatch();
! 863:
! 864: evhttp_connection_free(evcon);
! 865: evhttp_free(http);
! 866:
! 867: if (test_ok != 1) {
! 868: fprintf(stdout, "FAILED: %d\n", test_ok);
! 869: exit(1);
! 870: }
! 871:
! 872: fprintf(stdout, "OK\n");
! 873: }
! 874:
! 875: void
! 876: http_post_cb(struct evhttp_request *req, void *arg)
! 877: {
! 878: struct evbuffer *evb;
! 879: event_debug(("%s: called\n", __func__));
! 880:
! 881: /* Yes, we are expecting a post request */
! 882: if (req->type != EVHTTP_REQ_POST) {
! 883: fprintf(stdout, "FAILED (post type)\n");
! 884: exit(1);
! 885: }
! 886:
! 887: if (EVBUFFER_LENGTH(req->input_buffer) != strlen(POST_DATA)) {
! 888: fprintf(stdout, "FAILED (length: %zu vs %zu)\n",
! 889: EVBUFFER_LENGTH(req->input_buffer), strlen(POST_DATA));
! 890: exit(1);
! 891: }
! 892:
! 893: if (memcmp(EVBUFFER_DATA(req->input_buffer), POST_DATA,
! 894: strlen(POST_DATA))) {
! 895: fprintf(stdout, "FAILED (data)\n");
! 896: fprintf(stdout, "Got :%s\n", EVBUFFER_DATA(req->input_buffer));
! 897: fprintf(stdout, "Want:%s\n", POST_DATA);
! 898: exit(1);
! 899: }
! 900:
! 901: evb = evbuffer_new();
! 902: evbuffer_add_printf(evb, "This is funny");
! 903:
! 904: evhttp_send_reply(req, HTTP_OK, "Everything is fine", evb);
! 905:
! 906: evbuffer_free(evb);
! 907: }
! 908:
! 909: void
! 910: http_postrequest_done(struct evhttp_request *req, void *arg)
! 911: {
! 912: const char *what = "This is funny";
! 913:
! 914: if (req == NULL) {
! 915: fprintf(stderr, "FAILED (timeout)\n");
! 916: exit(1);
! 917: }
! 918:
! 919: if (req->response_code != HTTP_OK) {
! 920:
! 921: fprintf(stderr, "FAILED (response code)\n");
! 922: exit(1);
! 923: }
! 924:
! 925: if (evhttp_find_header(req->input_headers, "Content-Type") == NULL) {
! 926: fprintf(stderr, "FAILED (content type)\n");
! 927: exit(1);
! 928: }
! 929:
! 930: if (EVBUFFER_LENGTH(req->input_buffer) != strlen(what)) {
! 931: fprintf(stderr, "FAILED (length %zu vs %zu)\n",
! 932: EVBUFFER_LENGTH(req->input_buffer), strlen(what));
! 933: exit(1);
! 934: }
! 935:
! 936: if (memcmp(EVBUFFER_DATA(req->input_buffer), what, strlen(what)) != 0) {
! 937: fprintf(stderr, "FAILED (data)\n");
! 938: exit(1);
! 939: }
! 940:
! 941: test_ok = 1;
! 942: event_loopexit(NULL);
! 943: }
! 944:
! 945: static void
! 946: http_failure_readcb(struct bufferevent *bev, void *arg)
! 947: {
! 948: const char *what = "400 Bad Request";
! 949: if (evbuffer_find(bev->input, (const unsigned char*) what, strlen(what)) != NULL) {
! 950: test_ok = 2;
! 951: bufferevent_disable(bev, EV_READ);
! 952: event_loopexit(NULL);
! 953: }
! 954: }
! 955:
! 956: /*
! 957: * Testing that the HTTP server can deal with a malformed request.
! 958: */
! 959: static void
! 960: http_failure_test(void)
! 961: {
! 962: struct bufferevent *bev;
! 963: int fd;
! 964: const char *http_request;
! 965: short port = -1;
! 966:
! 967: test_ok = 0;
! 968: fprintf(stdout, "Testing Bad HTTP Request: ");
! 969:
! 970: http = http_setup(&port, NULL);
! 971:
! 972: fd = http_connect("127.0.0.1", port);
! 973:
! 974: /* Stupid thing to send a request */
! 975: bev = bufferevent_new(fd, http_failure_readcb, http_writecb,
! 976: http_errorcb, NULL);
! 977:
! 978: http_request = "illegal request\r\n";
! 979:
! 980: bufferevent_write(bev, http_request, strlen(http_request));
! 981:
! 982: event_dispatch();
! 983:
! 984: bufferevent_free(bev);
! 985: EVUTIL_CLOSESOCKET(fd);
! 986:
! 987: evhttp_free(http);
! 988:
! 989: if (test_ok != 2) {
! 990: fprintf(stdout, "FAILED\n");
! 991: exit(1);
! 992: }
! 993:
! 994: fprintf(stdout, "OK\n");
! 995: }
! 996:
! 997: static void
! 998: close_detect_done(struct evhttp_request *req, void *arg)
! 999: {
! 1000: struct timeval tv;
! 1001: if (req == NULL || req->response_code != HTTP_OK) {
! 1002:
! 1003: fprintf(stderr, "FAILED\n");
! 1004: exit(1);
! 1005: }
! 1006:
! 1007: test_ok = 1;
! 1008:
! 1009: timerclear(&tv);
! 1010: tv.tv_sec = 3; /* longer than the http time out */
! 1011:
! 1012: event_loopexit(&tv);
! 1013: }
! 1014:
! 1015: static void
! 1016: close_detect_launch(int fd, short what, void *arg)
! 1017: {
! 1018: struct evhttp_connection *evcon = arg;
! 1019: struct evhttp_request *req;
! 1020:
! 1021: req = evhttp_request_new(close_detect_done, NULL);
! 1022:
! 1023: /* Add the information that we care about */
! 1024: evhttp_add_header(req->output_headers, "Host", "somehost");
! 1025:
! 1026: /* We give ownership of the request to the connection */
! 1027: if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) {
! 1028: fprintf(stdout, "FAILED\n");
! 1029: exit(1);
! 1030: }
! 1031: }
! 1032:
! 1033: static void
! 1034: close_detect_cb(struct evhttp_request *req, void *arg)
! 1035: {
! 1036: struct evhttp_connection *evcon = arg;
! 1037: struct timeval tv;
! 1038:
! 1039: if (req != NULL && req->response_code != HTTP_OK) {
! 1040:
! 1041: fprintf(stderr, "FAILED\n");
! 1042: exit(1);
! 1043: }
! 1044:
! 1045: timerclear(&tv);
! 1046: tv.tv_sec = 3; /* longer than the http time out */
! 1047:
! 1048: /* launch a new request on the persistent connection in 6 seconds */
! 1049: event_once(-1, EV_TIMEOUT, close_detect_launch, evcon, &tv);
! 1050: }
! 1051:
! 1052:
! 1053: static void
! 1054: http_close_detection(int with_delay)
! 1055: {
! 1056: short port = -1;
! 1057: struct evhttp_connection *evcon = NULL;
! 1058: struct evhttp_request *req = NULL;
! 1059:
! 1060: test_ok = 0;
! 1061: fprintf(stdout, "Testing Connection Close Detection%s: ",
! 1062: with_delay ? " (with delay)" : "");
! 1063:
! 1064: http = http_setup(&port, NULL);
! 1065:
! 1066: /* 2 second timeout */
! 1067: evhttp_set_timeout(http, 2);
! 1068:
! 1069: evcon = evhttp_connection_new("127.0.0.1", port);
! 1070: if (evcon == NULL) {
! 1071: fprintf(stdout, "FAILED\n");
! 1072: exit(1);
! 1073: }
! 1074:
! 1075: delayed_client = evcon;
! 1076:
! 1077: /*
! 1078: * At this point, we want to schedule a request to the HTTP
! 1079: * server using our make request method.
! 1080: */
! 1081:
! 1082: req = evhttp_request_new(close_detect_cb, evcon);
! 1083:
! 1084: /* Add the information that we care about */
! 1085: evhttp_add_header(req->output_headers, "Host", "somehost");
! 1086:
! 1087: /* We give ownership of the request to the connection */
! 1088: if (evhttp_make_request(evcon,
! 1089: req, EVHTTP_REQ_GET, with_delay ? "/largedelay" : "/test") == -1) {
! 1090: fprintf(stdout, "FAILED\n");
! 1091: exit(1);
! 1092: }
! 1093:
! 1094: event_dispatch();
! 1095:
! 1096: if (test_ok != 1) {
! 1097: fprintf(stdout, "FAILED\n");
! 1098: exit(1);
! 1099: }
! 1100:
! 1101: /* at this point, the http server should have no connection */
! 1102: if (TAILQ_FIRST(&http->connections) != NULL) {
! 1103: fprintf(stdout, "FAILED (left connections)\n");
! 1104: exit(1);
! 1105: }
! 1106:
! 1107: evhttp_connection_free(evcon);
! 1108: evhttp_free(http);
! 1109:
! 1110: fprintf(stdout, "OK\n");
! 1111: }
! 1112:
! 1113: static void
! 1114: http_highport_test(void)
! 1115: {
! 1116: int i = -1;
! 1117: struct evhttp *myhttp = NULL;
! 1118:
! 1119: fprintf(stdout, "Testing HTTP Server with high port: ");
! 1120:
! 1121: /* Try a few different ports */
! 1122: for (i = 0; i < 50; ++i) {
! 1123: myhttp = evhttp_start("127.0.0.1", 65535 - i);
! 1124: if (myhttp != NULL) {
! 1125: fprintf(stdout, "OK\n");
! 1126: evhttp_free(myhttp);
! 1127: return;
! 1128: }
! 1129: }
! 1130:
! 1131: fprintf(stdout, "FAILED\n");
! 1132: exit(1);
! 1133: }
! 1134:
! 1135: static void
! 1136: http_bad_header_test(void)
! 1137: {
! 1138: struct evkeyvalq headers;
! 1139:
! 1140: fprintf(stdout, "Testing HTTP Header filtering: ");
! 1141:
! 1142: TAILQ_INIT(&headers);
! 1143:
! 1144: if (evhttp_add_header(&headers, "One", "Two") != 0)
! 1145: goto fail;
! 1146:
! 1147: if (evhttp_add_header(&headers, "One\r", "Two") != -1)
! 1148: goto fail;
! 1149: if (evhttp_add_header(&headers, "One", "Two") != 0)
! 1150: goto fail;
! 1151: if (evhttp_add_header(&headers, "One", "Two\r\n Three") != 0)
! 1152: goto fail;
! 1153: if (evhttp_add_header(&headers, "One\r", "Two") != -1)
! 1154: goto fail;
! 1155: if (evhttp_add_header(&headers, "One\n", "Two") != -1)
! 1156: goto fail;
! 1157: if (evhttp_add_header(&headers, "One", "Two\r") != -1)
! 1158: goto fail;
! 1159: if (evhttp_add_header(&headers, "One", "Two\n") != -1)
! 1160: goto fail;
! 1161:
! 1162: evhttp_clear_headers(&headers);
! 1163:
! 1164: fprintf(stdout, "OK\n");
! 1165: return;
! 1166: fail:
! 1167: fprintf(stdout, "FAILED\n");
! 1168: exit(1);
! 1169: }
! 1170:
! 1171: static int validate_header(
! 1172: const struct evkeyvalq* headers,
! 1173: const char *key, const char *value)
! 1174: {
! 1175: const char *real_val = evhttp_find_header(headers, key);
! 1176: if (real_val == NULL)
! 1177: return (-1);
! 1178: if (strcmp(real_val, value) != 0)
! 1179: return (-1);
! 1180: return (0);
! 1181: }
! 1182:
! 1183: static void
! 1184: http_parse_query_test(void)
! 1185: {
! 1186: struct evkeyvalq headers;
! 1187:
! 1188: fprintf(stdout, "Testing HTTP query parsing: ");
! 1189:
! 1190: TAILQ_INIT(&headers);
! 1191:
! 1192: evhttp_parse_query("http://www.test.com/?q=test", &headers);
! 1193: if (validate_header(&headers, "q", "test") != 0)
! 1194: goto fail;
! 1195: evhttp_clear_headers(&headers);
! 1196:
! 1197: evhttp_parse_query("http://www.test.com/?q=test&foo=bar", &headers);
! 1198: if (validate_header(&headers, "q", "test") != 0)
! 1199: goto fail;
! 1200: if (validate_header(&headers, "foo", "bar") != 0)
! 1201: goto fail;
! 1202: evhttp_clear_headers(&headers);
! 1203:
! 1204: evhttp_parse_query("http://www.test.com/?q=test+foo", &headers);
! 1205: if (validate_header(&headers, "q", "test foo") != 0)
! 1206: goto fail;
! 1207: evhttp_clear_headers(&headers);
! 1208:
! 1209: evhttp_parse_query("http://www.test.com/?q=test%0Afoo", &headers);
! 1210: if (validate_header(&headers, "q", "test\nfoo") != 0)
! 1211: goto fail;
! 1212: evhttp_clear_headers(&headers);
! 1213:
! 1214: evhttp_parse_query("http://www.test.com/?q=test%0Dfoo", &headers);
! 1215: if (validate_header(&headers, "q", "test\rfoo") != 0)
! 1216: goto fail;
! 1217: evhttp_clear_headers(&headers);
! 1218:
! 1219: fprintf(stdout, "OK\n");
! 1220: return;
! 1221: fail:
! 1222: fprintf(stdout, "FAILED\n");
! 1223: exit(1);
! 1224: }
! 1225:
! 1226: static void
! 1227: http_base_test(void)
! 1228: {
! 1229: struct bufferevent *bev;
! 1230: int fd;
! 1231: const char *http_request;
! 1232: short port = -1;
! 1233:
! 1234: test_ok = 0;
! 1235: fprintf(stdout, "Testing HTTP Server Event Base: ");
! 1236:
! 1237: base = event_init();
! 1238:
! 1239: /*
! 1240: * create another bogus base - which is being used by all subsequen
! 1241: * tests - yuck!
! 1242: */
! 1243: event_init();
! 1244:
! 1245: http = http_setup(&port, base);
! 1246:
! 1247: fd = http_connect("127.0.0.1", port);
! 1248:
! 1249: /* Stupid thing to send a request */
! 1250: bev = bufferevent_new(fd, http_readcb, http_writecb,
! 1251: http_errorcb, NULL);
! 1252: bufferevent_base_set(base, bev);
! 1253:
! 1254: http_request =
! 1255: "GET /test HTTP/1.1\r\n"
! 1256: "Host: somehost\r\n"
! 1257: "Connection: close\r\n"
! 1258: "\r\n";
! 1259:
! 1260: bufferevent_write(bev, http_request, strlen(http_request));
! 1261:
! 1262: event_base_dispatch(base);
! 1263:
! 1264: bufferevent_free(bev);
! 1265: EVUTIL_CLOSESOCKET(fd);
! 1266:
! 1267: evhttp_free(http);
! 1268:
! 1269: event_base_free(base);
! 1270: base = NULL;
! 1271:
! 1272: if (test_ok != 2) {
! 1273: fprintf(stdout, "FAILED\n");
! 1274: exit(1);
! 1275: }
! 1276:
! 1277: fprintf(stdout, "OK\n");
! 1278: }
! 1279:
! 1280: /*
! 1281: * the server is going to reply with chunked data.
! 1282: */
! 1283:
! 1284: static void
! 1285: http_chunked_readcb(struct bufferevent *bev, void *arg)
! 1286: {
! 1287: /* nothing here */
! 1288: }
! 1289:
! 1290: static void
! 1291: http_chunked_errorcb(struct bufferevent *bev, short what, void *arg)
! 1292: {
! 1293: if (!test_ok)
! 1294: goto out;
! 1295:
! 1296: test_ok = -1;
! 1297:
! 1298: if ((what & EVBUFFER_EOF) != 0) {
! 1299: struct evhttp_request *req = evhttp_request_new(NULL, NULL);
! 1300: const char *header;
! 1301: enum message_read_status done;
! 1302:
! 1303: req->kind = EVHTTP_RESPONSE;
! 1304: done = evhttp_parse_firstline(req, EVBUFFER_INPUT(bev));
! 1305: if (done != ALL_DATA_READ)
! 1306: goto out;
! 1307:
! 1308: done = evhttp_parse_headers(req, EVBUFFER_INPUT(bev));
! 1309: if (done != ALL_DATA_READ)
! 1310: goto out;
! 1311:
! 1312: header = evhttp_find_header(req->input_headers, "Transfer-Encoding");
! 1313: if (header == NULL || strcmp(header, "chunked"))
! 1314: goto out;
! 1315:
! 1316: header = evhttp_find_header(req->input_headers, "Connection");
! 1317: if (header == NULL || strcmp(header, "close"))
! 1318: goto out;
! 1319:
! 1320: header = evbuffer_readline(EVBUFFER_INPUT(bev));
! 1321: if (header == NULL)
! 1322: goto out;
! 1323: /* 13 chars */
! 1324: if (strcmp(header, "d"))
! 1325: goto out;
! 1326: free((char*)header);
! 1327:
! 1328: if (strncmp((char *)EVBUFFER_DATA(EVBUFFER_INPUT(bev)),
! 1329: "This is funny", 13))
! 1330: goto out;
! 1331:
! 1332: evbuffer_drain(EVBUFFER_INPUT(bev), 13 + 2);
! 1333:
! 1334: header = evbuffer_readline(EVBUFFER_INPUT(bev));
! 1335: if (header == NULL)
! 1336: goto out;
! 1337: /* 18 chars */
! 1338: if (strcmp(header, "12"))
! 1339: goto out;
! 1340: free((char *)header);
! 1341:
! 1342: if (strncmp((char *)EVBUFFER_DATA(EVBUFFER_INPUT(bev)),
! 1343: "but not hilarious.", 18))
! 1344: goto out;
! 1345:
! 1346: evbuffer_drain(EVBUFFER_INPUT(bev), 18 + 2);
! 1347:
! 1348: header = evbuffer_readline(EVBUFFER_INPUT(bev));
! 1349: if (header == NULL)
! 1350: goto out;
! 1351: /* 8 chars */
! 1352: if (strcmp(header, "8"))
! 1353: goto out;
! 1354: free((char *)header);
! 1355:
! 1356: if (strncmp((char *)EVBUFFER_DATA(EVBUFFER_INPUT(bev)),
! 1357: "bwv 1052.", 8))
! 1358: goto out;
! 1359:
! 1360: evbuffer_drain(EVBUFFER_INPUT(bev), 8 + 2);
! 1361:
! 1362: header = evbuffer_readline(EVBUFFER_INPUT(bev));
! 1363: if (header == NULL)
! 1364: goto out;
! 1365: /* 0 chars */
! 1366: if (strcmp(header, "0"))
! 1367: goto out;
! 1368: free((char *)header);
! 1369:
! 1370: test_ok = 2;
! 1371: }
! 1372:
! 1373: out:
! 1374: event_loopexit(NULL);
! 1375: }
! 1376:
! 1377: static void
! 1378: http_chunked_writecb(struct bufferevent *bev, void *arg)
! 1379: {
! 1380: if (EVBUFFER_LENGTH(EVBUFFER_OUTPUT(bev)) == 0) {
! 1381: /* enable reading of the reply */
! 1382: bufferevent_enable(bev, EV_READ);
! 1383: test_ok++;
! 1384: }
! 1385: }
! 1386:
! 1387: static void
! 1388: http_chunked_request_done(struct evhttp_request *req, void *arg)
! 1389: {
! 1390: if (req->response_code != HTTP_OK) {
! 1391: fprintf(stderr, "FAILED\n");
! 1392: exit(1);
! 1393: }
! 1394:
! 1395: if (evhttp_find_header(req->input_headers,
! 1396: "Transfer-Encoding") == NULL) {
! 1397: fprintf(stderr, "FAILED\n");
! 1398: exit(1);
! 1399: }
! 1400:
! 1401: if (EVBUFFER_LENGTH(req->input_buffer) != 13 + 18 + 8) {
! 1402: fprintf(stderr, "FAILED\n");
! 1403: exit(1);
! 1404: }
! 1405:
! 1406: if (strncmp((char *)EVBUFFER_DATA(req->input_buffer),
! 1407: "This is funnybut not hilarious.bwv 1052",
! 1408: 13 + 18 + 8)) {
! 1409: fprintf(stderr, "FAILED\n");
! 1410: exit(1);
! 1411: }
! 1412:
! 1413: test_ok = 1;
! 1414: event_loopexit(NULL);
! 1415: }
! 1416:
! 1417: static void
! 1418: http_chunked_test(void)
! 1419: {
! 1420: struct bufferevent *bev;
! 1421: int fd;
! 1422: const char *http_request;
! 1423: short port = -1;
! 1424: struct timeval tv_start, tv_end;
! 1425: struct evhttp_connection *evcon = NULL;
! 1426: struct evhttp_request *req = NULL;
! 1427: int i;
! 1428:
! 1429: test_ok = 0;
! 1430: fprintf(stdout, "Testing Chunked HTTP Reply: ");
! 1431:
! 1432: http = http_setup(&port, NULL);
! 1433:
! 1434: fd = http_connect("127.0.0.1", port);
! 1435:
! 1436: /* Stupid thing to send a request */
! 1437: bev = bufferevent_new(fd,
! 1438: http_chunked_readcb, http_chunked_writecb,
! 1439: http_chunked_errorcb, NULL);
! 1440:
! 1441: http_request =
! 1442: "GET /chunked HTTP/1.1\r\n"
! 1443: "Host: somehost\r\n"
! 1444: "Connection: close\r\n"
! 1445: "\r\n";
! 1446:
! 1447: bufferevent_write(bev, http_request, strlen(http_request));
! 1448:
! 1449: evutil_gettimeofday(&tv_start, NULL);
! 1450:
! 1451: event_dispatch();
! 1452:
! 1453: evutil_gettimeofday(&tv_end, NULL);
! 1454: evutil_timersub(&tv_end, &tv_start, &tv_end);
! 1455:
! 1456: if (tv_end.tv_sec >= 1) {
! 1457: fprintf(stdout, "FAILED (time)\n");
! 1458: exit (1);
! 1459: }
! 1460:
! 1461:
! 1462: if (test_ok != 2) {
! 1463: fprintf(stdout, "FAILED\n");
! 1464: exit(1);
! 1465: }
! 1466:
! 1467: /* now try again with the regular connection object */
! 1468: evcon = evhttp_connection_new("127.0.0.1", port);
! 1469: if (evcon == NULL) {
! 1470: fprintf(stdout, "FAILED\n");
! 1471: exit(1);
! 1472: }
! 1473:
! 1474: /* make two requests to check the keepalive behavior */
! 1475: for (i = 0; i < 2; i++) {
! 1476: test_ok = 0;
! 1477: req = evhttp_request_new(http_chunked_request_done, NULL);
! 1478:
! 1479: /* Add the information that we care about */
! 1480: evhttp_add_header(req->output_headers, "Host", "somehost");
! 1481:
! 1482: /* We give ownership of the request to the connection */
! 1483: if (evhttp_make_request(evcon, req,
! 1484: EVHTTP_REQ_GET, "/chunked") == -1) {
! 1485: fprintf(stdout, "FAILED\n");
! 1486: exit(1);
! 1487: }
! 1488:
! 1489: event_dispatch();
! 1490:
! 1491: if (test_ok != 1) {
! 1492: fprintf(stdout, "FAILED\n");
! 1493: exit(1);
! 1494: }
! 1495: }
! 1496:
! 1497: evhttp_connection_free(evcon);
! 1498: evhttp_free(http);
! 1499:
! 1500: fprintf(stdout, "OK\n");
! 1501: }
! 1502:
! 1503: static void
! 1504: http_multi_line_header_test(void)
! 1505: {
! 1506: struct bufferevent *bev;
! 1507: int fd;
! 1508: const char *http_start_request;
! 1509: short port = -1;
! 1510:
! 1511: test_ok = 0;
! 1512: fprintf(stdout, "Testing HTTP Server with multi line: ");
! 1513:
! 1514: http = http_setup(&port, NULL);
! 1515:
! 1516: fd = http_connect("127.0.0.1", port);
! 1517:
! 1518: /* Stupid thing to send a request */
! 1519: bev = bufferevent_new(fd, http_readcb, http_writecb,
! 1520: http_errorcb, NULL);
! 1521:
! 1522: http_start_request =
! 1523: "GET /test HTTP/1.1\r\n"
! 1524: "Host: somehost\r\n"
! 1525: "Connection: close\r\n"
! 1526: "X-Multi: aaaaaaaa\r\n"
! 1527: " a\r\n"
! 1528: "\tEND\r\n"
! 1529: "X-Last: last\r\n"
! 1530: "\r\n";
! 1531:
! 1532: bufferevent_write(bev, http_start_request, strlen(http_start_request));
! 1533:
! 1534: event_dispatch();
! 1535:
! 1536: bufferevent_free(bev);
! 1537: EVUTIL_CLOSESOCKET(fd);
! 1538:
! 1539: evhttp_free(http);
! 1540:
! 1541: if (test_ok != 4) {
! 1542: fprintf(stdout, "FAILED\n");
! 1543: exit(1);
! 1544: }
! 1545:
! 1546: fprintf(stdout, "OK\n");
! 1547: }
! 1548:
! 1549: static void
! 1550: http_request_bad(struct evhttp_request *req, void *arg)
! 1551: {
! 1552: if (req != NULL) {
! 1553: fprintf(stderr, "FAILED\n");
! 1554: exit(1);
! 1555: }
! 1556:
! 1557: test_ok = 1;
! 1558: event_loopexit(NULL);
! 1559: }
! 1560:
! 1561: static void
! 1562: http_negative_content_length_test(void)
! 1563: {
! 1564: short port = -1;
! 1565: struct evhttp_connection *evcon = NULL;
! 1566: struct evhttp_request *req = NULL;
! 1567:
! 1568: test_ok = 0;
! 1569: fprintf(stdout, "Testing HTTP Negative Content Length: ");
! 1570:
! 1571: http = http_setup(&port, NULL);
! 1572:
! 1573: evcon = evhttp_connection_new("127.0.0.1", port);
! 1574: if (evcon == NULL) {
! 1575: fprintf(stdout, "FAILED\n");
! 1576: exit(1);
! 1577: }
! 1578:
! 1579: /*
! 1580: * At this point, we want to schedule a request to the HTTP
! 1581: * server using our make request method.
! 1582: */
! 1583:
! 1584: req = evhttp_request_new(http_request_bad, NULL);
! 1585:
! 1586: /* Cause the response to have a negative content-length */
! 1587: evhttp_add_header(req->output_headers, "X-Negative", "makeitso");
! 1588:
! 1589: /* We give ownership of the request to the connection */
! 1590: if (evhttp_make_request(evcon, req, EVHTTP_REQ_GET, "/test") == -1) {
! 1591: fprintf(stdout, "FAILED\n");
! 1592: exit(1);
! 1593: }
! 1594:
! 1595: event_dispatch();
! 1596:
! 1597: evhttp_free(http);
! 1598:
! 1599: if (test_ok != 1) {
! 1600: fprintf(stdout, "FAILED\n");
! 1601: exit(1);
! 1602: }
! 1603:
! 1604: fprintf(stdout, "OK\n");
! 1605: }
! 1606:
! 1607: /*
! 1608: * Testing client reset of server chunked connections
! 1609: */
! 1610:
! 1611: struct terminate_state {
! 1612: struct evhttp_request *req;
! 1613: struct bufferevent *bev;
! 1614: int fd;
! 1615: } terminate_state;
! 1616:
! 1617: static void
! 1618: terminate_chunked_trickle_cb(int fd, short events, void *arg)
! 1619: {
! 1620: struct terminate_state *state = arg;
! 1621: struct evbuffer *evb = evbuffer_new();
! 1622: struct timeval tv;
! 1623:
! 1624: if (evhttp_request_get_connection(state->req) == NULL) {
! 1625: test_ok = 1;
! 1626: evhttp_request_free(state->req);
! 1627: event_loopexit(NULL);
! 1628: return;
! 1629: }
! 1630:
! 1631: evbuffer_add_printf(evb, "%p", evb);
! 1632: evhttp_send_reply_chunk(state->req, evb);
! 1633: evbuffer_free(evb);
! 1634:
! 1635: tv.tv_sec = 0;
! 1636: tv.tv_usec = 3000;
! 1637: event_once(-1, EV_TIMEOUT, terminate_chunked_trickle_cb, arg, &tv);
! 1638: }
! 1639:
! 1640: static void
! 1641: terminate_chunked_cb(struct evhttp_request *req, void *arg)
! 1642: {
! 1643: struct terminate_state *state = arg;
! 1644: struct timeval tv;
! 1645:
! 1646: state->req = req;
! 1647:
! 1648: evhttp_send_reply_start(req, HTTP_OK, "OK");
! 1649:
! 1650: tv.tv_sec = 0;
! 1651: tv.tv_usec = 3000;
! 1652: event_once(-1, EV_TIMEOUT, terminate_chunked_trickle_cb, arg, &tv);
! 1653: }
! 1654:
! 1655: static void
! 1656: terminate_chunked_client(int fd, short event, void *arg)
! 1657: {
! 1658: struct terminate_state *state = arg;
! 1659: bufferevent_free(state->bev);
! 1660: EVUTIL_CLOSESOCKET(state->fd);
! 1661: }
! 1662:
! 1663: static void
! 1664: terminate_readcb(struct bufferevent *bev, void *arg)
! 1665: {
! 1666: /* just drop the data */
! 1667: evbuffer_drain(bev->output, -1);
! 1668: }
! 1669:
! 1670:
! 1671: static void
! 1672: http_terminate_chunked_test(void)
! 1673: {
! 1674: struct bufferevent *bev = NULL;
! 1675: struct timeval tv;
! 1676: const char *http_request;
! 1677: short port = -1;
! 1678: int fd = -1;
! 1679:
! 1680: test_ok = 0;
! 1681: fprintf(stdout, "Testing Terminated Chunked Connection: ");
! 1682:
! 1683: http = http_setup(&port, NULL);
! 1684: evhttp_del_cb(http, "/test");
! 1685: evhttp_set_cb(http, "/test", terminate_chunked_cb, &terminate_state);
! 1686:
! 1687: fd = http_connect("127.0.0.1", port);
! 1688:
! 1689: /* Stupid thing to send a request */
! 1690: bev = bufferevent_new(fd, terminate_readcb, http_writecb,
! 1691: http_errorcb, NULL);
! 1692:
! 1693: terminate_state.fd = fd;
! 1694: terminate_state.bev = bev;
! 1695:
! 1696: /* first half of the http request */
! 1697: http_request =
! 1698: "GET /test HTTP/1.1\r\n"
! 1699: "Host: some\r\n\r\n";
! 1700:
! 1701: bufferevent_write(bev, http_request, strlen(http_request));
! 1702: evutil_timerclear(&tv);
! 1703: tv.tv_usec = 10000;
! 1704: event_once(-1, EV_TIMEOUT, terminate_chunked_client, &terminate_state,
! 1705: &tv);
! 1706:
! 1707: event_dispatch();
! 1708:
! 1709: if (test_ok != 1) {
! 1710: fprintf(stdout, "FAILED\n");
! 1711: exit(1);
! 1712: }
! 1713:
! 1714: fprintf(stdout, "OK\n");
! 1715:
! 1716: if (fd >= 0)
! 1717: EVUTIL_CLOSESOCKET(fd);
! 1718: if (http)
! 1719: evhttp_free(http);
! 1720: }
! 1721:
! 1722: void
! 1723: http_suite(void)
! 1724: {
! 1725: http_base_test();
! 1726: http_bad_header_test();
! 1727: http_parse_query_test();
! 1728: http_basic_test();
! 1729: http_connection_test(0 /* not-persistent */);
! 1730: http_connection_test(1 /* persistent */);
! 1731: http_close_detection(0 /* without delay */);
! 1732: http_close_detection(1 /* with delay */);
! 1733: http_bad_request();
! 1734: http_post_test();
! 1735: http_failure_test();
! 1736: http_highport_test();
! 1737: http_dispatcher_test();
! 1738:
! 1739: http_multi_line_header_test();
! 1740: http_negative_content_length_test();
! 1741:
! 1742: http_chunked_test();
! 1743: http_terminate_chunked_test();
! 1744: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to regress_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 / test