Annotation of embedaddon/libpdel/http/http_server.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/types.h>
! 42: #include <sys/param.h>
! 43: #include <sys/socket.h>
! 44: #include <sys/syslog.h>
! 45: #include <sys/queue.h>
! 46:
! 47: #include <stdlib.h>
! 48: #include <stdarg.h>
! 49: #include <unistd.h>
! 50: #include <errno.h>
! 51: #include <assert.h>
! 52: #include <unistd.h>
! 53: #include <string.h>
! 54: #include <fcntl.h>
! 55: #include <ctype.h>
! 56: #include <limits.h>
! 57: #include <regex.h>
! 58: #include <pthread.h>
! 59: #include <netdb.h>
! 60:
! 61: #include <netinet/in_systm.h>
! 62: #include <netinet/in.h>
! 63: #include <arpa/inet.h>
! 64:
! 65: #include <openssl/ssl.h>
! 66: #include <openssl/err.h>
! 67:
! 68: #include "structs/structs.h"
! 69: #include "structs/type/array.h"
! 70:
! 71: #include "io/ssl_fp.h"
! 72: #include "http/http_defs.h"
! 73: #include "http/http_server.h"
! 74: #include "http/http_internal.h"
! 75: #include "http/http_servlet.h"
! 76: #include "util/pevent.h"
! 77: #include "util/ghash.h"
! 78: #include "util/typed_mem.h"
! 79:
! 80: /*
! 81: * Embedded HTTP[S] web server.
! 82: */
! 83:
! 84: #define MAX_CONNECTIONS 1024
! 85: #define HTTP_SERVER_TIMEOUT 90
! 86:
! 87: /* HTTP server */
! 88: struct http_server {
! 89: struct pevent_ctx *ctx; /* event context */
! 90: struct pevent *conn_event; /* new connection event */
! 91: int sock; /* accept(2) socket */
! 92: SSL_CTX *ssl; /* ssl context, if doing ssl */
! 93: char *pkey_pw; /* ssl private key password */
! 94: char *server_name; /* server name */
! 95: struct ghash *vhosts; /* virtual hosts */
! 96: http_proxy_t *proxy_handler; /* proxy handler */
! 97: void *proxy_arg; /* proxy handler cookie */
! 98: LIST_HEAD(,http_connection)
! 99: conn_list; /* active connections */
! 100: int max_conn; /* max number of connections */
! 101: int num_conn; /* number of connections */
! 102: http_logger_t *logger; /* error logging routine */
! 103: pthread_mutex_t mutex; /* mutex */
! 104: u_char stopping; /* server being stopped */
! 105: #if PDEL_DEBUG
! 106: int mutex_count; /* mutex count */
! 107: #endif
! 108: };
! 109:
! 110: /* Virtual host */
! 111: struct http_virthost {
! 112: struct http_server *server; /* back pointer to server */
! 113: char *host; /* virtual hostname */
! 114: LIST_HEAD(,http_servlet_hook)
! 115: servlets; /* registered servlets */
! 116: };
! 117:
! 118: /* What a registered servlet looks like */
! 119: struct http_servlet_hook {
! 120: struct http_servlet *servlet; /* servlet */
! 121: struct http_virthost *vhost; /* back pointer to vhost */
! 122: #if PDEL_DEBUG
! 123: char *spat; /* string pattern */
! 124: #endif
! 125: regex_t pat; /* regex pattern */
! 126: int order; /* processing order */
! 127: pthread_rwlock_t rwlock; /* servlet lock */
! 128: LIST_ENTRY(http_servlet_hook)
! 129: next; /* next in vhost list */
! 130: };
! 131:
! 132: /*
! 133: * Internal functions
! 134: */
! 135: static void *http_server_connection_main(void *arg);
! 136: static void http_server_connection_cleanup(void *arg);
! 137: static void http_server_dispatch(struct http_request *req,
! 138: struct http_response *resp);
! 139: static int http_server_ssl_pem_password_cb(char *buf, int size,
! 140: int rwflag, void *udata);
! 141:
! 142: static pevent_handler_t http_server_accept;
! 143:
! 144: static ghash_equal_t http_server_virthost_equal;
! 145: static ghash_hash_t http_server_virthost_hash;
! 146:
! 147: static ssl_logger_t http_server_ssl_logger;
! 148:
! 149: /*********************************************************************
! 150: SERVER START/STOP ROUTINES
! 151: *********************************************************************/
! 152:
! 153: /*
! 154: * Create and start a new server. The server runs in a separate thread.
! 155: */
! 156: struct http_server *
! 157: http_server_start(struct pevent_ctx *ctx, struct in_addr ip,
! 158: u_int16_t port, const struct http_server_ssl *ssl,
! 159: const char *server_name, http_logger_t *logger)
! 160: {
! 161: static const int one = 1;
! 162: struct http_server *serv;
! 163: struct sockaddr_in sin;
! 164: int got_mutex = 0;
! 165:
! 166: /* Initialize new server structure */
! 167: if ((serv = MALLOC("http_server", sizeof(*serv))) == NULL) {
! 168: (*logger)(LOG_ERR, "%s: %s", "realloc", strerror(errno));
! 169: return (NULL);
! 170: }
! 171: memset(serv, 0, sizeof(*serv));
! 172: LIST_INIT(&serv->conn_list);
! 173: serv->ctx = ctx;
! 174: serv->logger = logger;
! 175: serv->sock = -1;
! 176: serv->max_conn = MAX_CONNECTIONS; /* XXX make configurable */
! 177:
! 178: /* Copy server name */
! 179: if ((serv->server_name
! 180: = STRDUP("http_server.server_name", server_name)) == NULL) {
! 181: (*logger)(LOG_ERR, "%s: %s", "strdup", strerror(errno));
! 182: goto fail;
! 183: }
! 184:
! 185: /* Create virtual host hash table */
! 186: if ((serv->vhosts = ghash_create(serv, 0, 0, "http_server.vhosts",
! 187: http_server_virthost_hash, http_server_virthost_equal, NULL,
! 188: NULL)) == NULL) {
! 189: (*logger)(LOG_ERR, "%s: %s", "strdup", strerror(errno));
! 190: goto fail;
! 191: }
! 192:
! 193: /* Initialize ssl */
! 194: if (ssl != NULL) {
! 195:
! 196: /* Initialize SSL stuff */
! 197: _http_ssl_init();
! 198:
! 199: /* Initialize SSL context for this server */
! 200: if ((serv->ssl = SSL_CTX_new(SSLv2_server_method())) == NULL) {
! 201: ssl_log(http_server_ssl_logger, serv);
! 202: goto fail;
! 203: }
! 204:
! 205: /* Set callback for getting private key file password */
! 206: SSL_CTX_set_default_passwd_cb(serv->ssl,
! 207: http_server_ssl_pem_password_cb);
! 208: SSL_CTX_set_default_passwd_cb_userdata(serv->ssl, serv);
! 209: if (serv->pkey_pw != NULL
! 210: && (serv->pkey_pw = STRDUP("http_server.pkey_pw",
! 211: ssl->pkey_password)) == NULL) {
! 212: (*serv->logger)(LOG_ERR, "%s: %s",
! 213: "strdup", strerror(errno));
! 214: goto fail;
! 215: }
! 216:
! 217: /* Read in certificate and private key files */
! 218: if (SSL_CTX_use_certificate_file(serv->ssl,
! 219: ssl->cert_path, SSL_FILETYPE_PEM) <= 0) {
! 220: ssl_log(http_server_ssl_logger, serv);
! 221: goto fail;
! 222: }
! 223: if (SSL_CTX_use_PrivateKey_file(serv->ssl,
! 224: ssl->pkey_path, SSL_FILETYPE_PEM) <= 0) {
! 225: ssl_log(http_server_ssl_logger, serv);
! 226: goto fail;
! 227: }
! 228:
! 229: /* Verify that certificate actually signs the public key */
! 230: if (!SSL_CTX_check_private_key(serv->ssl)) {
! 231: (*serv->logger)(LOG_ERR,
! 232: "certificate %s does not match private key %s",
! 233: ssl->cert_path, ssl->pkey_path);
! 234: goto fail;
! 235: }
! 236: }
! 237:
! 238: /* Create socket */
! 239: if ((serv->sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
! 240: (*serv->logger)(LOG_ERR, "%s: %s", "socket", strerror(errno));
! 241: goto fail;
! 242: }
! 243: (void)fcntl(serv->sock, F_SETFD, 1);
! 244: if (setsockopt(serv->sock, SOL_SOCKET,
! 245: SO_REUSEADDR, (char *)&one, sizeof(one)) == -1) {
! 246: (*serv->logger)(LOG_ERR,
! 247: "%s: %s", "setsockopt", strerror(errno));
! 248: goto fail;
! 249: }
! 250: memset(&sin, 0, sizeof(sin));
! 251: #if !defined(__linux__) && !defined(__sun__)
! 252: sin.sin_len = sizeof(sin);
! 253: #endif
! 254: sin.sin_family = AF_INET;
! 255: sin.sin_port = htons(port);
! 256: sin.sin_addr = ip;
! 257: if (bind(serv->sock, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
! 258: (*serv->logger)(LOG_ERR, "%s: %s", "bind", strerror(errno));
! 259: goto fail;
! 260: }
! 261: if (listen(serv->sock, 1024) == -1) {
! 262: (*serv->logger)(LOG_ERR, "%s: %s", "listen", strerror(errno));
! 263: goto fail;
! 264: }
! 265:
! 266: /* Initialize mutex */
! 267: if ((errno = pthread_mutex_init(&serv->mutex, NULL)) != 0) {
! 268: (*serv->logger)(LOG_ERR, "%s: %s",
! 269: "pthread_mutex_init", strerror(errno));
! 270: goto fail;
! 271: }
! 272: got_mutex = 1;
! 273:
! 274: /* Start accepting connections */
! 275: if (pevent_register(serv->ctx, &serv->conn_event, PEVENT_RECURRING,
! 276: &serv->mutex, http_server_accept, serv, PEVENT_READ, serv->sock)
! 277: == -1) {
! 278: (*serv->logger)(LOG_ERR, "%s: %s",
! 279: "pevent_register", strerror(errno));
! 280: goto fail;
! 281: }
! 282: DBG(HTTP, "server %p started", serv);
! 283:
! 284: /* Done */
! 285: return (serv);
! 286:
! 287: fail:
! 288: /* Cleanup after failure */
! 289: if (got_mutex)
! 290: pthread_mutex_destroy(&serv->mutex);
! 291: if (serv->pkey_pw != NULL) {
! 292: memset(serv->pkey_pw, 0, strlen(serv->pkey_pw));
! 293: FREE("http_server.pkey_pw", serv->pkey_pw);
! 294: }
! 295: if (serv->sock != -1)
! 296: (void)close(serv->sock);
! 297: if (serv->ssl != NULL)
! 298: SSL_CTX_free(serv->ssl);
! 299: ghash_destroy(&serv->vhosts);
! 300: FREE("http_server.server_name", serv->server_name);
! 301: FREE("http_server", serv);
! 302: return (NULL);
! 303: }
! 304:
! 305: /*
! 306: * Stop HTTP server.
! 307: */
! 308: void
! 309: http_server_stop(struct http_server **sp)
! 310: {
! 311: struct http_server *const serv = *sp;
! 312: struct http_connection *conn;
! 313:
! 314: /* Already stopped? */
! 315: if (serv == NULL)
! 316: return;
! 317: *sp = NULL;
! 318:
! 319: /* Set 'stopping' flag to prevent new servlet registrations */
! 320: if (serv->stopping)
! 321: return;
! 322: serv->stopping = 1;
! 323: DBG(HTTP, "stopping server %p", serv);
! 324:
! 325: /* Acquire mutex */
! 326: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 327:
! 328: /* Stop accepting new connections */
! 329: pevent_unregister(&serv->conn_event);
! 330:
! 331: /*
! 332: * Destroy all registered servlets. Because we must unlock the
! 333: * server to do this, don't rely on iteration. Instead, start at
! 334: * the beginning each time.
! 335: */
! 336: while (ghash_size(serv->vhosts) > 0) {
! 337: struct http_servlet_hook *hook;
! 338: struct http_servlet *servlet;
! 339: struct http_virthost *vhost;
! 340: struct ghash_walk walk;
! 341:
! 342: /* Get the first virtual host */
! 343: ghash_walk_init(serv->vhosts, &walk);
! 344: vhost = ghash_walk_next(serv->vhosts, &walk);
! 345: assert(vhost != NULL);
! 346:
! 347: /* Get the first servlet in this virtual host */
! 348: assert(!LIST_EMPTY(&vhost->servlets));
! 349: hook = LIST_FIRST(&vhost->servlets);
! 350: servlet = hook->servlet;
! 351:
! 352: /* Unlock server and nuke the servlet */
! 353: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 354: http_server_destroy_servlet(&servlet);
! 355: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 356: }
! 357:
! 358: /* Kill any remaining connections */
! 359: while (!LIST_EMPTY(&serv->conn_list)) {
! 360:
! 361: /* Kill active connections; they will clean up themselves */
! 362: LIST_FOREACH(conn, &serv->conn_list, next) {
! 363: if (conn->started && conn->tid != 0) {
! 364: DBG(HTTP, "canceling conn %p (thread %p)",
! 365: conn, conn->tid);
! 366: assert(conn->tid != pthread_self());
! 367: pthread_cancel(conn->tid);
! 368: conn->tid = 0; /* don't cancel twice */
! 369: }
! 370: }
! 371:
! 372: /* Wait for outstanding connections to complete */
! 373: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 374: usleep(100000);
! 375: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 376: }
! 377:
! 378: /* Free SSL context */
! 379: if (serv->ssl != NULL)
! 380: SSL_CTX_free(serv->ssl);
! 381:
! 382: /* Close listen socket */
! 383: (void)close(serv->sock);
! 384:
! 385: /* Free strings */
! 386: if (serv->pkey_pw != NULL) {
! 387: memset(serv->pkey_pw, 0, strlen(serv->pkey_pw));
! 388: FREE("http_server.pkey_pw", serv->pkey_pw);
! 389: }
! 390: FREE("http_server.server_name", serv->server_name);
! 391:
! 392: /* Free virtual hosts hash table */
! 393: assert(ghash_size(serv->vhosts) == 0);
! 394: ghash_destroy(&serv->vhosts);
! 395:
! 396: /* Free server structure itself */
! 397: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 398: pthread_mutex_destroy(&serv->mutex);
! 399: DBG(HTTP, "freeing server %p", serv);
! 400: FREE("http_server", serv);
! 401: }
! 402:
! 403: /*********************************************************************
! 404: SERVLET REGISTRATION
! 405: *********************************************************************/
! 406:
! 407: /*
! 408: * Register a servlet
! 409: */
! 410: int
! 411: http_server_register_servlet(struct http_server *serv,
! 412: struct http_servlet *servlet, const char *vhost,
! 413: const char *urlpat, int order)
! 414: {
! 415: struct http_servlet_hook *hook;
! 416: struct http_virthost vhost_key;
! 417: int got_rwlock = 0;
! 418: int got_regex = 0;
! 419: char ebuf[128];
! 420: int r;
! 421:
! 422: /* Sanity */
! 423: if (servlet == NULL) {
! 424: errno = EINVAL;
! 425: return (-1);
! 426: }
! 427: if (servlet->hook != NULL) {
! 428: errno = EALREADY;
! 429: return (-1);
! 430: }
! 431: if (serv->stopping) {
! 432: errno = ESRCH;
! 433: return (-1);
! 434: }
! 435: if (vhost == NULL)
! 436: vhost = "";
! 437:
! 438: /* Create new servlet hook */
! 439: if ((hook = MALLOC("http_servlet_hook", sizeof(*hook))) == NULL) {
! 440: (*serv->logger)(LOG_ERR, "%s: %s", "malloc", strerror(errno));
! 441: return (-1);
! 442: }
! 443: memset(hook, 0, sizeof(*hook));
! 444: hook->servlet = servlet;
! 445: hook->order = order;
! 446: #if PDEL_DEBUG
! 447: if ((hook->spat = STRDUP("http_servlet_hook.spat", urlpat)) == NULL) {
! 448: (*serv->logger)(LOG_ERR, "%s: %s", "malloc", strerror(errno));
! 449: goto fail;
! 450: }
! 451: #endif
! 452:
! 453: /* Compile URL regular expression */
! 454: if ((r = regcomp(&hook->pat, urlpat, REG_EXTENDED | REG_NOSUB)) != 0) {
! 455: regerror(r, &hook->pat, ebuf, sizeof(ebuf));
! 456: (*serv->logger)(LOG_ERR,
! 457: "invalid URL pattern \"%s\": %s", urlpat, ebuf);
! 458: goto fail;
! 459: }
! 460: got_regex = 1;
! 461:
! 462: /* Initialize read/write lock */
! 463: if ((errno = pthread_rwlock_init(&hook->rwlock, NULL)) != 0) {
! 464: (*serv->logger)(LOG_ERR, "%s: %s",
! 465: "pthread_rwlock_init", strerror(errno));
! 466: goto fail;
! 467: }
! 468: got_rwlock = 1;
! 469:
! 470: /* Lock server */
! 471: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 472:
! 473: /* Find virtual host; create a new one if necessary */
! 474: vhost_key.host = (char *)vhost;
! 475: if ((hook->vhost = ghash_get(serv->vhosts, &vhost_key)) == NULL) {
! 476:
! 477: /* Create a new virtual host */
! 478: if ((hook->vhost = MALLOC("http_virthost",
! 479: sizeof(*hook->vhost))) == NULL) {
! 480: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 481: (*serv->logger)(LOG_ERR, "%s: %s",
! 482: "malloc", strerror(errno));
! 483: goto fail;
! 484: }
! 485: memset(hook->vhost, 0, sizeof(*hook->vhost));
! 486: if ((hook->vhost->host
! 487: = STRDUP("http_virthost.host", vhost)) == NULL) {
! 488: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 489: (*serv->logger)(LOG_ERR, "%s: %s",
! 490: "malloc", strerror(errno));
! 491: goto fail;
! 492: }
! 493: LIST_INIT(&hook->vhost->servlets);
! 494:
! 495: /* Add virtual host to server's list */
! 496: if ((r = ghash_put(serv->vhosts, hook->vhost)) == -1) {
! 497: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 498: goto fail;
! 499: }
! 500: assert(r == 0);
! 501: hook->vhost->server = serv;
! 502: }
! 503:
! 504: /* Register servlet with virtual host */
! 505: LIST_INSERT_HEAD(&hook->vhost->servlets, hook, next);
! 506: servlet->hook = hook;
! 507:
! 508: /* Unlock server */
! 509: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 510:
! 511: /* Done */
! 512: return (0);
! 513:
! 514: fail:
! 515: /* Clean up after failure */
! 516: if (hook->vhost != NULL) {
! 517: FREE("http_virthost.host", hook->vhost->host);
! 518: FREE("http_virthost", hook->vhost);
! 519: }
! 520: if (got_rwlock)
! 521: pthread_rwlock_destroy(&hook->rwlock);
! 522: if (got_regex)
! 523: regfree(&hook->pat);
! 524: #if PDEL_DEBUG
! 525: FREE("http_servlet_hook.spat", hook->spat);
! 526: #endif
! 527: FREE("http_servlet_hook", hook);
! 528: return (-1);
! 529: }
! 530:
! 531: /*
! 532: * Destroy a servlet, unregistering it if necessary.
! 533: *
! 534: * If it's the last servlet in the virtual host, remove the virtual host too.
! 535: */
! 536: void
! 537: http_server_destroy_servlet(struct http_servlet **servletp)
! 538: {
! 539: struct http_servlet *const servlet = *servletp;
! 540: struct http_servlet_hook *hook;
! 541: struct http_virthost *vhost;
! 542: struct http_server *serv;
! 543: int r;
! 544:
! 545: /* Sanity */
! 546: if (servlet == NULL)
! 547: return;
! 548: *servletp = NULL;
! 549: hook = servlet->hook;
! 550:
! 551: /* If servlet is not registered, just destroy it */
! 552: if (hook == NULL)
! 553: goto done;
! 554: vhost = hook->vhost;
! 555: serv = vhost->server;
! 556:
! 557: /* Lock server */
! 558: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 559:
! 560: /* Unregister servlet from its virtual host */
! 561: LIST_REMOVE(hook, next);
! 562: hook->vhost = NULL; /* for good measure */
! 563:
! 564: /* Remove the virtual host if it has no more servlets */
! 565: if (LIST_EMPTY(&vhost->servlets)) {
! 566: r = ghash_remove(serv->vhosts, vhost);
! 567: assert(r == 1);
! 568: vhost->server = NULL; /* for good measure */
! 569: FREE("http_virthost.host", vhost->host);
! 570: FREE("http_virthost", vhost);
! 571: }
! 572:
! 573: /* Unlock server */
! 574: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 575:
! 576: /* Wait for any threads running this servlet to finish */
! 577: r = pthread_rwlock_wrlock(&hook->rwlock);
! 578: assert(r == 0);
! 579: r = pthread_rwlock_unlock(&hook->rwlock);
! 580: assert(r == 0);
! 581:
! 582: /* Destroy servlet hook */
! 583: regfree(&hook->pat);
! 584: pthread_rwlock_destroy(&hook->rwlock);
! 585: #if PDEL_DEBUG
! 586: FREE("http_servlet_hook.spat", hook->spat);
! 587: #endif
! 588: FREE("http_servlet_hook", hook);
! 589: servlet->hook = NULL; /* for good measure */
! 590:
! 591: done:
! 592: /* Destroy servlet itself */
! 593: (*servlet->destroy)(servlet);
! 594: }
! 595:
! 596: /*
! 597: * Set proxy servlet
! 598: */
! 599: extern void
! 600: http_server_set_proxy_handler(struct http_server *serv,
! 601: http_proxy_t *handler, void *arg)
! 602: {
! 603: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 604: serv->proxy_handler = handler;
! 605: serv->proxy_arg = arg;
! 606: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 607: }
! 608:
! 609: /*********************************************************************
! 610: SERVER MAIN THREAD
! 611: *********************************************************************/
! 612:
! 613: /*
! 614: * Accept a new connection.
! 615: *
! 616: * The mutex will be locked when this is called.
! 617: */
! 618: static void
! 619: http_server_accept(void *arg)
! 620: {
! 621: struct http_server *const serv = arg;
! 622: struct http_connection *conn;
! 623: struct sockaddr_in sin;
! 624: socklen_t slen = sizeof(sin);
! 625: int sock;
! 626:
! 627: /* Accept next connection */
! 628: if ((sock = accept(serv->sock, (struct sockaddr *)&sin, &slen)) == -1) {
! 629: if (errno != ECONNABORTED && errno != ENOTCONN) {
! 630: (*serv->logger)(LOG_ERR, "%s: %s",
! 631: "accept", strerror(errno));
! 632: }
! 633: return;
! 634: }
! 635: (void)fcntl(sock, F_SETFD, 1);
! 636:
! 637: /* Get new connection object */
! 638: if ((conn = _http_connection_create(NULL, sock, 1, sin.sin_addr,
! 639: ntohs(sin.sin_port), serv->ssl, serv->logger,
! 640: HTTP_SERVER_TIMEOUT)) == NULL) {
! 641: (*serv->logger)(LOG_ERR, "%s: %s",
! 642: "_http_connection_create", strerror(errno));
! 643: (void)close(sock);
! 644: return;
! 645: }
! 646: conn->owner = serv;
! 647:
! 648: /* Add to server's list of active connections */
! 649: LIST_INSERT_HEAD(&serv->conn_list, conn, next);
! 650: serv->num_conn++;
! 651:
! 652: /* Spawn a new thread to handle request */
! 653: if ((errno = pthread_create(&conn->tid, NULL,
! 654: http_server_connection_main, conn)) != 0) {
! 655: (*serv->logger)(LOG_ERR, "%s: %s",
! 656: "pthread_create", strerror(errno));
! 657: conn->tid = 0;
! 658: LIST_REMOVE(conn, next);
! 659: serv->num_conn--;
! 660: _http_connection_free(&conn);
! 661: }
! 662:
! 663: /* Detach thread */
! 664: pthread_detach(conn->tid);
! 665: DBG(HTTP, "spawning %p for connection %p from %s:%u",
! 666: conn->tid, conn, inet_ntoa(conn->remote_ip), conn->remote_port);
! 667:
! 668: /* If maximum number of connections reached, stop accepting new ones */
! 669: if (serv->num_conn >= serv->max_conn)
! 670: pevent_unregister(&serv->conn_event);
! 671: }
! 672:
! 673: /*********************************************************************
! 674: SERVER CONNECTION MAIN THREAD
! 675: *********************************************************************/
! 676:
! 677: /*
! 678: * HTTP connection thread main routine.
! 679: */
! 680: static void *
! 681: http_server_connection_main(void *arg)
! 682: {
! 683: struct http_connection *const conn = arg;
! 684: struct http_server *const serv = conn->owner;
! 685:
! 686: /* Add shutdown cleanup hook */
! 687: pthread_cleanup_push(http_server_connection_cleanup, conn);
! 688: conn->started = 1; /* avoids pthread_cancel() race */
! 689: DBG(HTTP, "connection %p started", conn);
! 690:
! 691: /* Read requests as long as connection is kept alive */
! 692: conn->keep_alive = 1;
! 693: while (1) {
! 694: struct http_request *const req = conn->req;
! 695: struct http_response *const resp = conn->resp;
! 696: const char *hval;
! 697: char dbuf[64];
! 698: struct tm tm;
! 699: time_t now;
! 700:
! 701: /* Read in request */
! 702: if (_http_request_read(conn) == -1) {
! 703: if (errno == ENOTCONN) /* remote side disconnected */
! 704: break;
! 705: conn->keep_alive = 0;
! 706: goto send_response;
! 707: }
! 708:
! 709: /* Set default response headers */
! 710: now = time(NULL);
! 711: strftime(dbuf, sizeof(dbuf),
! 712: HTTP_TIME_FMT_RFC1123, gmtime_r(&now, &tm));
! 713: if (http_response_set_header(resp, 0,
! 714: HDR_REPLY_VERSION, HTTP_PROTO_1_1) == -1
! 715: || http_response_set_header(resp, 0, HDR_REPLY_STATUS,
! 716: "%d", HTTP_STATUS_OK) == -1
! 717: || http_response_set_header(resp, 0, HDR_REPLY_REASON,
! 718: "%s", http_response_status_msg(HTTP_STATUS_OK)) == -1
! 719: || http_response_set_header(resp, 0, HTTP_HEADER_SERVER,
! 720: "%s", serv->server_name) == -1
! 721: || http_response_set_header(resp, 0, HTTP_HEADER_DATE,
! 722: "%s", dbuf) == -1
! 723: || http_response_set_header(resp, 0,
! 724: HTTP_HEADER_LAST_MODIFIED, "%s", dbuf) == -1) {
! 725: conn->keep_alive = 0;
! 726: goto send_response;
! 727: }
! 728:
! 729: /* Turn off keep-alive if client doesn't want it */
! 730: if (!_http_head_want_keepalive(req->msg->head))
! 731: conn->keep_alive = 0;
! 732:
! 733: /* Handle request */
! 734: http_server_dispatch(req, resp);
! 735:
! 736: /* Set Connection: header if not already set */
! 737: if (((hval = http_request_get_method(req)) == NULL
! 738: || strcmp(hval, HTTP_METHOD_CONNECT) != 0)
! 739: && http_response_get_header(resp,
! 740: _http_message_connection_header(resp->msg)) == NULL) {
! 741: http_response_set_header(resp, 0,
! 742: _http_message_connection_header(resp->msg),
! 743: conn->keep_alive ? "Keep-Alive" : "Close");
! 744: }
! 745:
! 746: /* Slurp up any remaining entity data if keep-alive */
! 747: if (conn->keep_alive && req != NULL && !feof(req->msg->input)) {
! 748: static char buf[1024];
! 749:
! 750: while (fgets(buf, sizeof(buf), req->msg->input) != NULL)
! 751: ;
! 752: }
! 753:
! 754: send_response:
! 755: /* Send back headers (if not already sent) */
! 756: http_response_send_headers(resp, 0);
! 757:
! 758: /* Send back body (if it was buffered) */
! 759: _http_message_send_body(resp->msg);
! 760:
! 761: /* Determine if we can still keep this connection alive */
! 762: if (!resp->msg->no_body
! 763: && (http_response_get_header(resp,
! 764: HTTP_HEADER_CONTENT_LENGTH) == NULL
! 765: || ferror(conn->fp)
! 766: || feof(conn->fp)
! 767: || !_http_head_want_keepalive(resp->msg->head)))
! 768: conn->keep_alive = 0;
! 769:
! 770: /* Close connection unless keeping it alive */
! 771: if (!conn->keep_alive)
! 772: break;
! 773:
! 774: /* Reset request & response for next time */
! 775: _http_request_free(&conn->req);
! 776: _http_response_free(&conn->resp);
! 777: if (_http_request_new(conn) == -1
! 778: || _http_response_new(conn) == -1)
! 779: break;
! 780: }
! 781:
! 782: /* Done with this connection */
! 783: DBG(HTTP, "done with connection %p", conn);
! 784: pthread_cleanup_pop(1);
! 785: return (NULL);
! 786: }
! 787:
! 788: /*
! 789: * Cleanup when shutting down an HTTP server connection.
! 790: */
! 791: static void
! 792: http_server_connection_cleanup(void *arg)
! 793: {
! 794: struct http_connection *conn = arg;
! 795: struct http_server *const serv = conn->owner;
! 796:
! 797: /* Lock server */
! 798: DBG(HTTP, "connection %p cleaning up", conn);
! 799: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 800:
! 801: /* Restart accepting new connections if needed */
! 802: if (serv->conn_event == NULL && !serv->stopping) {
! 803: if (pevent_register(serv->ctx, &serv->conn_event,
! 804: PEVENT_RECURRING, &serv->mutex, http_server_accept,
! 805: serv, PEVENT_READ, serv->sock) == -1) {
! 806: (*serv->logger)(LOG_ERR, "%s: %s",
! 807: "pevent_register", strerror(errno));
! 808: }
! 809: }
! 810:
! 811: /* Remove this connection from the list of connections */
! 812: LIST_REMOVE(conn, next);
! 813: serv->num_conn--;
! 814:
! 815: /* Unlock server */
! 816: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 817:
! 818: /* Free connection */
! 819: _http_connection_free(&conn);
! 820: }
! 821:
! 822: /*
! 823: * Dispatch a request
! 824: */
! 825: static void
! 826: http_server_dispatch(struct http_request *req, struct http_response *resp)
! 827: {
! 828: struct http_connection *conn = req->msg->conn;
! 829: struct http_server *const serv = conn->owner;
! 830: const char *url = http_request_get_path(req);
! 831: struct http_virthost vhost_key;
! 832: char buf[MAXHOSTNAMELEN];
! 833: const char *hval;
! 834: int order;
! 835: int done;
! 836:
! 837: /* Special handling for proxy requests */
! 838: if (conn->proxy) {
! 839: http_proxy_t *proxy_handler;
! 840: void *proxy_arg;
! 841:
! 842: /* Get proxy handler from server */
! 843: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 844: proxy_handler = serv->proxy_handler;
! 845: proxy_arg = serv->proxy_arg;
! 846: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 847:
! 848: /* Handle request */
! 849: if (proxy_handler == NULL) {
! 850: http_response_send_error(resp,
! 851: (strcmp(http_request_get_method(req),
! 852: HTTP_METHOD_CONNECT) == 0) ?
! 853: HTTP_STATUS_METHOD_NOT_ALLOWED :
! 854: HTTP_STATUS_NOT_FOUND, NULL);
! 855: return;
! 856: }
! 857: (*proxy_handler)(proxy_arg, req, resp);
! 858: return;
! 859: }
! 860:
! 861: /* Extract the desired virtual host from the request */
! 862: if ((hval = http_request_get_header(req, HTTP_HEADER_HOST)) != NULL) {
! 863: char *s;
! 864:
! 865: strlcpy(buf, hval, sizeof(buf));
! 866: if ((s = strchr(buf, ':')) != NULL) /* trim port */
! 867: *s = '\0';
! 868: } else
! 869: *buf = '\0'; /* fall back to default vhost */
! 870: vhost_key.host = buf;
! 871:
! 872: /* Lock server */
! 873: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 874:
! 875: /* Choose and fix desired virtual host before running any servlets */
! 876: if (ghash_get(serv->vhosts, &vhost_key) == NULL)
! 877: *buf = '\0'; /* fall back to default vhost */
! 878:
! 879: /* Unlock server */
! 880: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 881:
! 882: /* Execute matching vhost servlets, in order, until there is output */
! 883: for (done = 0, order = INT_MIN; !done; ) {
! 884: struct http_servlet_hook *best = NULL;
! 885: struct http_servlet_hook *hook;
! 886: struct http_virthost *vhost;
! 887: int r;
! 888:
! 889: /* Lock server */
! 890: MUTEX_LOCK(&serv->mutex, serv->mutex_count);
! 891:
! 892: /* Find virtual host (do this each time because we unlock) */
! 893: if ((vhost = ghash_get(serv->vhosts, &vhost_key)) == NULL) {
! 894: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 895: break;
! 896: }
! 897:
! 898: /* Find lowest order virtual host servlet that matches */
! 899: LIST_FOREACH(hook, &vhost->servlets, next) {
! 900:
! 901: /* Skip if we've already tried it */
! 902: if (hook->order <= order)
! 903: continue;
! 904:
! 905: /* Compare URL path, choosing best match as we go */
! 906: if ((r = regexec(&hook->pat, url, 0, NULL, 0)) == 0) {
! 907: if (best == NULL || hook->order < best->order)
! 908: best = hook;
! 909: continue;
! 910: }
! 911:
! 912: /* If it didn't match, try the next servlet */
! 913: if (r == REG_NOMATCH)
! 914: continue;
! 915:
! 916: /* We got some weird error from regexec() */
! 917: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 918: regerror(r, &hook->pat, buf, sizeof(buf));
! 919: (*serv->logger)(LOG_ERR, "%s: %s", "regexec", buf);
! 920: http_response_send_error(resp,
! 921: HTTP_STATUS_INTERNAL_SERVER_ERROR,
! 922: "regexec: %s", buf);
! 923: return;
! 924: }
! 925:
! 926: /* If no matching servlet was found, we're done */
! 927: if ((hook = best) == NULL) {
! 928: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 929: break;
! 930: }
! 931:
! 932: /* Update lowest order for next iteration */
! 933: order = hook->order;
! 934:
! 935: /* Lock servlet to prevent it from going away */
! 936: r = pthread_rwlock_rdlock(&hook->rwlock);
! 937: assert(r == 0);
! 938:
! 939: /* Add cleanup hook that unlocks servlet */
! 940: pthread_cleanup_push((void (*)(void *))pthread_rwlock_unlock,
! 941: &hook->rwlock);
! 942:
! 943: /* Unlock server */
! 944: MUTEX_UNLOCK(&serv->mutex, serv->mutex_count);
! 945:
! 946: /* Execute servlet */
! 947: done = (*hook->servlet->run)(hook->servlet, req, resp);
! 948:
! 949: /* Unlock servlet */
! 950: pthread_cleanup_pop(1);
! 951:
! 952: /* If servlet returned an error, bail out */
! 953: if (done == -1) {
! 954: http_response_send_errno_error(resp);
! 955: break;
! 956: }
! 957: }
! 958:
! 959: /* No matching servlet found? */
! 960: if (!done)
! 961: http_response_send_error(resp, HTTP_STATUS_NOT_FOUND, NULL);
! 962: }
! 963:
! 964: /*********************************************************************
! 965: MISC ROUTINES
! 966: *********************************************************************/
! 967:
! 968: /*
! 969: * SSL callback to get the password for encrypted private key files.
! 970: */
! 971: static int
! 972: http_server_ssl_pem_password_cb(char *buf, int size, int rwflag, void *udata)
! 973: {
! 974: struct http_server *const serv = udata;
! 975:
! 976: if (serv->pkey_pw == NULL) {
! 977: (*serv->logger)(LOG_ERR,
! 978: "SSL private key is encrypted but no key was supplied");
! 979: return (-1);
! 980: }
! 981: strlcpy(buf, serv->pkey_pw, size);
! 982: return (strlen(buf));
! 983: }
! 984:
! 985: /*
! 986: * SSL callback for logging.
! 987: */
! 988: static void
! 989: http_server_ssl_logger(void *arg, int sev, const char *fmt, ...)
! 990: {
! 991: struct http_server *const serv = arg;
! 992: va_list args;
! 993: char *s;
! 994:
! 995: /* Prepend "startup" message to error message */
! 996: va_start(args, fmt);
! 997: VASPRINTF(TYPED_MEM_TEMP, &s, fmt, args);
! 998: va_end(args);
! 999: if (s == NULL)
! 1000: return;
! 1001: (*serv->logger)(sev, "%s: %s", "startup error", s);
! 1002: FREE(TYPED_MEM_TEMP, s);
! 1003: }
! 1004:
! 1005: /*
! 1006: * Virtual host hashing routines
! 1007: */
! 1008: static int
! 1009: http_server_virthost_equal(struct ghash *g,
! 1010: const void *item1, const void *item2)
! 1011: {
! 1012: const struct http_virthost *const vhost1 = item1;
! 1013: const struct http_virthost *const vhost2 = item2;
! 1014:
! 1015: return (strcasecmp(vhost1->host, vhost2->host) == 0);
! 1016: }
! 1017:
! 1018: u_int32_t
! 1019: http_server_virthost_hash(struct ghash *g, const void *item)
! 1020: {
! 1021: const struct http_virthost *const vhost = item;
! 1022: u_int32_t hash;
! 1023: const char *s;
! 1024:
! 1025: for (hash = 0, s = vhost->host; *s != '\0'; s++)
! 1026: hash = (hash * 31) + (u_char)tolower(*s);
! 1027: return (hash);
! 1028: }
! 1029:
! 1030:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_server.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