1 /* $OpenBSD: server.c,v 1.118 2019/02/19 11:37:26 pirofti Exp $ */ 2 3 /* 4 * Copyright (c) 2006 - 2015 Reyk Floeter <reyk@openbsd.org> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 #include <sys/queue.h> 21 #include <sys/time.h> 22 #include <sys/stat.h> 23 #include <sys/socket.h> 24 #include <sys/uio.h> 25 #include <sys/tree.h> 26 27 #include <netinet/in.h> 28 #include <netinet/tcp.h> 29 #include <arpa/inet.h> 30 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <stdarg.h> 34 #include <limits.h> 35 #include <errno.h> 36 #include <fcntl.h> 37 #include <string.h> 38 #include <syslog.h> 39 #include <unistd.h> 40 #include <event.h> 41 #include <imsg.h> 42 #include <tls.h> 43 #include <vis.h> 44 45 #include "httpd.h" 46 47 #define MINIMUM(a, b) (((a) < (b)) ? (a) : (b)) 48 49 int server_dispatch_parent(int, struct privsep_proc *, 50 struct imsg *); 51 int server_dispatch_logger(int, struct privsep_proc *, 52 struct imsg *); 53 void server_shutdown(void); 54 55 void server_init(struct privsep *, struct privsep_proc *p, void *); 56 void server_launch(void); 57 int server_socket(struct sockaddr_storage *, in_port_t, 58 struct server_config *, int, int); 59 int server_socket_listen(struct sockaddr_storage *, in_port_t, 60 struct server_config *); 61 struct server *server_byid(uint32_t); 62 63 int server_tls_init(struct server *); 64 void server_tls_readcb(int, short, void *); 65 void server_tls_writecb(int, short, void *); 66 void server_tls_handshake(int, short, void *); 67 68 void server_accept(int, short, void *); 69 void server_input(struct client *); 70 void server_inflight_dec(struct client *, const char *); 71 72 extern void bufferevent_read_pressure_cb(struct evbuffer *, size_t, 73 size_t, void *); 74 75 volatile int server_clients; 76 volatile int server_inflight = 0; 77 uint32_t server_cltid; 78 79 static struct privsep_proc procs[] = { 80 { "parent", PROC_PARENT, server_dispatch_parent }, 81 { "logger", PROC_LOGGER, server_dispatch_logger } 82 }; 83 84 void 85 server(struct privsep *ps, struct privsep_proc *p) 86 { 87 proc_run(ps, p, procs, nitems(procs), server_init, NULL); 88 server_http(); 89 } 90 91 void 92 server_shutdown(void) 93 { 94 config_purge(httpd_env, CONFIG_ALL); 95 usleep(200); /* XXX server needs to shutdown last */ 96 } 97 98 int 99 server_privinit(struct server *srv) 100 { 101 struct server *s; 102 103 if (srv->srv_conf.flags & SRVFLAG_LOCATION) 104 return (0); 105 106 log_debug("%s: adding server %s", __func__, srv->srv_conf.name); 107 108 /* 109 * There's no need to open a new socket if a server with the 110 * same address already exists. 111 */ 112 TAILQ_FOREACH(s, httpd_env->sc_servers, srv_entry) { 113 if (s != srv && s->srv_s != -1 && 114 s->srv_conf.port == srv->srv_conf.port && 115 sockaddr_cmp((struct sockaddr *)&s->srv_conf.ss, 116 (struct sockaddr *)&srv->srv_conf.ss, 117 s->srv_conf.prefixlen) == 0) 118 return (0); 119 } 120 121 /* Open listening socket in the privileged process */ 122 if ((srv->srv_conf.flags & SRVFLAG_TLS) && srv->srv_conf.tls_cert == 123 NULL) { 124 /* soft fail if cert is not there yet */ 125 srv->srv_s = -1; 126 return (0); 127 } 128 129 if ((srv->srv_s = server_socket_listen(&srv->srv_conf.ss, 130 srv->srv_conf.port, &srv->srv_conf)) == -1) 131 return (-1); 132 133 return (0); 134 } 135 136 int 137 server_tls_cmp(struct server *s1, struct server *s2, int match_keypair) 138 { 139 struct server_config *sc1, *sc2; 140 141 sc1 = &s1->srv_conf; 142 sc2 = &s2->srv_conf; 143 144 if (sc1->tls_flags != sc2->tls_flags) 145 return (-1); 146 if (sc1->tls_protocols != sc2->tls_protocols) 147 return (-1); 148 if (sc1->tls_ticket_lifetime != sc2->tls_ticket_lifetime) 149 return (-1); 150 if (strcmp(sc1->tls_ciphers, sc2->tls_ciphers) != 0) 151 return (-1); 152 if (strcmp(sc1->tls_dhe_params, sc2->tls_dhe_params) != 0) 153 return (-1); 154 if (strcmp(sc1->tls_ecdhe_curves, sc2->tls_ecdhe_curves) != 0) 155 return (-1); 156 157 if (match_keypair) { 158 if (strcmp(sc1->tls_cert_file, sc2->tls_cert_file) != 0) 159 return (-1); 160 if (strcmp(sc1->tls_key_file, sc2->tls_key_file) != 0) 161 return (-1); 162 } 163 164 return (0); 165 } 166 167 int 168 server_tls_load_keypair(struct server *srv) 169 { 170 if ((srv->srv_conf.flags & SRVFLAG_TLS) == 0) 171 return (0); 172 173 if ((srv->srv_conf.tls_cert = tls_load_file(srv->srv_conf.tls_cert_file, 174 &srv->srv_conf.tls_cert_len, NULL)) == NULL) 175 return (-1); 176 log_debug("%s: using certificate %s", __func__, 177 srv->srv_conf.tls_cert_file); 178 179 /* XXX allow to specify password for encrypted key */ 180 if ((srv->srv_conf.tls_key = tls_load_file(srv->srv_conf.tls_key_file, 181 &srv->srv_conf.tls_key_len, NULL)) == NULL) 182 return (-1); 183 log_debug("%s: using private key %s", __func__, 184 srv->srv_conf.tls_key_file); 185 186 return (0); 187 } 188 189 int 190 server_tls_load_ocsp(struct server *srv) 191 { 192 if ((srv->srv_conf.flags & SRVFLAG_TLS) == 0) 193 return (0); 194 195 if (srv->srv_conf.tls_ocsp_staple_file == NULL) 196 return (0); 197 198 if ((srv->srv_conf.tls_ocsp_staple = tls_load_file( 199 srv->srv_conf.tls_ocsp_staple_file, 200 &srv->srv_conf.tls_ocsp_staple_len, NULL)) == NULL) { 201 log_warnx("%s: Failed to load ocsp staple from %s", __func__, 202 srv->srv_conf.tls_ocsp_staple_file); 203 return (-1); 204 } 205 206 if (srv->srv_conf.tls_ocsp_staple_len == 0) { 207 log_warnx("%s: ignoring 0 length ocsp staple from %s", __func__, 208 srv->srv_conf.tls_ocsp_staple_file); 209 return (0); 210 } 211 212 log_debug("%s: using ocsp staple from %s", __func__, 213 srv->srv_conf.tls_ocsp_staple_file); 214 215 return (0); 216 } 217 218 int 219 server_tls_load_ca(struct server *srv) 220 { 221 if ((srv->srv_conf.tls_flags & TLSFLAG_CA) == 0 || 222 srv->srv_conf.tls_ca_file == NULL) 223 return (0); 224 225 if ((srv->srv_conf.tls_ca = tls_load_file( 226 srv->srv_conf.tls_ca_file, 227 &srv->srv_conf.tls_ca_len, NULL)) == NULL) 228 return (-1); 229 log_debug("%s: using ca cert(s) from %s", __func__, 230 srv->srv_conf.tls_ca_file); 231 232 return (0); 233 } 234 235 int 236 server_tls_load_crl(struct server *srv) 237 { 238 if ((srv->srv_conf.tls_flags & TLSFLAG_CA) == 0 || 239 srv->srv_conf.tls_crl_file == NULL) 240 return (0); 241 242 if ((srv->srv_conf.tls_crl = tls_load_file( 243 srv->srv_conf.tls_crl_file, 244 &srv->srv_conf.tls_crl_len, NULL)) == NULL) 245 return (-1); 246 log_debug("%s: using crl(s) from %s", __func__, 247 srv->srv_conf.tls_crl_file); 248 249 return (0); 250 } 251 252 int 253 server_tls_init(struct server *srv) 254 { 255 struct server_config *srv_conf; 256 257 if ((srv->srv_conf.flags & SRVFLAG_TLS) == 0) 258 return (0); 259 260 if (srv->srv_conf.tls_cert == NULL) 261 /* soft fail if cert is not there yet */ 262 return (0); 263 264 log_debug("%s: setting up tls for %s", __func__, srv->srv_conf.name); 265 266 if (tls_init() != 0) { 267 log_warnx("%s: failed to initialise tls", __func__); 268 return (-1); 269 } 270 if ((srv->srv_tls_config = tls_config_new()) == NULL) { 271 log_warnx("%s: failed to get tls config", __func__); 272 return (-1); 273 } 274 if ((srv->srv_tls_ctx = tls_server()) == NULL) { 275 log_warnx("%s: failed to get tls server", __func__); 276 return (-1); 277 } 278 279 if (tls_config_set_protocols(srv->srv_tls_config, 280 srv->srv_conf.tls_protocols) != 0) { 281 log_warnx("%s: failed to set tls protocols: %s", 282 __func__, tls_config_error(srv->srv_tls_config)); 283 return (-1); 284 } 285 if (tls_config_set_ciphers(srv->srv_tls_config, 286 srv->srv_conf.tls_ciphers) != 0) { 287 log_warnx("%s: failed to set tls ciphers: %s", 288 __func__, tls_config_error(srv->srv_tls_config)); 289 return (-1); 290 } 291 if (tls_config_set_dheparams(srv->srv_tls_config, 292 srv->srv_conf.tls_dhe_params) != 0) { 293 log_warnx("%s: failed to set tls dhe params: %s", 294 __func__, tls_config_error(srv->srv_tls_config)); 295 return (-1); 296 } 297 if (tls_config_set_ecdhecurves(srv->srv_tls_config, 298 srv->srv_conf.tls_ecdhe_curves) != 0) { 299 log_warnx("%s: failed to set tls ecdhe curves: %s", 300 __func__, tls_config_error(srv->srv_tls_config)); 301 return (-1); 302 } 303 304 if (tls_config_set_keypair_ocsp_mem(srv->srv_tls_config, 305 srv->srv_conf.tls_cert, srv->srv_conf.tls_cert_len, 306 srv->srv_conf.tls_key, srv->srv_conf.tls_key_len, 307 srv->srv_conf.tls_ocsp_staple, 308 srv->srv_conf.tls_ocsp_staple_len) != 0) { 309 log_warnx("%s: failed to set tls certificate/key: %s", 310 __func__, tls_config_error(srv->srv_tls_config)); 311 return (-1); 312 } 313 314 if (srv->srv_conf.tls_ca != NULL) { 315 if (tls_config_set_ca_mem(srv->srv_tls_config, 316 srv->srv_conf.tls_ca, srv->srv_conf.tls_ca_len) != 0) { 317 log_warnx("%s: failed to add ca cert(s)", __func__); 318 return (-1); 319 } 320 if (tls_config_set_crl_mem(srv->srv_tls_config, 321 srv->srv_conf.tls_crl, srv->srv_conf.tls_crl_len) != 0) { 322 log_warnx("%s: failed to add crl(s)", __func__); 323 return (-1); 324 } 325 if (srv->srv_conf.tls_flags & TLSFLAG_OPTIONAL) 326 tls_config_verify_client_optional(srv->srv_tls_config); 327 else 328 tls_config_verify_client(srv->srv_tls_config); 329 } 330 331 TAILQ_FOREACH(srv_conf, &srv->srv_hosts, entry) { 332 if (srv_conf->tls_cert == NULL || srv_conf->tls_key == NULL) 333 continue; 334 log_debug("%s: adding keypair for server %s", __func__, 335 srv->srv_conf.name); 336 if (tls_config_add_keypair_ocsp_mem(srv->srv_tls_config, 337 srv_conf->tls_cert, srv_conf->tls_cert_len, 338 srv_conf->tls_key, srv_conf->tls_key_len, 339 srv_conf->tls_ocsp_staple, 340 srv_conf->tls_ocsp_staple_len) != 0) { 341 log_warnx("%s: failed to add tls keypair", __func__); 342 return (-1); 343 } 344 } 345 346 /* set common session ID among all processes */ 347 if (tls_config_set_session_id(srv->srv_tls_config, 348 httpd_env->sc_tls_sid, sizeof(httpd_env->sc_tls_sid)) == -1) { 349 log_warnx("%s: could not set the TLS session ID: %s", 350 __func__, tls_config_error(srv->srv_tls_config)); 351 return (-1); 352 } 353 354 /* ticket support */ 355 if (srv->srv_conf.tls_ticket_lifetime) { 356 if (tls_config_set_session_lifetime(srv->srv_tls_config, 357 srv->srv_conf.tls_ticket_lifetime) == -1) { 358 log_warnx("%s: could not set the TLS session lifetime: " 359 "%s", __func__, 360 tls_config_error(srv->srv_tls_config)); 361 return (-1); 362 } 363 tls_config_add_ticket_key(srv->srv_tls_config, 364 srv->srv_conf.tls_ticket_key.tt_keyrev, 365 srv->srv_conf.tls_ticket_key.tt_key, 366 sizeof(srv->srv_conf.tls_ticket_key.tt_key)); 367 explicit_bzero(&srv->srv_conf.tls_ticket_key, 368 sizeof(srv->srv_conf.tls_ticket_key)); 369 } 370 371 if (tls_configure(srv->srv_tls_ctx, srv->srv_tls_config) != 0) { 372 log_warnx("%s: failed to configure tls - %s", __func__, 373 tls_error(srv->srv_tls_ctx)); 374 return (-1); 375 } 376 377 /* We're now done with the public/private key & ca/crl... */ 378 tls_config_clear_keys(srv->srv_tls_config); 379 freezero(srv->srv_conf.tls_cert, srv->srv_conf.tls_cert_len); 380 freezero(srv->srv_conf.tls_key, srv->srv_conf.tls_key_len); 381 free(srv->srv_conf.tls_ca); 382 free(srv->srv_conf.tls_crl); 383 srv->srv_conf.tls_ca = NULL; 384 srv->srv_conf.tls_cert = NULL; 385 srv->srv_conf.tls_crl = NULL; 386 srv->srv_conf.tls_key = NULL; 387 srv->srv_conf.tls_ca_len = 0; 388 srv->srv_conf.tls_cert_len = 0; 389 srv->srv_conf.tls_crl_len = 0; 390 srv->srv_conf.tls_key_len = 0; 391 392 return (0); 393 } 394 395 void 396 server_generate_ticket_key(struct server_config *srv_conf) 397 { 398 struct server_tls_ticket *key = &srv_conf->tls_ticket_key; 399 400 key->tt_id = srv_conf->id; 401 key->tt_keyrev = arc4random(); 402 arc4random_buf(key->tt_key, sizeof(key->tt_key)); 403 } 404 405 void 406 server_init(struct privsep *ps, struct privsep_proc *p, void *arg) 407 { 408 server_http(); 409 410 if (config_init(ps->ps_env) == -1) 411 fatal("failed to initialize configuration"); 412 413 /* We use a custom shutdown callback */ 414 p->p_shutdown = server_shutdown; 415 416 /* Unlimited file descriptors (use system limits) */ 417 socket_rlimit(-1); 418 419 if (pledge("stdio rpath inet unix recvfd", NULL) == -1) 420 fatal("pledge"); 421 422 #if 0 423 /* Schedule statistics timer */ 424 evtimer_set(&ps->ps_env->sc_statev, server_statistics, NULL); 425 memcpy(&tv, &ps->ps_env->sc_statinterval, sizeof(tv)); 426 evtimer_add(&ps->ps_env->sc_statev, &tv); 427 #endif 428 } 429 430 void 431 server_launch(void) 432 { 433 struct server *srv; 434 435 TAILQ_FOREACH(srv, httpd_env->sc_servers, srv_entry) { 436 log_debug("%s: configuring server %s", __func__, 437 srv->srv_conf.name); 438 439 server_tls_init(srv); 440 server_http_init(srv); 441 442 log_debug("%s: running server %s", __func__, 443 srv->srv_conf.name); 444 445 event_set(&srv->srv_ev, srv->srv_s, EV_READ, 446 server_accept, srv); 447 event_add(&srv->srv_ev, NULL); 448 evtimer_set(&srv->srv_evt, server_accept, srv); 449 } 450 } 451 452 void 453 server_purge(struct server *srv) 454 { 455 struct client *clt; 456 struct server_config *srv_conf; 457 458 /* shutdown and remove server */ 459 if (event_initialized(&srv->srv_ev)) 460 event_del(&srv->srv_ev); 461 if (evtimer_initialized(&srv->srv_evt)) 462 evtimer_del(&srv->srv_evt); 463 464 if (srv->srv_s != -1) 465 close(srv->srv_s); 466 TAILQ_REMOVE(httpd_env->sc_servers, srv, srv_entry); 467 468 /* cleanup sessions */ 469 while ((clt = 470 SPLAY_ROOT(&srv->srv_clients)) != NULL) 471 server_close(clt, NULL); 472 473 /* cleanup hosts */ 474 while ((srv_conf = 475 TAILQ_FIRST(&srv->srv_hosts)) != NULL) { 476 TAILQ_REMOVE(&srv->srv_hosts, srv_conf, entry); 477 478 /* It might point to our own "default" entry */ 479 if (srv_conf != &srv->srv_conf) { 480 serverconfig_free(srv_conf); 481 free(srv_conf); 482 } 483 } 484 485 tls_config_free(srv->srv_tls_config); 486 tls_free(srv->srv_tls_ctx); 487 488 free(srv); 489 } 490 491 void 492 serverconfig_free(struct server_config *srv_conf) 493 { 494 struct fastcgi_param *param, *tparam; 495 496 free(srv_conf->return_uri); 497 free(srv_conf->tls_ca_file); 498 free(srv_conf->tls_ca); 499 free(srv_conf->tls_cert_file); 500 free(srv_conf->tls_crl_file); 501 free(srv_conf->tls_crl); 502 free(srv_conf->tls_key_file); 503 free(srv_conf->tls_ocsp_staple_file); 504 free(srv_conf->tls_ocsp_staple); 505 freezero(srv_conf->tls_cert, srv_conf->tls_cert_len); 506 freezero(srv_conf->tls_key, srv_conf->tls_key_len); 507 508 TAILQ_FOREACH_SAFE(param, &srv_conf->fcgiparams, entry, tparam) 509 free(param); 510 } 511 512 void 513 serverconfig_reset(struct server_config *srv_conf) 514 { 515 srv_conf->auth = NULL; 516 srv_conf->return_uri = NULL; 517 srv_conf->tls_ca = NULL; 518 srv_conf->tls_ca_file = NULL; 519 srv_conf->tls_cert = NULL; 520 srv_conf->tls_cert_file = NULL; 521 srv_conf->tls_crl = NULL; 522 srv_conf->tls_crl_file = NULL; 523 srv_conf->tls_key = NULL; 524 srv_conf->tls_key_file = NULL; 525 srv_conf->tls_ocsp_staple = NULL; 526 srv_conf->tls_ocsp_staple_file = NULL; 527 TAILQ_INIT(&srv_conf->fcgiparams); 528 } 529 530 struct server * 531 server_byaddr(struct sockaddr *addr, in_port_t port) 532 { 533 struct server *srv; 534 535 TAILQ_FOREACH(srv, httpd_env->sc_servers, srv_entry) { 536 if (port == srv->srv_conf.port && 537 sockaddr_cmp((struct sockaddr *)&srv->srv_conf.ss, 538 addr, srv->srv_conf.prefixlen) == 0) 539 return (srv); 540 } 541 542 return (NULL); 543 } 544 545 struct server_config * 546 serverconfig_byid(uint32_t id) 547 { 548 struct server *srv; 549 struct server_config *srv_conf; 550 551 TAILQ_FOREACH(srv, httpd_env->sc_servers, srv_entry) { 552 if (srv->srv_conf.id == id) 553 return (&srv->srv_conf); 554 TAILQ_FOREACH(srv_conf, &srv->srv_hosts, entry) { 555 if (srv_conf->id == id) 556 return (srv_conf); 557 } 558 } 559 560 return (NULL); 561 } 562 563 struct server * 564 server_byid(uint32_t id) 565 { 566 struct server *srv; 567 568 TAILQ_FOREACH(srv, httpd_env->sc_servers, srv_entry) { 569 if (srv->srv_conf.id == id) 570 return (srv); 571 } 572 return (NULL); 573 } 574 575 int 576 server_foreach(int (*srv_cb)(struct server *, 577 struct server_config *, void *), void *arg) 578 { 579 struct server *srv; 580 struct server_config *srv_conf; 581 582 TAILQ_FOREACH(srv, httpd_env->sc_servers, srv_entry) { 583 if ((srv_cb)(srv, &srv->srv_conf, arg) == -1) 584 return (-1); 585 TAILQ_FOREACH(srv_conf, &srv->srv_hosts, entry) { 586 if ((srv_cb)(srv, srv_conf, arg) == -1) 587 return (-1); 588 } 589 } 590 591 return (0); 592 } 593 594 struct server * 595 server_match(struct server *s2, int match_name) 596 { 597 struct server *s1; 598 599 /* Attempt to find matching server. */ 600 TAILQ_FOREACH(s1, httpd_env->sc_servers, srv_entry) { 601 if ((s1->srv_conf.flags & SRVFLAG_LOCATION) != 0) 602 continue; 603 if (match_name) { 604 if (strcmp(s1->srv_conf.name, s2->srv_conf.name) != 0) 605 continue; 606 } 607 if (s1->srv_conf.port != s2->srv_conf.port) 608 continue; 609 if (sockaddr_cmp( 610 (struct sockaddr *)&s1->srv_conf.ss, 611 (struct sockaddr *)&s2->srv_conf.ss, 612 s1->srv_conf.prefixlen) != 0) 613 continue; 614 615 return (s1); 616 } 617 618 return (NULL); 619 } 620 621 int 622 server_socket_af(struct sockaddr_storage *ss, in_port_t port) 623 { 624 switch (ss->ss_family) { 625 case AF_INET: 626 ((struct sockaddr_in *)ss)->sin_port = port; 627 ((struct sockaddr_in *)ss)->sin_len = 628 sizeof(struct sockaddr_in); 629 break; 630 case AF_INET6: 631 ((struct sockaddr_in6 *)ss)->sin6_port = port; 632 ((struct sockaddr_in6 *)ss)->sin6_len = 633 sizeof(struct sockaddr_in6); 634 break; 635 default: 636 return (-1); 637 } 638 639 return (0); 640 } 641 642 in_port_t 643 server_socket_getport(struct sockaddr_storage *ss) 644 { 645 switch (ss->ss_family) { 646 case AF_INET: 647 return (((struct sockaddr_in *)ss)->sin_port); 648 case AF_INET6: 649 return (((struct sockaddr_in6 *)ss)->sin6_port); 650 default: 651 return (0); 652 } 653 654 /* NOTREACHED */ 655 return (0); 656 } 657 658 int 659 server_socket(struct sockaddr_storage *ss, in_port_t port, 660 struct server_config *srv_conf, int fd, int reuseport) 661 { 662 struct linger lng; 663 int s = -1, val; 664 665 if (server_socket_af(ss, port) == -1) 666 goto bad; 667 668 s = fd == -1 ? socket(ss->ss_family, SOCK_STREAM | SOCK_NONBLOCK, 669 IPPROTO_TCP) : fd; 670 if (s == -1) 671 goto bad; 672 673 /* 674 * Socket options 675 */ 676 memset(&lng, 0, sizeof(lng)); 677 if (setsockopt(s, SOL_SOCKET, SO_LINGER, &lng, sizeof(lng)) == -1) 678 goto bad; 679 if (reuseport) { 680 val = 1; 681 if (setsockopt(s, SOL_SOCKET, SO_REUSEPORT, &val, 682 sizeof(int)) == -1) 683 goto bad; 684 } 685 if (srv_conf->tcpflags & TCPFLAG_BUFSIZ) { 686 val = srv_conf->tcpbufsiz; 687 if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, 688 &val, sizeof(val)) == -1) 689 goto bad; 690 val = srv_conf->tcpbufsiz; 691 if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, 692 &val, sizeof(val)) == -1) 693 goto bad; 694 } 695 696 /* 697 * IP options 698 */ 699 if (srv_conf->tcpflags & TCPFLAG_IPTTL) { 700 val = (int)srv_conf->tcpipttl; 701 switch (ss->ss_family) { 702 case AF_INET: 703 if (setsockopt(s, IPPROTO_IP, IP_TTL, 704 &val, sizeof(val)) == -1) 705 goto bad; 706 break; 707 case AF_INET6: 708 if (setsockopt(s, IPPROTO_IPV6, IPV6_UNICAST_HOPS, 709 &val, sizeof(val)) == -1) 710 goto bad; 711 break; 712 } 713 } 714 if (srv_conf->tcpflags & TCPFLAG_IPMINTTL) { 715 val = (int)srv_conf->tcpipminttl; 716 switch (ss->ss_family) { 717 case AF_INET: 718 if (setsockopt(s, IPPROTO_IP, IP_MINTTL, 719 &val, sizeof(val)) == -1) 720 goto bad; 721 break; 722 case AF_INET6: 723 if (setsockopt(s, IPPROTO_IPV6, IPV6_MINHOPCOUNT, 724 &val, sizeof(val)) == -1) 725 goto bad; 726 break; 727 } 728 } 729 730 /* 731 * TCP options 732 */ 733 if (srv_conf->tcpflags & (TCPFLAG_NODELAY|TCPFLAG_NNODELAY)) { 734 if (srv_conf->tcpflags & TCPFLAG_NNODELAY) 735 val = 0; 736 else 737 val = 1; 738 if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, 739 &val, sizeof(val)) == -1) 740 goto bad; 741 } 742 if (srv_conf->tcpflags & (TCPFLAG_SACK|TCPFLAG_NSACK)) { 743 if (srv_conf->tcpflags & TCPFLAG_NSACK) 744 val = 0; 745 else 746 val = 1; 747 if (setsockopt(s, IPPROTO_TCP, TCP_SACK_ENABLE, 748 &val, sizeof(val)) == -1) 749 goto bad; 750 } 751 752 return (s); 753 754 bad: 755 if (s != -1) 756 close(s); 757 return (-1); 758 } 759 760 int 761 server_socket_listen(struct sockaddr_storage *ss, in_port_t port, 762 struct server_config *srv_conf) 763 { 764 int s; 765 766 if ((s = server_socket(ss, port, srv_conf, -1, 1)) == -1) 767 return (-1); 768 769 if (bind(s, (struct sockaddr *)ss, ss->ss_len) == -1) 770 goto bad; 771 if (listen(s, srv_conf->tcpbacklog) == -1) 772 goto bad; 773 774 return (s); 775 776 bad: 777 close(s); 778 return (-1); 779 } 780 781 int 782 server_socket_connect(struct sockaddr_storage *ss, in_port_t port, 783 struct server_config *srv_conf) 784 { 785 int s; 786 787 if ((s = server_socket(ss, port, srv_conf, -1, 0)) == -1) 788 return (-1); 789 790 if (connect(s, (struct sockaddr *)ss, ss->ss_len) == -1) { 791 if (errno != EINPROGRESS) 792 goto bad; 793 } 794 795 return (s); 796 797 bad: 798 close(s); 799 return (-1); 800 } 801 802 void 803 server_tls_readcb(int fd, short event, void *arg) 804 { 805 struct bufferevent *bufev = arg; 806 struct client *clt = bufev->cbarg; 807 char rbuf[IBUF_READ_SIZE]; 808 int what = EVBUFFER_READ; 809 int howmuch = IBUF_READ_SIZE; 810 ssize_t ret; 811 size_t len; 812 813 if (event == EV_TIMEOUT) { 814 what |= EVBUFFER_TIMEOUT; 815 goto err; 816 } 817 818 if (bufev->wm_read.high != 0) 819 howmuch = MINIMUM(sizeof(rbuf), bufev->wm_read.high); 820 821 ret = tls_read(clt->clt_tls_ctx, rbuf, howmuch); 822 if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) { 823 goto retry; 824 } else if (ret < 0) { 825 what |= EVBUFFER_ERROR; 826 goto err; 827 } 828 len = ret; 829 830 if (len == 0) { 831 what |= EVBUFFER_EOF; 832 goto err; 833 } 834 835 if (evbuffer_add(bufev->input, rbuf, len) == -1) { 836 what |= EVBUFFER_ERROR; 837 goto err; 838 } 839 840 server_bufferevent_add(&bufev->ev_read, bufev->timeout_read); 841 842 len = EVBUFFER_LENGTH(bufev->input); 843 if (bufev->wm_read.low != 0 && len < bufev->wm_read.low) 844 return; 845 if (bufev->wm_read.high != 0 && len > bufev->wm_read.high) { 846 struct evbuffer *buf = bufev->input; 847 event_del(&bufev->ev_read); 848 evbuffer_setcb(buf, bufferevent_read_pressure_cb, bufev); 849 return; 850 } 851 852 if (bufev->readcb != NULL) 853 (*bufev->readcb)(bufev, bufev->cbarg); 854 return; 855 856 retry: 857 server_bufferevent_add(&bufev->ev_read, bufev->timeout_read); 858 return; 859 860 err: 861 (*bufev->errorcb)(bufev, what, bufev->cbarg); 862 } 863 864 void 865 server_tls_writecb(int fd, short event, void *arg) 866 { 867 struct bufferevent *bufev = arg; 868 struct client *clt = bufev->cbarg; 869 ssize_t ret; 870 short what = EVBUFFER_WRITE; 871 size_t len; 872 873 if (event == EV_TIMEOUT) { 874 what |= EVBUFFER_TIMEOUT; 875 goto err; 876 } 877 878 if (EVBUFFER_LENGTH(bufev->output)) { 879 ret = tls_write(clt->clt_tls_ctx, 880 EVBUFFER_DATA(bufev->output), 881 EVBUFFER_LENGTH(bufev->output)); 882 if (ret == TLS_WANT_POLLIN || ret == TLS_WANT_POLLOUT) { 883 goto retry; 884 } else if (ret < 0) { 885 what |= EVBUFFER_ERROR; 886 goto err; 887 } 888 len = ret; 889 evbuffer_drain(bufev->output, len); 890 } 891 892 if (EVBUFFER_LENGTH(bufev->output) != 0) 893 server_bufferevent_add(&bufev->ev_write, bufev->timeout_write); 894 895 if (bufev->writecb != NULL && 896 EVBUFFER_LENGTH(bufev->output) <= bufev->wm_write.low) 897 (*bufev->writecb)(bufev, bufev->cbarg); 898 return; 899 900 retry: 901 server_bufferevent_add(&bufev->ev_write, bufev->timeout_write); 902 return; 903 904 err: 905 (*bufev->errorcb)(bufev, what, bufev->cbarg); 906 } 907 908 void 909 server_input(struct client *clt) 910 { 911 struct server_config *srv_conf = clt->clt_srv_conf; 912 evbuffercb inrd = server_read; 913 evbuffercb inwr = server_write; 914 socklen_t slen; 915 916 if (server_httpdesc_init(clt) == -1) { 917 server_close(clt, "failed to allocate http descriptor"); 918 return; 919 } 920 921 clt->clt_toread = TOREAD_HTTP_HEADER; 922 inrd = server_read_http; 923 924 slen = sizeof(clt->clt_sndbufsiz); 925 if (getsockopt(clt->clt_s, SOL_SOCKET, SO_SNDBUF, 926 &clt->clt_sndbufsiz, &slen) == -1) { 927 server_close(clt, "failed to get send buffer size"); 928 return; 929 } 930 931 /* 932 * Client <-> Server 933 */ 934 clt->clt_bev = bufferevent_new(clt->clt_s, inrd, inwr, 935 server_error, clt); 936 if (clt->clt_bev == NULL) { 937 server_close(clt, "failed to allocate input buffer event"); 938 return; 939 } 940 941 if (srv_conf->flags & SRVFLAG_TLS) { 942 event_set(&clt->clt_bev->ev_read, clt->clt_s, EV_READ, 943 server_tls_readcb, clt->clt_bev); 944 event_set(&clt->clt_bev->ev_write, clt->clt_s, EV_WRITE, 945 server_tls_writecb, clt->clt_bev); 946 } 947 948 /* Adjust write watermark to the socket buffer output size */ 949 bufferevent_setwatermark(clt->clt_bev, EV_WRITE, 950 SERVER_MIN_PREFETCHED * clt->clt_sndbufsiz, 0); 951 /* Read at most amount of data that fits in one fcgi record. */ 952 bufferevent_setwatermark(clt->clt_bev, EV_READ, 0, FCGI_CONTENT_SIZE); 953 954 bufferevent_settimeout(clt->clt_bev, 955 srv_conf->requesttimeout.tv_sec, srv_conf->requesttimeout.tv_sec); 956 bufferevent_enable(clt->clt_bev, EV_READ|EV_WRITE); 957 } 958 959 void 960 server_write(struct bufferevent *bev, void *arg) 961 { 962 struct client *clt = arg; 963 struct evbuffer *dst = EVBUFFER_OUTPUT(bev); 964 965 if (EVBUFFER_LENGTH(dst) == 0 && 966 clt->clt_toread == TOREAD_HTTP_NONE) 967 goto done; 968 969 getmonotime(&clt->clt_tv_last); 970 971 if (clt->clt_done) 972 goto done; 973 974 if (clt->clt_srvbev && clt->clt_srvbev_throttled) { 975 bufferevent_enable(clt->clt_srvbev, EV_READ); 976 clt->clt_srvbev_throttled = 0; 977 } 978 979 return; 980 done: 981 (*bev->errorcb)(bev, EVBUFFER_WRITE, bev->cbarg); 982 return; 983 } 984 985 void 986 server_dump(struct client *clt, const void *buf, size_t len) 987 { 988 if (!len) 989 return; 990 991 /* 992 * This function will dump the specified message directly 993 * to the underlying client, without waiting for success 994 * of non-blocking events etc. This is useful to print an 995 * error message before gracefully closing the client. 996 */ 997 if (clt->clt_tls_ctx != NULL) 998 (void)tls_write(clt->clt_tls_ctx, buf, len); 999 else 1000 (void)write(clt->clt_s, buf, len); 1001 } 1002 1003 void 1004 server_read(struct bufferevent *bev, void *arg) 1005 { 1006 struct client *clt = arg; 1007 struct evbuffer *src = EVBUFFER_INPUT(bev); 1008 1009 getmonotime(&clt->clt_tv_last); 1010 1011 if (!EVBUFFER_LENGTH(src)) 1012 return; 1013 if (server_bufferevent_write_buffer(clt, src) == -1) 1014 goto fail; 1015 if (clt->clt_done) 1016 goto done; 1017 1018 if (EVBUFFER_LENGTH(EVBUFFER_OUTPUT(clt->clt_bev)) > (size_t) 1019 SERVER_MAX_PREFETCH * clt->clt_sndbufsiz) { 1020 bufferevent_disable(clt->clt_srvbev, EV_READ); 1021 clt->clt_srvbev_throttled = 1; 1022 } 1023 1024 return; 1025 done: 1026 (*bev->errorcb)(bev, EVBUFFER_READ, bev->cbarg); 1027 return; 1028 fail: 1029 server_close(clt, strerror(errno)); 1030 } 1031 1032 void 1033 server_error(struct bufferevent *bev, short error, void *arg) 1034 { 1035 struct client *clt = arg; 1036 struct evbuffer *dst; 1037 1038 if (error & EVBUFFER_TIMEOUT) { 1039 server_abort_http(clt, 408, "timeout"); 1040 return; 1041 } 1042 if (error & EVBUFFER_ERROR) { 1043 if (errno == EFBIG) { 1044 bufferevent_enable(bev, EV_READ); 1045 return; 1046 } 1047 server_close(clt, "buffer event error"); 1048 return; 1049 } 1050 if (error & EVBUFFER_EOF) { 1051 server_close(clt, "closed"); 1052 return; 1053 } 1054 if (error & (EVBUFFER_READ|EVBUFFER_WRITE)) { 1055 bufferevent_disable(bev, EV_READ|EV_WRITE); 1056 1057 clt->clt_done = 1; 1058 1059 dst = EVBUFFER_OUTPUT(clt->clt_bev); 1060 if (EVBUFFER_LENGTH(dst)) { 1061 /* Finish writing all data first */ 1062 bufferevent_enable(clt->clt_bev, EV_WRITE); 1063 return; 1064 } 1065 1066 server_close(clt, "done"); 1067 return; 1068 } 1069 server_close(clt, "unknown event error"); 1070 return; 1071 } 1072 1073 void 1074 server_accept(int fd, short event, void *arg) 1075 { 1076 struct server *srv = arg; 1077 struct client *clt = NULL; 1078 socklen_t slen; 1079 struct sockaddr_storage ss; 1080 int s = -1; 1081 1082 event_add(&srv->srv_ev, NULL); 1083 if ((event & EV_TIMEOUT)) 1084 return; 1085 1086 slen = sizeof(ss); 1087 if ((s = accept_reserve(fd, (struct sockaddr *)&ss, 1088 &slen, FD_RESERVE, &server_inflight)) == -1) { 1089 /* 1090 * Pause accept if we are out of file descriptors, or 1091 * libevent will haunt us here too. 1092 */ 1093 if (errno == ENFILE || errno == EMFILE) { 1094 struct timeval evtpause = { 1, 0 }; 1095 1096 event_del(&srv->srv_ev); 1097 evtimer_add(&srv->srv_evt, &evtpause); 1098 log_debug("%s: deferring connections", __func__); 1099 } 1100 return; 1101 } 1102 if (server_clients >= SERVER_MAX_CLIENTS) 1103 goto err; 1104 1105 if ((clt = calloc(1, sizeof(*clt))) == NULL) 1106 goto err; 1107 1108 /* Pre-allocate log buffer */ 1109 clt->clt_log = evbuffer_new(); 1110 if (clt->clt_log == NULL) 1111 goto err; 1112 1113 clt->clt_s = s; 1114 clt->clt_fd = -1; 1115 clt->clt_toread = TOREAD_UNLIMITED; 1116 clt->clt_srv = srv; 1117 clt->clt_srv_conf = &srv->srv_conf; 1118 clt->clt_id = ++server_cltid; 1119 clt->clt_srv_id = srv->srv_conf.id; 1120 clt->clt_pid = getpid(); 1121 clt->clt_inflight = 1; 1122 1123 /* get local address */ 1124 slen = sizeof(clt->clt_srv_ss); 1125 if (getsockname(s, (struct sockaddr *)&clt->clt_srv_ss, 1126 &slen) == -1) { 1127 server_close(clt, "listen address lookup failed"); 1128 return; 1129 } 1130 1131 /* get client address */ 1132 memcpy(&clt->clt_ss, &ss, sizeof(clt->clt_ss)); 1133 1134 /* get ports */ 1135 switch (ss.ss_family) { 1136 case AF_INET: 1137 clt->clt_port = ((struct sockaddr_in *)&ss)->sin_port; 1138 break; 1139 case AF_INET6: 1140 clt->clt_port = ((struct sockaddr_in6 *)&ss)->sin6_port; 1141 break; 1142 } 1143 1144 getmonotime(&clt->clt_tv_start); 1145 memcpy(&clt->clt_tv_last, &clt->clt_tv_start, sizeof(clt->clt_tv_last)); 1146 1147 server_clients++; 1148 SPLAY_INSERT(client_tree, &srv->srv_clients, clt); 1149 1150 /* Pre-allocate output buffer */ 1151 clt->clt_output = evbuffer_new(); 1152 if (clt->clt_output == NULL) { 1153 server_close(clt, "failed to allocate output buffer"); 1154 return; 1155 } 1156 1157 if (srv->srv_conf.flags & SRVFLAG_TLS) { 1158 if (tls_accept_socket(srv->srv_tls_ctx, &clt->clt_tls_ctx, 1159 clt->clt_s) != 0) { 1160 server_close(clt, "failed to setup tls context"); 1161 return; 1162 } 1163 event_again(&clt->clt_ev, clt->clt_s, EV_TIMEOUT|EV_READ, 1164 server_tls_handshake, &clt->clt_tv_start, 1165 &srv->srv_conf.timeout, clt); 1166 return; 1167 } 1168 1169 server_input(clt); 1170 return; 1171 1172 err: 1173 if (s != -1) { 1174 close(s); 1175 free(clt); 1176 /* 1177 * the client struct was not completely set up, but still 1178 * counted as an inflight client. account for this. 1179 */ 1180 server_inflight_dec(NULL, __func__); 1181 } 1182 } 1183 1184 void 1185 server_tls_handshake(int fd, short event, void *arg) 1186 { 1187 struct client *clt = (struct client *)arg; 1188 struct server *srv = (struct server *)clt->clt_srv; 1189 int ret; 1190 1191 if (event == EV_TIMEOUT) { 1192 server_close(clt, "tls handshake timeout"); 1193 return; 1194 } 1195 1196 if (srv->srv_tls_ctx == NULL || clt->clt_tls_ctx == NULL) 1197 fatalx("NULL tls context"); 1198 1199 ret = tls_handshake(clt->clt_tls_ctx); 1200 if (ret == 0) { 1201 server_input(clt); 1202 } else if (ret == TLS_WANT_POLLIN) { 1203 event_again(&clt->clt_ev, clt->clt_s, EV_TIMEOUT|EV_READ, 1204 server_tls_handshake, &clt->clt_tv_start, 1205 &srv->srv_conf.timeout, clt); 1206 } else if (ret == TLS_WANT_POLLOUT) { 1207 event_again(&clt->clt_ev, clt->clt_s, EV_TIMEOUT|EV_WRITE, 1208 server_tls_handshake, &clt->clt_tv_start, 1209 &srv->srv_conf.timeout, clt); 1210 } else { 1211 log_debug("%s: tls handshake failed - %s", __func__, 1212 tls_error(clt->clt_tls_ctx)); 1213 server_close(clt, "tls handshake failed"); 1214 } 1215 } 1216 1217 void 1218 server_inflight_dec(struct client *clt, const char *why) 1219 { 1220 if (clt != NULL) { 1221 /* the flight already left inflight mode. */ 1222 if (clt->clt_inflight == 0) 1223 return; 1224 clt->clt_inflight = 0; 1225 } 1226 1227 /* the file was never opened, thus this was an inflight client. */ 1228 server_inflight--; 1229 DPRINTF("%s: inflight decremented, now %d, %s", 1230 __func__, server_inflight, why); 1231 } 1232 1233 void 1234 server_sendlog(struct server_config *srv_conf, int cmd, const char *emsg, ...) 1235 { 1236 va_list ap; 1237 char *msg; 1238 int ret; 1239 struct iovec iov[2]; 1240 1241 if (srv_conf->flags & SRVFLAG_SYSLOG) { 1242 va_start(ap, emsg); 1243 if (cmd == IMSG_LOG_ACCESS) 1244 vlog(LOG_INFO, emsg, ap); 1245 else 1246 vlog(LOG_DEBUG, emsg, ap); 1247 va_end(ap); 1248 return; 1249 } 1250 1251 va_start(ap, emsg); 1252 ret = vasprintf(&msg, emsg, ap); 1253 va_end(ap); 1254 if (ret == -1) { 1255 log_warn("%s: vasprintf", __func__); 1256 return; 1257 } 1258 1259 iov[0].iov_base = &srv_conf->id; 1260 iov[0].iov_len = sizeof(srv_conf->id); 1261 iov[1].iov_base = msg; 1262 iov[1].iov_len = strlen(msg) + 1; 1263 1264 if (proc_composev(httpd_env->sc_ps, PROC_LOGGER, cmd, iov, 2) != 0) { 1265 log_warn("%s: failed to compose imsg", __func__); 1266 return; 1267 } 1268 } 1269 1270 void 1271 server_log(struct client *clt, const char *msg) 1272 { 1273 char ibuf[HOST_NAME_MAX+1], obuf[HOST_NAME_MAX+1]; 1274 struct server_config *srv_conf = clt->clt_srv_conf; 1275 char *ptr = NULL, *vmsg = NULL; 1276 int debug_cmd = -1; 1277 1278 switch (srv_conf->logformat) { 1279 case LOG_FORMAT_CONNECTION: 1280 debug_cmd = IMSG_LOG_ACCESS; 1281 break; 1282 default: 1283 if (log_getverbose() > 1) 1284 debug_cmd = IMSG_LOG_ERROR; 1285 if (EVBUFFER_LENGTH(clt->clt_log)) { 1286 while ((ptr = 1287 evbuffer_readline(clt->clt_log)) != NULL) { 1288 server_sendlog(srv_conf, 1289 IMSG_LOG_ACCESS, "%s", ptr); 1290 free(ptr); 1291 } 1292 } 1293 break; 1294 } 1295 1296 if (debug_cmd != -1 && msg != NULL) { 1297 memset(ibuf, 0, sizeof(ibuf)); 1298 memset(obuf, 0, sizeof(obuf)); 1299 (void)print_host(&clt->clt_ss, ibuf, sizeof(ibuf)); 1300 (void)server_http_host(&clt->clt_srv_ss, obuf, sizeof(obuf)); 1301 if (EVBUFFER_LENGTH(clt->clt_log) && 1302 evbuffer_add_printf(clt->clt_log, "\n") != -1) 1303 ptr = evbuffer_readline(clt->clt_log); 1304 (void)stravis(&vmsg, msg, HTTPD_LOGVIS); 1305 server_sendlog(srv_conf, debug_cmd, "server %s, " 1306 "client %d (%d active), %s:%u -> %s, " 1307 "%s%s%s", srv_conf->name, clt->clt_id, server_clients, 1308 ibuf, ntohs(clt->clt_port), obuf, vmsg == NULL ? "" : vmsg, 1309 ptr == NULL ? "" : ",", ptr == NULL ? "" : ptr); 1310 free(vmsg); 1311 free(ptr); 1312 } 1313 } 1314 1315 void 1316 server_close(struct client *clt, const char *msg) 1317 { 1318 struct server *srv = clt->clt_srv; 1319 1320 SPLAY_REMOVE(client_tree, &srv->srv_clients, clt); 1321 1322 /* free the HTTP descriptors incl. headers */ 1323 server_close_http(clt); 1324 1325 event_del(&clt->clt_ev); 1326 if (clt->clt_bev != NULL) 1327 bufferevent_disable(clt->clt_bev, EV_READ|EV_WRITE); 1328 if (clt->clt_srvbev != NULL) 1329 bufferevent_disable(clt->clt_srvbev, EV_READ|EV_WRITE); 1330 1331 server_log(clt, msg); 1332 1333 if (clt->clt_bev != NULL) 1334 bufferevent_free(clt->clt_bev); 1335 if (clt->clt_output != NULL) 1336 evbuffer_free(clt->clt_output); 1337 if (clt->clt_srvevb != NULL) 1338 evbuffer_free(clt->clt_srvevb); 1339 1340 if (clt->clt_srvbev != NULL) 1341 bufferevent_free(clt->clt_srvbev); 1342 if (clt->clt_fd != -1) 1343 close(clt->clt_fd); 1344 if (clt->clt_s != -1) 1345 close(clt->clt_s); 1346 1347 if (clt->clt_tls_ctx != NULL) 1348 tls_close(clt->clt_tls_ctx); 1349 tls_free(clt->clt_tls_ctx); 1350 1351 server_inflight_dec(clt, __func__); 1352 1353 if (clt->clt_log != NULL) 1354 evbuffer_free(clt->clt_log); 1355 1356 free(clt); 1357 server_clients--; 1358 } 1359 1360 int 1361 server_dispatch_parent(int fd, struct privsep_proc *p, struct imsg *imsg) 1362 { 1363 struct server *srv; 1364 struct server_tls_ticket key; 1365 1366 switch (imsg->hdr.type) { 1367 case IMSG_CFG_MEDIA: 1368 config_getmedia(httpd_env, imsg); 1369 break; 1370 case IMSG_CFG_AUTH: 1371 config_getauth(httpd_env, imsg); 1372 break; 1373 case IMSG_CFG_SERVER: 1374 config_getserver(httpd_env, imsg); 1375 break; 1376 case IMSG_CFG_TLS: 1377 config_getserver_tls(httpd_env, imsg); 1378 break; 1379 case IMSG_CFG_FCGI: 1380 config_getserver_fcgiparams(httpd_env, imsg); 1381 break; 1382 case IMSG_CFG_DONE: 1383 config_getcfg(httpd_env, imsg); 1384 break; 1385 case IMSG_CTL_START: 1386 server_launch(); 1387 break; 1388 case IMSG_CTL_RESET: 1389 config_getreset(httpd_env, imsg); 1390 break; 1391 case IMSG_TLSTICKET_REKEY: 1392 IMSG_SIZE_CHECK(imsg, (&key)); 1393 memcpy(&key, imsg->data, sizeof(key)); 1394 /* apply to the right server */ 1395 srv = server_byid(key.tt_id); 1396 if (srv) { 1397 tls_config_add_ticket_key(srv->srv_tls_config, 1398 key.tt_keyrev, key.tt_key, sizeof(key.tt_key)); 1399 } 1400 break; 1401 default: 1402 return (-1); 1403 } 1404 1405 return (0); 1406 } 1407 1408 int 1409 server_dispatch_logger(int fd, struct privsep_proc *p, struct imsg *imsg) 1410 { 1411 switch (imsg->hdr.type) { 1412 default: 1413 return (-1); 1414 } 1415 1416 return (0); 1417 } 1418 1419 int 1420 server_bufferevent_add(struct event *ev, int timeout) 1421 { 1422 struct timeval tv, *ptv = NULL; 1423 1424 if (timeout) { 1425 timerclear(&tv); 1426 tv.tv_sec = timeout; 1427 ptv = &tv; 1428 } 1429 1430 return (event_add(ev, ptv)); 1431 } 1432 1433 int 1434 server_bufferevent_printf(struct client *clt, const char *fmt, ...) 1435 { 1436 int ret; 1437 va_list ap; 1438 char *str; 1439 1440 va_start(ap, fmt); 1441 ret = vasprintf(&str, fmt, ap); 1442 va_end(ap); 1443 1444 if (ret == -1) 1445 return (ret); 1446 1447 ret = server_bufferevent_print(clt, str); 1448 free(str); 1449 1450 return (ret); 1451 } 1452 1453 int 1454 server_bufferevent_print(struct client *clt, const char *str) 1455 { 1456 if (clt->clt_bev == NULL) 1457 return (evbuffer_add(clt->clt_output, str, strlen(str))); 1458 return (bufferevent_write(clt->clt_bev, str, strlen(str))); 1459 } 1460 1461 int 1462 server_bufferevent_write_buffer(struct client *clt, struct evbuffer *buf) 1463 { 1464 if (clt->clt_bev == NULL) 1465 return (evbuffer_add_buffer(clt->clt_output, buf)); 1466 return (bufferevent_write_buffer(clt->clt_bev, buf)); 1467 } 1468 1469 int 1470 server_bufferevent_write_chunk(struct client *clt, 1471 struct evbuffer *buf, size_t size) 1472 { 1473 int ret; 1474 ret = server_bufferevent_write(clt, buf->buffer, size); 1475 if (ret != -1) 1476 evbuffer_drain(buf, size); 1477 return (ret); 1478 } 1479 1480 int 1481 server_bufferevent_write(struct client *clt, void *data, size_t size) 1482 { 1483 if (clt->clt_bev == NULL) 1484 return (evbuffer_add(clt->clt_output, data, size)); 1485 return (bufferevent_write(clt->clt_bev, data, size)); 1486 } 1487 1488 int 1489 server_client_cmp(struct client *a, struct client *b) 1490 { 1491 return ((int)a->clt_id - b->clt_id); 1492 } 1493 1494 SPLAY_GENERATE(client_tree, client, clt_nodes, server_client_cmp); 1495