Annotation of embedaddon/libpdel/http/test/main.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/stat.h>
! 42: #include <sys/param.h>
! 43:
! 44: #include <stdio.h>
! 45: #include <stdlib.h>
! 46: #include <signal.h>
! 47: #include <stdarg.h>
! 48: #include <string.h>
! 49: #include <unistd.h>
! 50: #include <errno.h>
! 51: #include <assert.h>
! 52: #include <netdb.h>
! 53: #include <err.h>
! 54: #include <regex.h>
! 55: #include <pthread.h>
! 56:
! 57: #include <netinet/in_systm.h>
! 58: #include <netinet/in.h>
! 59: #include <arpa/inet.h>
! 60:
! 61: #include <openssl/ssl.h>
! 62:
! 63: #include <pdel/structs/structs.h>
! 64: #include <pdel/structs/type/array.h>
! 65:
! 66: #include <pdel/tmpl/tmpl.h>
! 67: #include <pdel/util/typed_mem.h>
! 68: #include <pdel/util/pevent.h>
! 69:
! 70: #include <pdel/http/http_defs.h>
! 71: #include <pdel/http/http_server.h>
! 72: #include <pdel/http/http_servlet.h>
! 73: #include <pdel/http/servlet/tmpl.h>
! 74: #include <pdel/http/servlet/file.h>
! 75: #include <pdel/http/servlet/basicauth.h>
! 76: #include <pdel/http/servlet/redirect.h>
! 77: #include <pdel/http/servlet/cookieauth.h>
! 78:
! 79: #define DEMO_MEM_TYPE "demo"
! 80: #define DEMO_COOKIE_NAME "demo_cookie"
! 81: #define TMPL_MEM_TYPE "tmpl"
! 82: #define NUM_IN_CACHE 2
! 83: #define CACHE_TIMEOUT_SECS 10
! 84: #define NUM_CACHE_LOOP 10
! 85: #define PATH_KERNEL "/kernel"
! 86:
! 87: #ifndef MIN
! 88: #define MIN(a, b) ((a) > (b) ? (a) : (b))
! 89: #endif
! 90:
! 91: /*
! 92: * Servlets
! 93: */
! 94: static struct http_servlet *demo_servlet_create(void);
! 95: static struct http_servlet *cgi_servlet_create(void);
! 96: static struct http_servlet *getkernel_servlet_create(void);
! 97:
! 98: /*
! 99: * Internal functions
! 100: */
! 101:
! 102: static http_logger_t demo_logger;
! 103:
! 104: static tmpl_handler_t demo_tmpl_handler;
! 105: static tmpl_errfmtr_t demo_tmpl_errfmtr;
! 106:
! 107: static http_servlet_basicauth_t demo_basicauth;
! 108:
! 109: static http_servlet_cookieauth_reqd_t demo_auth_reqd;
! 110:
! 111: static void demo_file_upload(struct http_request *req,
! 112: struct http_response *resp, FILE *op);
! 113: static int demo_client(struct pevent_ctx *ctx, int nurls,
! 114: char **urls, int count);
! 115:
! 116: /* SSL typed_mem(3) wrappers */
! 117: static void *ssl_malloc(size_t size);
! 118: static void *ssl_realloc(void *mem, size_t size);
! 119: static void ssl_free(void *mem);
! 120:
! 121: static void usage(void);
! 122:
! 123: /*
! 124: * Internal variables
! 125: */
! 126:
! 127: /* SSL info */
! 128: static const struct http_server_ssl ssl_info = {
! 129: "demo.crt", /* SSL x509 certificate file */
! 130: "demo.key", /* SSL RSA private key file */
! 131: NULL /* no password for private key needed */
! 132: };
! 133:
! 134: static const char *redirect_url;
! 135: static const struct in_addr zero_ip;
! 136: static pid_t main_pid;
! 137:
! 138: static const u_char demo_id[] = { 'd', 'e', 'm', 'o' };
! 139:
! 140: static const char *vhost = NULL;
! 141: static const struct http_server_ssl *ssl = NULL;
! 142: static int port = 0;
! 143:
! 144: static struct http_servlet *cookieauth_servlet;
! 145:
! 146: /* Info for "demo.tmpl" template servlet */
! 147: static struct http_servlet_tmpl_info tmpl_servlet_info = {
! 148: "demo.tmpl", /* pathname of template file */
! 149: NULL, /* guess the mime type for me */
! 150: NULL, /* guess the mime encoding for me */
! 151: demo_logger, /* error logging routine */
! 152: { /* info required by tmpl library */
! 153: TMPL_SKIP_NL_WHITE, /* flags for tmpl_execute() */
! 154: TMPL_MEM_TYPE, /* tmpl string typed mem type */
! 155: demo_tmpl_handler, /* handler for custom @funcs */
! 156: demo_tmpl_errfmtr, /* handler for errors */
! 157: NULL, /* opaque user cookie */
! 158: }
! 159: };
! 160:
! 161: /* Info for "logon.tmpl" template servlet */
! 162: static struct http_servlet_tmpl_info logon_servlet_info = {
! 163: "logon.tmpl", /* pathname of template file */
! 164: NULL, /* guess the mime type for me */
! 165: NULL, /* guess the mime encoding for me */
! 166: demo_logger, /* error logging routine */
! 167: { /* info required by tmpl library */
! 168: TMPL_SKIP_NL_WHITE, /* flags for tmpl_execute() */
! 169: TMPL_MEM_TYPE, /* tmpl string typed mem type */
! 170: demo_tmpl_handler, /* handler for custom @funcs */
! 171: demo_tmpl_errfmtr, /* handler for errors */
! 172: NULL, /* opaque user cookie */
! 173: }
! 174: };
! 175:
! 176: /* Info for "vhost.tmpl" template servlet */
! 177: static struct http_servlet_tmpl_info vhost_servlet_info = {
! 178: "vhost.tmpl", /* pathname of template file */
! 179: NULL, /* guess the mime type for me */
! 180: NULL, /* guess the mime encoding for me */
! 181: demo_logger, /* error logging routine */
! 182: { /* info required by tmpl library */
! 183: TMPL_SKIP_NL_WHITE, /* flags for tmpl_execute() */
! 184: TMPL_MEM_TYPE, /* tmpl string typed mem type */
! 185: demo_tmpl_handler, /* handler for custom @funcs */
! 186: demo_tmpl_errfmtr, /* handler for errors */
! 187: NULL, /* opaque user cookie */
! 188: }
! 189: };
! 190:
! 191: /* Info for BIND docs file servlet */
! 192: static struct http_servlet_file_info bind_servlet_info = {
! 193: "/usr/share/doc/bind/html", /* document root for this servlet */
! 194: 0, /* don't allow escape from docroot */
! 195: NULL, /* derive filename from URL */
! 196: "/file", /* URL prefix to strip from pathname */
! 197: NULL, /* guess the mime type for me */
! 198: NULL, /* guess the mime encoding for me */
! 199: demo_logger, /* error logging routine */
! 200: NULL, /* don't hide any files */
! 201: { } /* don't support templates */
! 202: };
! 203:
! 204: /*
! 205: * Start a HTTP server.
! 206: */
! 207: int
! 208: main(int argc, char **argv)
! 209: {
! 210: struct pevent_ctx *ctx;
! 211: char hostname[255] = { '\0' };
! 212: struct http_servlet *servlet;
! 213: struct http_server *server;
! 214: int do_client = 0;
! 215: sigset_t sigs;
! 216: int count = 1;
! 217: int sig;
! 218: int ret;
! 219: int ch;
! 220:
! 221: /* Parse command line arguments */
! 222: while ((ch = getopt(argc, argv, "sp:c:r:h:v:")) != -1) {
! 223: switch (ch) {
! 224: case 'c':
! 225: count = atoi(optarg);
! 226: break;
! 227: case 'h':
! 228: snprintf(hostname, sizeof(hostname), "%s", optarg);
! 229: break;
! 230: case 's':
! 231: ssl = &ssl_info;
! 232: break;
! 233: case 'p':
! 234: port = atoi(optarg);
! 235: break;
! 236: case 'r':
! 237: redirect_url = optarg;
! 238: break;
! 239: case 'v':
! 240: vhost = optarg;
! 241: break;
! 242: default:
! 243: usage();
! 244: }
! 245: }
! 246: argc -= optind;
! 247: argv += optind;
! 248: switch (argc) {
! 249: default:
! 250: do_client = 1;
! 251: break;
! 252: case 0:
! 253: break;
! 254: }
! 255: if (port == 0)
! 256: port = (ssl != NULL) ? 443 : 80;
! 257: if (*hostname == '\0') {
! 258: if (gethostname(hostname, sizeof(hostname)) == -1)
! 259: err(1, "gethostname");
! 260: hostname[sizeof(hostname) - 1] = '\0';
! 261: }
! 262:
! 263: /* Make OpenSSL use our malloc/free wrappers */
! 264: if (ssl != NULL) {
! 265: ret = CRYPTO_set_mem_functions(ssl_malloc,
! 266: ssl_realloc, ssl_free);
! 267: assert(ret);
! 268: ret = CRYPTO_set_locked_mem_functions(ssl_malloc, ssl_free);
! 269: assert(ret);
! 270: }
! 271: main_pid = getpid();
! 272:
! 273: /* Enable typed memory */
! 274: if (typed_mem_enable() == -1)
! 275: err(1, "typed_mem_enable");
! 276:
! 277: /* Block SIGPIPE */
! 278: (void)signal(SIGPIPE, SIG_IGN);
! 279:
! 280: /* Get event context */
! 281: if ((ctx = pevent_ctx_create("demo_server.ctx", NULL)) == NULL)
! 282: err(1, "pevent_ctx_create");
! 283:
! 284: /* If client mode, do that */
! 285: if (do_client) {
! 286: demo_client(ctx, argc, argv, count);
! 287: goto shutdown;
! 288: }
! 289:
! 290: /* Start HTTP server */
! 291: printf("demo_server: starting http server on port %d, SSL %sabled\n",
! 292: port, ssl ? "en" : "dis");
! 293: if ((server = http_server_start(ctx, zero_ip,
! 294: port, ssl, "Demo/1.0", demo_logger)) == NULL)
! 295: err(1, "http_server_start");
! 296:
! 297: /* Register default virtual host servlet if vhost defined */
! 298: if (vhost != NULL) {
! 299: /* Register "vhost.tmpl" servlet */
! 300: if ((servlet = http_servlet_tmpl_create(
! 301: &vhost_servlet_info)) == NULL)
! 302: err(1, "http_servlet_tmpl_create");
! 303: if (http_server_register_servlet(server,
! 304: servlet, NULL, "^/", 0) == -1)
! 305: err(1, "http_server_register_servlet");
! 306: }
! 307:
! 308: /* Register redirect servlet */
! 309: if (redirect_url != NULL) {
! 310: if ((servlet = http_servlet_redirect_create(redirect_url,
! 311: HTTP_SERVLET_REDIRECT_NO_APPEND)) == NULL)
! 312: err(1, "redirect_servlet_create");
! 313: if (http_server_register_servlet(server,
! 314: servlet, vhost, "^/redirect", 0) == -1)
! 315: err(1, "http_server_register_servlet");
! 316: }
! 317:
! 318: /* Register cookie auth servlet */
! 319: {
! 320: char logurl[128];
! 321:
! 322: if ((ssl && port == 443) || (!ssl && port == 80)) {
! 323: snprintf(logurl, sizeof(logurl),
! 324: "http%s://%s/logon", ssl ? "s" : "", hostname);
! 325: } else {
! 326: snprintf(logurl, sizeof(logurl),
! 327: "http%s://%s:%u/logon", ssl ? "s" : "",
! 328: hostname, port);
! 329: }
! 330: if ((cookieauth_servlet = http_servlet_cookieauth_create(
! 331: logurl, HTTP_SERVLET_REDIRECT_APPEND_URL,
! 332: demo_auth_reqd, NULL, NULL, "demo.key", demo_id,
! 333: sizeof(demo_id), DEMO_COOKIE_NAME)) == NULL)
! 334: err(1, "http_servlet_cookieauth_create");
! 335: if (http_server_register_servlet(server,
! 336: cookieauth_servlet, vhost, "^/.*", -20) == -1)
! 337: err(1, "http_server_register_servlet");
! 338: }
! 339:
! 340: /* Register logon page */
! 341: if ((servlet = http_servlet_tmpl_create(&logon_servlet_info)) == NULL)
! 342: err(1, "http_servlet_tmpl_create");
! 343: if (http_server_register_servlet(server,
! 344: servlet, vhost, "^/logon$", 0) == -1)
! 345: err(1, "http_server_register_servlet");
! 346:
! 347: /* Register demo servlet */
! 348: if ((servlet = demo_servlet_create()) == NULL)
! 349: err(1, "demo_servlet_create");
! 350: if (http_server_register_servlet(server,
! 351: servlet, vhost, "^/$", 0) == -1)
! 352: err(1, "http_server_register_servlet");
! 353:
! 354: /* Register "demo.tmpl" servlet */
! 355: if ((servlet = http_servlet_tmpl_create(&tmpl_servlet_info)) == NULL)
! 356: err(1, "http_servlet_tmpl_create");
! 357: if (http_server_register_servlet(server,
! 358: servlet, vhost, "^/tmpl$", 0) == -1)
! 359: err(1, "http_server_register_servlet");
! 360:
! 361: /* Register authorization servlet */
! 362: if ((servlet = http_servlet_basicauth_create(
! 363: demo_basicauth, NULL, NULL)) == NULL)
! 364: err(1, "http_servlet_basicauth_create");
! 365: if (http_server_register_servlet(server,
! 366: servlet, vhost, "^/[^l].*$", -10) == -1)
! 367: err(1, "http_server_register_servlet");
! 368:
! 369: /* Register BIND docs servlet */
! 370: if ((servlet = http_servlet_file_create(&bind_servlet_info)) == NULL)
! 371: err(1, "http_servlet_file_create");
! 372: if (http_server_register_servlet(server,
! 373: servlet, vhost, "^/file", 0) == -1)
! 374: err(1, "http_server_register_servlet");
! 375:
! 376: /* Register CGI servlet, at two different URLs */
! 377: if ((servlet = cgi_servlet_create()) == NULL)
! 378: err(1, "cgi_servlet_create");
! 379: if (http_server_register_servlet(server,
! 380: servlet, vhost, "^/cgi/get$", 0) == -1)
! 381: err(1, "http_server_register_servlet");
! 382: if ((servlet = cgi_servlet_create()) == NULL)
! 383: err(1, "cgi_servlet_create");
! 384: if (http_server_register_servlet(server,
! 385: servlet, vhost, "^/cgi/post$", 0) == -1)
! 386: err(1, "http_server_register_servlet");
! 387:
! 388: /* Register kernel servlet */
! 389: if ((servlet = getkernel_servlet_create()) == NULL)
! 390: err(1, "getkernel_servlet_create");
! 391: if (http_server_register_servlet(server,
! 392: servlet, vhost, "^/kernel", 0) == -1)
! 393: err(1, "http_server_register_servlet");
! 394:
! 395: /* Wait for interrupt */
! 396: sigemptyset(&sigs);
! 397: sigaddset(&sigs, SIGINT);
! 398: sigaddset(&sigs, SIGTERM);
! 399: if (sigprocmask(SIG_BLOCK, &sigs, NULL) == -1)
! 400: err(1, "sigprocmask");
! 401: if (sigwait(&sigs, &sig) == -1)
! 402: err(1, "sigwait");
! 403:
! 404: /* Shut down server */
! 405: printf("Rec'd signal %d, shutting down http server...\n", sig);
! 406: http_server_stop(&server);
! 407:
! 408: shutdown:
! 409: /* Destroy event context */
! 410: pevent_ctx_destroy(&ctx);
! 411: usleep(100000);
! 412:
! 413: /* Done */
! 414: printf("Done. Displaying unfreed memory...\n");
! 415:
! 416: /* Show memory usage */
! 417: typed_mem_dump(stdout);
! 418: return (0);
! 419: }
! 420:
! 421: /***********************************************************************
! 422: SUPPORT ROUTINES
! 423: ***********************************************************************/
! 424:
! 425: /*
! 426: * Do client loop
! 427: */
! 428: static int
! 429: demo_client(struct pevent_ctx *ctx, int nurls, char **urls, int count)
! 430: {
! 431: struct http_client *client;
! 432: struct hostent *hent;
! 433: struct in_addr ip;
! 434: char buf[256];
! 435: regex_t reg;
! 436: int i, j;
! 437: int r;
! 438:
! 439: /* Compile URL pattern */
! 440: if ((r = regcomp(®,
! 441: "^(http|https)://([-.[:alnum:]]+)(:[[:digit:]]+)?(/.*)?$",
! 442: REG_EXTENDED)) != 0) {
! 443: regerror(r, ®, buf, sizeof(buf));
! 444: errx(1, "invalid URL pattern: %s", buf);
! 445: }
! 446:
! 447: /* Create client */
! 448: if ((client = http_client_create(ctx, "DemoClient/1.0",
! 449: 5, 3, 7, demo_logger)) == NULL)
! 450: err(1, "http_client_create");
! 451:
! 452: printf("Fetching %d URLs %d times...\n", nurls, count);
! 453: for (i = 0; i < count; i++) {
! 454: for (j = 0; j < nurls; j++) {
! 455: const char *const url = urls[j];
! 456: struct http_client_connection *cc;
! 457: struct http_request *req;
! 458: struct http_response *resp;
! 459: regmatch_t match[5];
! 460: char host[256];
! 461: char path[256];
! 462: int https = 0;
! 463: int port;
! 464:
! 465: /* Parse URL */
! 466: if ((r = regexec(®, url, sizeof(match) / sizeof(*match),
! 467: match, 0)) != 0) {
! 468: regerror(r, ®, buf, sizeof(buf));
! 469: errx(1, "invalid URL \"%s\": %s", url, buf);
! 470: }
! 471: if (match[1].rm_eo - match[1].rm_so == 4)
! 472: port = 80;
! 473: else {
! 474: port = 443;
! 475: https = 1;
! 476: }
! 477: if (match[3].rm_so != match[3].rm_eo) {
! 478: strncpy(buf, url + match[3].rm_so, sizeof(buf) - 1);
! 479: buf[sizeof(buf) - 1] = '\0';
! 480: if ((port = strtoul(buf + 1, NULL, 10)) == 0)
! 481: errx(1, "invalid port");
! 482: }
! 483: memset(&host, 0, sizeof(host));
! 484: strncpy(host, url + match[2].rm_so,
! 485: MIN(sizeof(host) - 1, (match[2].rm_eo - match[2].rm_so)));
! 486: if (match[4].rm_so != match[4].rm_eo) {
! 487: memset(&path, 0, sizeof(path));
! 488: strncpy(path, url + match[4].rm_so,
! 489: MIN(sizeof(path) - 1, (match[4].rm_eo
! 490: - match[4].rm_so)));
! 491: } else
! 492: strcpy(path, "/");
! 493: if (!inet_aton(host, &ip)) {
! 494: if ((hent = gethostbyname(host)) == NULL)
! 495: err(1, "%s: %s", host, hstrerror(h_errno));
! 496: ip = *((struct in_addr **)hent->h_addr_list)[0];
! 497: }
! 498: printf("\nFetching %s://%s:%d%s\n", https ? "https" : "http",
! 499: host, port, path);
! 500:
! 501: /* Create/get client connection */
! 502: if ((cc = http_client_connect(client, ip, port, https)) == NULL)
! 503: err(1, "http_client_connect");
! 504:
! 505: /* Set up request */
! 506: req = http_client_get_request(cc);
! 507: if (http_request_set_method(req, "GET") == -1)
! 508: err(1, "http_request_set_method");
! 509: if (http_request_set_path(req, path) == -1)
! 510: err(1, "%s(%s)", "http_request_set_path", path);
! 511: if (http_request_set_header(req, 0,
! 512: HTTP_HEADER_HOST, "%s:%u", host, port) == -1)
! 513: err(1, "http_request_set_header");
! 514:
! 515: /* Send request */
! 516: if ((resp = http_client_get_response(cc)) == NULL)
! 517: printf("Error: %s\n", http_client_get_reason(cc));
! 518: else {
! 519: FILE *fp;
! 520: int ch;
! 521: int lnum;
! 522:
! 523: printf("********** RESPONSE (first 20 lines): %d %s\n",
! 524: http_response_get_code(resp),
! 525: http_response_get_header(resp, HDR_REPLY_REASON));
! 526: if ((fp = http_response_get_input(resp)) == NULL)
! 527: err(1, "http_response_get_input");
! 528: for (lnum = 0; (ch = getc(fp)) != EOF; ) {
! 529: putchar(ch);
! 530: if (ch == '\n') {
! 531: if (++lnum == 20)
! 532: break;
! 533: }
! 534: }
! 535: printf("*********************************\n\n\n");
! 536: }
! 537:
! 538: /* Release client connection */
! 539: http_client_close(&cc);
! 540:
! 541: /* Pause */
! 542: sleep(1);
! 543: }
! 544: }
! 545:
! 546: /* Release client */
! 547: if (http_client_destroy(&client) == -1)
! 548: err(1, "http_client_free");
! 549: regfree(®);
! 550: return (0);
! 551: }
! 552:
! 553: /*
! 554: * Demo CGI file upload handler
! 555: */
! 556: static void
! 557: demo_file_upload(struct http_request *req, struct http_response *resp, FILE *fp)
! 558: {
! 559: static const char *hr = "-----------------------------------------\n";
! 560: struct mime_multipart *mp;
! 561: u_int count;
! 562: int i;
! 563:
! 564: /* Read multipart MIME */
! 565: if ((mp = http_request_read_mime_multipart(req)) == NULL) {
! 566: http_response_send_error(resp,
! 567: HTTP_STATUS_INTERNAL_SERVER_ERROR,
! 568: "Can't read multi-part MIME input: %s", strerror(errno));
! 569: return;
! 570: }
! 571:
! 572: /* Display parts */
! 573: count = http_mime_multipart_get_count(mp);
! 574: fprintf(fp, "Read %d parts:\n\n", count);
! 575: fprintf(fp, "%s", hr);
! 576: for (i = 0; i < count; i++) {
! 577: struct mime_part *const part
! 578: = http_mime_multipart_get_part(mp, i);
! 579: u_char *const data = http_mime_part_get_data(part);
! 580: const u_int dlen = http_mime_part_get_length(part);
! 581: const char *const cd = http_mime_part_get_header(part,
! 582: HTTP_HEADER_CONTENT_DISPOSITION);
! 583:
! 584: fprintf(fp, "PART #%u: %u bytes\n%s: %s\n%s",
! 585: i + 1, dlen, HTTP_HEADER_CONTENT_DISPOSITION,
! 586: cd == NULL ? "<< NONE >>" : cd, hr);
! 587: fwrite(data, 1, dlen, fp);
! 588: fprintf(fp, "\n%s", hr);
! 589: }
! 590:
! 591: /* Free multipart data */
! 592: http_mime_multipart_free(&mp);
! 593: }
! 594:
! 595: /*
! 596: * Exit after printing usage string
! 597: */
! 598: static void
! 599: usage(void)
! 600: {
! 601: (void)fprintf(stderr,
! 602: "Usage: demo_server [-s] [-p port] [-c count]\n"
! 603: "\t[-r redirect url] [-h hostname] [-v virtual-host] [url ...]\n");
! 604: exit(1);
! 605: }
! 606:
! 607: /***********************************************************************
! 608: HTTP CALLBACKS
! 609: ***********************************************************************/
! 610:
! 611: /*
! 612: * Logger for the HTTP server.
! 613: */
! 614: static void
! 615: demo_logger(int sev, const char *fmt, ...)
! 616: {
! 617: static char buf[512];
! 618: va_list args;
! 619:
! 620: snprintf(buf, sizeof(buf), "http_server: %s", fmt);
! 621: va_start(args, fmt);
! 622: vfprintf(stderr, buf, args);
! 623: fprintf(stderr, "\n");
! 624: va_end(args);
! 625: }
! 626:
! 627: /***********************************************************************
! 628: AUTHORIZOR SERVLETS
! 629: ***********************************************************************/
! 630:
! 631: static int
! 632: demo_auth_reqd(void *arg, struct http_request *req)
! 633: {
! 634: const char *path = http_request_get_path(req);
! 635:
! 636: return (strcmp(path, "/logon") != 0);
! 637: }
! 638:
! 639: static const char *
! 640: demo_basicauth(void *arg, struct http_request *req,
! 641: const char *username, const char *password)
! 642: {
! 643: if (strcmp(username, "demo") != 0 || strcmp(password, "demo") != 0)
! 644: return ("HTTP Server Demo");
! 645: return (NULL);
! 646: }
! 647:
! 648: /***********************************************************************
! 649: DEMO SERVLET
! 650: ***********************************************************************/
! 651:
! 652: static http_servlet_run_t demo_servlet_run;
! 653: static http_servlet_destroy_t demo_servlet_destroy;
! 654:
! 655: /*
! 656: * Demo servlet
! 657: */
! 658: static struct http_servlet *
! 659: demo_servlet_create(void)
! 660: {
! 661: struct http_servlet *servlet;
! 662:
! 663: if ((servlet = MALLOC(DEMO_MEM_TYPE, sizeof(*servlet))) == NULL)
! 664: return (NULL);
! 665: memset(servlet, 0, sizeof(*servlet));
! 666: servlet->run = demo_servlet_run;
! 667: servlet->destroy = demo_servlet_destroy;
! 668: return (servlet);
! 669: }
! 670:
! 671: static int
! 672: demo_servlet_run(struct http_servlet *servlet,
! 673: struct http_request *req, struct http_response *resp)
! 674: {
! 675: const time_t now = time(NULL);
! 676: char buf[32];
! 677: FILE *fp;
! 678: char *u;
! 679:
! 680: /* Get output stream */
! 681: if ((fp = http_response_get_output(resp, 1)) == NULL) {
! 682: http_response_send_error(resp,
! 683: HTTP_STATUS_INTERNAL_SERVER_ERROR,
! 684: "Can't get output stream");
! 685: return (1);
! 686: }
! 687:
! 688: /* Set content type */
! 689: http_response_set_header(resp, 0,
! 690: HTTP_HEADER_CONTENT_TYPE, "text/html");
! 691:
! 692: /* Tell browser not to cache me */
! 693: http_response_set_header(resp, 1, HTTP_HEADER_PRAGMA, "no-cache");
! 694: http_response_set_header(resp, 0,
! 695: HTTP_HEADER_CACHE_CONTROL, "no-cache");
! 696:
! 697: /* Send some output */
! 698: fprintf(fp, "<html><head><title>Demo Servlet</title></head>\n");
! 699: fprintf(fp, "<body bgcolor=\"#ffffff\">\n");
! 700: fprintf(fp, "<h3>Demo Servlet in C</h3>\n");
! 701: fprintf(fp, "This servlet is implemented directly in C code.\n");
! 702: fprintf(fp, "See http_servlet(3) for details.\n<br>\n");
! 703: fprintf(fp, "<p>The time is <code>%s</code>\n", ctime_r(&now, buf));
! 704: if ((u = http_servlet_cookieauth_user("demo.key", demo_id,
! 705: sizeof(demo_id), DEMO_COOKIE_NAME, req, TYPED_MEM_TEMP)) == NULL) {
! 706: if (errno == EACCES)
! 707: u = STRDUP(TYPED_MEM_TEMP, "(nobody)");
! 708: }
! 709: if (u != NULL) {
! 710: fprintf(fp, "<p>You are logged on as <b>%s</b>.", u);
! 711: FREE(TYPED_MEM_TEMP, u);
! 712: } else
! 713: fprintf(fp, "<p><b>Error with user: %s</b>.", strerror(errno));
! 714: fprintf(fp, "<p>Click <a href=\"tmpl\">HERE</a>"
! 715: " for tmpl servlet demo (login as <b>demo</b>"
! 716: " password <b>demo</b>)\n");
! 717: fprintf(fp, "</body></html>\n");
! 718: fclose(fp);
! 719: return (1);
! 720: }
! 721:
! 722: static void
! 723: demo_servlet_destroy(struct http_servlet *servlet)
! 724: {
! 725: FREE(DEMO_MEM_TYPE, servlet);
! 726: }
! 727:
! 728: /***********************************************************************
! 729: KERNEL SERVLET
! 730: ***********************************************************************/
! 731:
! 732: static http_servlet_run_t getkernel_servlet_run;
! 733: static http_servlet_destroy_t getkernel_servlet_destroy;
! 734:
! 735: /*
! 736: * Kernel servlet
! 737: */
! 738: static struct http_servlet *
! 739: getkernel_servlet_create(void)
! 740: {
! 741: struct http_servlet *servlet;
! 742:
! 743: if ((servlet = MALLOC(DEMO_MEM_TYPE, sizeof(*servlet))) == NULL)
! 744: return (NULL);
! 745: memset(servlet, 0, sizeof(*servlet));
! 746: servlet->run = getkernel_servlet_run;
! 747: servlet->destroy = getkernel_servlet_destroy;
! 748: return (servlet);
! 749: }
! 750:
! 751: static int
! 752: getkernel_servlet_run(struct http_servlet *servlet,
! 753: struct http_request *req, struct http_response *resp)
! 754: {
! 755: struct stat sb;
! 756: time_t timestamp;
! 757: char date[64];
! 758: struct tm tm;
! 759:
! 760: /* Make this "web page" not cachable */
! 761: http_response_set_header(resp, 1, HTTP_HEADER_PRAGMA, "no-cache");
! 762: http_response_set_header(resp, 0,
! 763: HTTP_HEADER_CACHE_CONTROL, "no-cache");
! 764:
! 765: /* Get timestamp of kernel file */
! 766: if (stat(PATH_KERNEL, &sb) != -1)
! 767: timestamp = sb.st_mtime;
! 768: else
! 769: timestamp = time(NULL); /* ok because servlet will fail too */
! 770:
! 771: /* Set MIME type */
! 772: http_response_set_header(resp, 0, HTTP_HEADER_CONTENT_TYPE,
! 773: "application/octet-stream");
! 774:
! 775: /* Set filename (via Content-Disposition) based on date */
! 776: strftime(date, sizeof(date), "%Y-%m-%d", localtime_r(×tamp, &tm));
! 777: http_response_set_header(resp, 0, HTTP_HEADER_CONTENT_DISPOSITION,
! 778: "application/octet-stream; filename=\"kernel-%s\"", date);
! 779:
! 780: /* Piggy-back off of file servlet routine */
! 781: http_servlet_file_serve(PATH_KERNEL, demo_logger, req, resp);
! 782: return (1);
! 783: }
! 784:
! 785: static void
! 786: getkernel_servlet_destroy(struct http_servlet *servlet)
! 787: {
! 788: FREE(DEMO_MEM_TYPE, servlet);
! 789: }
! 790:
! 791: /***********************************************************************
! 792: CGI SERVLET
! 793: ***********************************************************************/
! 794:
! 795: static http_servlet_run_t cgi_servlet_run;
! 796: static http_servlet_destroy_t cgi_servlet_destroy;
! 797:
! 798: /*
! 799: * Demo CGI
! 800: */
! 801: static struct http_servlet *
! 802: cgi_servlet_create(void)
! 803: {
! 804: struct http_servlet *servlet;
! 805:
! 806: if ((servlet = MALLOC(DEMO_MEM_TYPE, sizeof(*servlet))) == NULL)
! 807: return (NULL);
! 808: memset(servlet, 0, sizeof(*servlet));
! 809: servlet->run = cgi_servlet_run;
! 810: servlet->destroy = cgi_servlet_destroy;
! 811: return (servlet);
! 812: }
! 813:
! 814: static int
! 815: cgi_servlet_run(struct http_servlet *servlet,
! 816: struct http_request *req, struct http_response *resp)
! 817: {
! 818: FILE *fp;
! 819: int i;
! 820:
! 821: /* Set no cache */
! 822: http_response_set_header(resp, 1, "Pragma", "no-cache");
! 823: http_response_set_header(resp, 0, "Cache-Control", "no-cache");
! 824:
! 825: /* Set MIME type */
! 826: http_response_set_header(resp, 0,
! 827: HTTP_HEADER_CONTENT_TYPE, "text/plain; charset=iso-8859-1");
! 828:
! 829: /* Get output stream */
! 830: if ((fp = http_response_get_output(resp, 0)) == NULL) {
! 831: http_response_send_error(resp,
! 832: HTTP_STATUS_INTERNAL_SERVER_ERROR,
! 833: "Can't get output stream");
! 834: return (1);
! 835: }
! 836:
! 837: /* For POST, read and decode input */
! 838: if (strcmp(http_request_get_method(req), "POST") == 0) {
! 839: const char *hval;
! 840: const char *s;
! 841: int nval;
! 842:
! 843: /* Check type of encoding */
! 844: if ((hval = http_request_get_header(req,
! 845: HTTP_HEADER_CONTENT_TYPE)) == NULL) {
! 846: http_response_send_error(resp,
! 847: HTTP_STATUS_INTERNAL_SERVER_ERROR,
! 848: "Missing %s header", HTTP_HEADER_CONTENT_TYPE);
! 849: return (1);
! 850: }
! 851:
! 852: /* Special case form file upload */
! 853: if ((s = strchr(hval, ';')) != NULL
! 854: && strncasecmp(hval,
! 855: HTTP_CTYPE_MULTIPART_FORMDATA, s - hval) == 0) {
! 856: demo_file_upload(req, resp, fp);
! 857: return (1);
! 858: }
! 859:
! 860: /* Must be POST form data */
! 861: if (strcasecmp(hval, HTTP_CTYPE_FORM_URLENCODED) != 0) {
! 862: http_response_send_error(resp,
! 863: HTTP_STATUS_INTERNAL_SERVER_ERROR,
! 864: "Weird content-type \"%s\"", hval);
! 865: return (1);
! 866: }
! 867:
! 868: /* Read POST form data */
! 869: if ((nval = http_request_read_url_encoded_values(req)) == -1) {
! 870: http_response_send_error(resp,
! 871: HTTP_STATUS_INTERNAL_SERVER_ERROR,
! 872: "Can't read POST input");
! 873: return (1);
! 874: }
! 875: fprintf(fp, "Read %d values from input\n", nval);
! 876: }
! 877:
! 878: /* Get fields and display them */
! 879: for (i = 1; 1; i++) {
! 880: const char *value;
! 881: char fname[32];
! 882:
! 883: snprintf(fname, sizeof(fname), "field%d", i);
! 884: fprintf(fp, "FIELD \"%s\": ", fname);
! 885: if ((value = http_request_get_value(req, fname, 0)) == NULL) {
! 886: fprintf(fp, "<< NOT FOUND >>\n");
! 887: break;
! 888: } else
! 889: fprintf(fp, "value=\"%s\"\n", value);
! 890: }
! 891: return (1);
! 892: }
! 893:
! 894: static void
! 895: cgi_servlet_destroy(struct http_servlet *servlet)
! 896: {
! 897: FREE(DEMO_MEM_TYPE, servlet);
! 898: }
! 899:
! 900: /***********************************************************************
! 901: TMPL USER FUNCTIONS
! 902: ***********************************************************************/
! 903:
! 904: static tmpl_handler_t authname_handler;
! 905: static tmpl_handler_t authorize_handler;
! 906: static tmpl_handler_t date_handler;
! 907: static tmpl_handler_t get_header_handler;
! 908: static tmpl_handler_t get_port_handler;
! 909: static tmpl_handler_t get_ssl_handler;
! 910: static tmpl_handler_t query_handler;
! 911: static tmpl_handler_t query_string_handler;
! 912: static tmpl_handler_t redirect_handler;
! 913: static tmpl_handler_t remote_ip_handler;
! 914: static tmpl_handler_t remote_port_handler;
! 915: static tmpl_handler_t shutdown_handler;
! 916: static tmpl_handler_t sleep_handler;
! 917: static tmpl_handler_t vhost_handler;
! 918:
! 919: static const struct tmpl_func demo_tmpl_funcs[] = {
! 920: { "authname", 0, 0, authname_handler },
! 921: { "authorize", 0, 2, authorize_handler },
! 922: { "date", 0, 0, date_handler },
! 923: { "get_header", 1, 1, get_header_handler },
! 924: { "get_port", 0, 0, get_port_handler },
! 925: { "get_ssl", 0, 0, get_ssl_handler },
! 926: { "query", 1, 1, query_handler },
! 927: { "query_string", 0, 0, query_string_handler },
! 928: { "redirect", 0, 0, redirect_handler },
! 929: { "remote_ip", 0, 0, remote_ip_handler },
! 930: { "remote_port", 0, 0, remote_port_handler },
! 931: { "shutdown", 0, 0, shutdown_handler },
! 932: { "sleep", 1, 1, sleep_handler },
! 933: { "vhost", 0, 0, vhost_handler },
! 934: };
! 935:
! 936: static char *
! 937: demo_tmpl_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 938: {
! 939: return (tmpl_list_handler(ctx, demo_tmpl_funcs,
! 940: sizeof(demo_tmpl_funcs) / sizeof(*demo_tmpl_funcs),
! 941: errmsgp, ac, av));
! 942: }
! 943:
! 944: static char *
! 945: remote_ip_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 946: {
! 947: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 948: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 949:
! 950: return (STRDUP(mtype,
! 951: inet_ntoa(http_request_get_remote_ip(targ->req))));
! 952: }
! 953:
! 954: static char *
! 955: remote_port_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 956: {
! 957: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 958: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 959: char buf[32];
! 960:
! 961: snprintf(buf, sizeof(buf), "%u",
! 962: http_request_get_remote_port(targ->req));
! 963: return (STRDUP(mtype, buf));
! 964: }
! 965:
! 966: static char *
! 967: redirect_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 968: {
! 969: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 970:
! 971: return (STRDUP(mtype, redirect_url ? redirect_url : ""));
! 972: }
! 973:
! 974: static char *
! 975: date_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 976: {
! 977: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 978: const time_t now = time(NULL);
! 979: char buf[32];
! 980:
! 981: return (STRDUP(mtype, ctime_r(&now, buf)));
! 982: }
! 983:
! 984: static char *
! 985: sleep_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 986: {
! 987: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 988: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 989:
! 990: http_response_send_headers(targ->resp, 1);
! 991: sleep(atoi(av[1]));
! 992: return (STRDUP(mtype, ""));
! 993: }
! 994:
! 995: static char *
! 996: authorize_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 997: {
! 998: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 999: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1000:
! 1001: /* Login */
! 1002: if (ac > 2 && *av[2] != '\0') {
! 1003: const u_long expiry = strtoul(av[2], NULL, 10);
! 1004:
! 1005: if (http_servlet_cookieauth_login(targ->resp,
! 1006: "demo.key", av[1], 3600, expiry ? time(NULL) + expiry : 0,
! 1007: expiry == 0, demo_id, sizeof(demo_id), DEMO_COOKIE_NAME,
! 1008: "/", NULL, 0) == -1)
! 1009: return (NULL);
! 1010: return (STRDUP(mtype, ""));
! 1011: }
! 1012:
! 1013: /* Logout */
! 1014: if (http_servlet_cookieauth_logout(DEMO_COOKIE_NAME,
! 1015: "/", NULL, targ->resp) == -1)
! 1016: return (NULL);
! 1017: return (STRDUP(mtype, ""));
! 1018: }
! 1019:
! 1020: static char *
! 1021: authname_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1022: {
! 1023: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 1024: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1025: char *name;
! 1026:
! 1027: if ((name = http_servlet_cookieauth_user("demo.key", demo_id,
! 1028: sizeof(demo_id), DEMO_COOKIE_NAME, targ->req, mtype)) == NULL) {
! 1029: if (errno == EACCES)
! 1030: name = STRDUP(mtype, "");
! 1031: }
! 1032: if (name == NULL)
! 1033: return (NULL);
! 1034: return (name);
! 1035: }
! 1036:
! 1037: static char *
! 1038: query_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1039: {
! 1040: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 1041: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1042: const char *value;
! 1043:
! 1044: if ((value = http_request_get_value(targ->req, av[1], 0)) == NULL)
! 1045: value = "";
! 1046: return (STRDUP(mtype, value));
! 1047: }
! 1048:
! 1049: static char *
! 1050: query_string_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1051: {
! 1052: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 1053: const char *eqs = http_request_get_query_string(targ->req);
! 1054: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1055: char *dqs;
! 1056:
! 1057: /* URL-decode query string */
! 1058: if ((dqs = MALLOC(mtype, strlen(eqs) + 1)) == NULL)
! 1059: return (NULL);
! 1060: http_request_url_decode(eqs, dqs);
! 1061:
! 1062: /* Return it */
! 1063: return (dqs);
! 1064: }
! 1065:
! 1066: static char *
! 1067: get_header_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1068: {
! 1069: struct http_servlet_tmpl_arg *const targ = tmpl_ctx_get_arg(ctx);
! 1070: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1071: const char *value;
! 1072:
! 1073: if ((value = http_request_get_header(targ->req, av[1])) == NULL)
! 1074: value = "";
! 1075: return (STRDUP(mtype, value));
! 1076: }
! 1077:
! 1078: static char *
! 1079: get_port_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1080: {
! 1081: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1082: char buf[32];
! 1083:
! 1084: snprintf(buf, sizeof(buf), "%u", port);
! 1085: return (STRDUP(mtype, buf));
! 1086: }
! 1087:
! 1088: static char *
! 1089: get_ssl_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1090: {
! 1091: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1092:
! 1093: return (STRDUP(mtype, ssl != NULL ? "1" : "0"));
! 1094: }
! 1095:
! 1096: static char *
! 1097: vhost_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1098: {
! 1099: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1100:
! 1101: return (STRDUP(mtype, vhost == NULL ? "" : vhost));
! 1102: }
! 1103:
! 1104: static char *
! 1105: shutdown_handler(struct tmpl_ctx *ctx, char **errmsgp, int ac, char **av)
! 1106: {
! 1107: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1108:
! 1109: kill(main_pid, SIGTERM);
! 1110: return (STRDUP(mtype, ""));
! 1111: }
! 1112:
! 1113: /*
! 1114: * Error formatter for templates.
! 1115: */
! 1116: static char *
! 1117: demo_tmpl_errfmtr(struct tmpl_ctx *ctx, const char *errmsg)
! 1118: {
! 1119: static const char fmt[] =
! 1120: "<font color=\"#ff0000\"><strong>Error: %s</strong></font>";
! 1121: const char *const mtype = tmpl_ctx_get_mtype(ctx);
! 1122: char *string;
! 1123: int slen;
! 1124:
! 1125: slen = sizeof(fmt) + strlen(errmsg);
! 1126: if ((string = MALLOC(mtype, slen)) == NULL)
! 1127: return (NULL);
! 1128: snprintf(string, slen, fmt, errmsg);
! 1129: return (string);
! 1130: }
! 1131:
! 1132: /***********************************************************************
! 1133: SSL MEMORY WRAPPERS
! 1134: ***********************************************************************/
! 1135:
! 1136: /*
! 1137: * OpenSSL malloc() wrappers
! 1138: */
! 1139: static void
! 1140: *ssl_malloc(size_t size)
! 1141: {
! 1142: return (MALLOC("OpenSSL", size));
! 1143: }
! 1144:
! 1145: static void
! 1146: *ssl_realloc(void *mem, size_t size)
! 1147: {
! 1148: return (REALLOC("OpenSSL", mem, size));
! 1149: }
! 1150:
! 1151: static void
! 1152: ssl_free(void *mem)
! 1153: {
! 1154: return (FREE("OpenSSL", mem));
! 1155: }
! 1156:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / http / test