server_fcgi.c revision 1.38
1/* $OpenBSD: server_fcgi.c,v 1.38 2014/09/02 16:20:41 reyk Exp $ */ 2 3/* 4 * Copyright (c) 2014 Florian Obser <florian@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/un.h> 25#include <sys/tree.h> 26#include <sys/hash.h> 27 28#include <net/if.h> 29#include <netinet/in_systm.h> 30#include <netinet/in.h> 31#include <netinet/ip.h> 32#include <netinet/tcp.h> 33#include <arpa/inet.h> 34 35#include <errno.h> 36#include <fcntl.h> 37#include <stdlib.h> 38#include <string.h> 39#include <unistd.h> 40#include <stdio.h> 41#include <ctype.h> 42#include <err.h> 43#include <event.h> 44 45#include "httpd.h" 46#include "http.h" 47 48#define FCGI_PADDING_SIZE 255 49#define FCGI_RECORD_SIZE \ 50 (sizeof(struct fcgi_record_header) + FCGI_CONTENT_SIZE + FCGI_PADDING_SIZE) 51 52#define FCGI_BEGIN_REQUEST 1 53#define FCGI_ABORT_REQUEST 2 54#define FCGI_END_REQUEST 3 55#define FCGI_PARAMS 4 56#define FCGI_STDIN 5 57#define FCGI_STDOUT 6 58#define FCGI_STDERR 7 59#define FCGI_DATA 8 60#define FCGI_GET_VALUES 9 61#define FCGI_GET_VALUES_RESULT 10 62#define FCGI_UNKNOWN_TYPE 11 63#define FCGI_MAXTYPE (FCGI_UNKNOWN_TYPE) 64 65#define FCGI_RESPONDER 1 66 67struct fcgi_record_header { 68 uint8_t version; 69 uint8_t type; 70 uint16_t id; 71 uint16_t content_len; 72 uint8_t padding_len; 73 uint8_t reserved; 74} __packed; 75 76struct fcgi_begin_request_body { 77 uint16_t role; 78 uint8_t flags; 79 uint8_t reserved[5]; 80} __packed; 81 82struct server_fcgi_param { 83 int total_len; 84 uint8_t buf[FCGI_RECORD_SIZE]; 85}; 86 87int server_fcgi_header(struct client *, u_int); 88void server_fcgi_read(struct bufferevent *, void *); 89int server_fcgi_writeheader(struct client *, struct kv *, void *); 90int server_fcgi_writechunk(struct client *); 91int server_fcgi_getheaders(struct client *); 92int fcgi_add_param(struct server_fcgi_param *, const char *, const char *, 93 struct client *); 94 95int 96server_fcgi(struct httpd *env, struct client *clt) 97{ 98 struct server_fcgi_param param; 99 struct server_config *srv_conf = clt->clt_srv_conf; 100 struct http_descriptor *desc = clt->clt_descreq; 101 struct fcgi_record_header *h; 102 struct fcgi_begin_request_body *begin; 103 char hbuf[MAXHOSTNAMELEN]; 104 size_t scriptlen; 105 int pathlen; 106 int fd = -1, ret; 107 const char *errstr = NULL; 108 char *str, *p, *script = NULL; 109 110 if (srv_conf->socket[0] == ':') { 111 struct sockaddr_storage ss; 112 in_port_t port; 113 114 p = srv_conf->socket + 1; 115 116 port = strtonum(p, 0, 0xffff, &errstr); 117 if (errstr != NULL) { 118 log_warn("%s: strtonum %s, %s", __func__, p, errstr); 119 goto fail; 120 } 121 memset(&ss, 0, sizeof(ss)); 122 ss.ss_family = AF_INET; 123 ((struct sockaddr_in *) 124 &ss)->sin_addr.s_addr = htonl(INADDR_LOOPBACK); 125 port = htons(port); 126 127 if ((fd = server_socket_connect(&ss, port, srv_conf)) == -1) 128 goto fail; 129 } else { 130 struct sockaddr_un sun; 131 size_t len; 132 133 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) 134 goto fail; 135 136 memset(&sun, 0, sizeof(sun)); 137 sun.sun_family = AF_UNIX; 138 len = strlcpy(sun.sun_path, 139 srv_conf->socket, sizeof(sun.sun_path)); 140 if (len >= sizeof(sun.sun_path)) { 141 errstr = "socket path to long"; 142 goto fail; 143 } 144 sun.sun_len = len; 145 146 if (connect(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) 147 goto fail; 148 } 149 150 socket_set_blockmode(fd, BM_NONBLOCK); 151 152 memset(hbuf, 0, sizeof(hbuf)); 153 clt->clt_fcgi_state = FCGI_READ_HEADER; 154 clt->clt_fcgi_toread = sizeof(struct fcgi_record_header); 155 156 if (clt->clt_srvevb != NULL) 157 evbuffer_free(clt->clt_srvevb); 158 159 clt->clt_srvevb = evbuffer_new(); 160 if (clt->clt_srvevb == NULL) { 161 errstr = "failed to allocate evbuffer"; 162 goto fail; 163 } 164 165 clt->clt_fd = fd; 166 if (clt->clt_srvbev != NULL) 167 bufferevent_free(clt->clt_srvbev); 168 169 clt->clt_srvbev = bufferevent_new(fd, server_fcgi_read, 170 NULL, server_file_error, clt); 171 if (clt->clt_srvbev == NULL) { 172 errstr = "failed to allocate fcgi buffer event"; 173 goto fail; 174 } 175 176 memset(¶m, 0, sizeof(param)); 177 178 h = (struct fcgi_record_header *)¶m.buf; 179 h->version = 1; 180 h->type = FCGI_BEGIN_REQUEST; 181 h->id = htons(1); 182 h->content_len = htons(sizeof(struct fcgi_begin_request_body)); 183 h->padding_len = 0; 184 185 begin = (struct fcgi_begin_request_body *)¶m.buf[sizeof(struct 186 fcgi_record_header)]; 187 begin->role = htons(FCGI_RESPONDER); 188 189 bufferevent_write(clt->clt_srvbev, ¶m.buf, 190 sizeof(struct fcgi_record_header) + 191 sizeof(struct fcgi_begin_request_body)); 192 193 h->type = FCGI_PARAMS; 194 h->content_len = param.total_len = 0; 195 196 if ((pathlen = asprintf(&script, "%s%s", srv_conf->root, 197 desc->http_path_alias != NULL ? 198 desc->http_path_alias : desc->http_path)) == -1) { 199 errstr = "failed to get script name"; 200 goto fail; 201 } 202 203 scriptlen = path_info(script); 204 /* 205 * no part of root should show up in PATH_INFO. 206 * therefore scriptlen should be >= strlen(root) 207 */ 208 if (scriptlen < strlen(srv_conf->root)) 209 scriptlen = strlen(srv_conf->root); 210 if ((int)scriptlen < pathlen) { 211 if (fcgi_add_param(¶m, "PATH_INFO", 212 script + scriptlen, clt) == -1) { 213 errstr = "failed to encode param"; 214 goto fail; 215 } 216 script[scriptlen] = '\0'; 217 } 218 219 if (fcgi_add_param(¶m, "SCRIPT_NAME", 220 script + strlen(srv_conf->root), clt) == -1) { 221 errstr = "failed to encode param"; 222 goto fail; 223 } 224 if (fcgi_add_param(¶m, "SCRIPT_FILENAME", script, clt) == -1) { 225 errstr = "failed to encode param"; 226 goto fail; 227 } 228 229 if (desc->http_query) 230 if (fcgi_add_param(¶m, "QUERY_STRING", desc->http_query, 231 clt) == -1) { 232 errstr = "failed to encode param"; 233 goto fail; 234 } 235 236 if (fcgi_add_param(¶m, "DOCUMENT_ROOT", srv_conf->root, 237 clt) == -1) { 238 errstr = "failed to encode param"; 239 goto fail; 240 } 241 if (fcgi_add_param(¶m, "DOCUMENT_URI", desc->http_path, 242 clt) == -1) { 243 errstr = "failed to encode param"; 244 goto fail; 245 } 246 if (fcgi_add_param(¶m, "GATEWAY_INTERFACE", "CGI/1.1", 247 clt) == -1) { 248 errstr = "failed to encode param"; 249 goto fail; 250 } 251 252 /* Add HTTP_* headers */ 253 if (server_headers(clt, desc, server_fcgi_writeheader, ¶m) == -1) { 254 errstr = "failed to encode param"; 255 goto fail; 256 } 257 258 if (srv_conf->flags & SRVFLAG_SSL) 259 if (fcgi_add_param(¶m, "HTTPS", "on", clt) == -1) { 260 errstr = "failed to encode param"; 261 goto fail; 262 } 263 264 (void)print_host(&clt->clt_ss, hbuf, sizeof(hbuf)); 265 if (fcgi_add_param(¶m, "REMOTE_ADDR", hbuf, clt) == -1) { 266 errstr = "failed to encode param"; 267 goto fail; 268 } 269 270 (void)snprintf(hbuf, sizeof(hbuf), "%d", ntohs(clt->clt_port)); 271 if (fcgi_add_param(¶m, "REMOTE_PORT", hbuf, clt) == -1) { 272 errstr = "failed to encode param"; 273 goto fail; 274 } 275 276 if (fcgi_add_param(¶m, "REQUEST_METHOD", 277 server_httpmethod_byid(desc->http_method), clt) == -1) { 278 errstr = "failed to encode param"; 279 goto fail; 280 } 281 282 if (!desc->http_query) { 283 if (fcgi_add_param(¶m, "REQUEST_URI", desc->http_path, 284 clt) == -1) { 285 errstr = "failed to encode param"; 286 goto fail; 287 } 288 } else if (asprintf(&str, "%s?%s", desc->http_path, 289 desc->http_query) != -1) { 290 ret = fcgi_add_param(¶m, "REQUEST_URI", str, clt); 291 free(str); 292 if (ret == -1) { 293 errstr = "failed to encode param"; 294 goto fail; 295 } 296 } 297 298 (void)print_host(&clt->clt_srv_ss, hbuf, sizeof(hbuf)); 299 if (fcgi_add_param(¶m, "SERVER_ADDR", hbuf, clt) == -1) { 300 errstr = "failed to encode param"; 301 goto fail; 302 } 303 304 (void)snprintf(hbuf, sizeof(hbuf), "%d", 305 ntohs(server_socket_getport(&clt->clt_srv_ss))); 306 if (fcgi_add_param(¶m, "SERVER_PORT", hbuf, clt) == -1) { 307 errstr = "failed to encode param"; 308 goto fail; 309 } 310 311 if (fcgi_add_param(¶m, "SERVER_NAME", srv_conf->name, 312 clt) == -1) { 313 errstr = "failed to encode param"; 314 goto fail; 315 } 316 317 if (fcgi_add_param(¶m, "SERVER_PROTOCOL", desc->http_version, 318 clt) == -1) { 319 errstr = "failed to encode param"; 320 goto fail; 321 } 322 323 if (fcgi_add_param(¶m, "SERVER_SOFTWARE", HTTPD_SERVERNAME, 324 clt) == -1) { 325 errstr = "failed to encode param"; 326 goto fail; 327 } 328 329 if (param.total_len != 0) { /* send last params record */ 330 bufferevent_write(clt->clt_srvbev, ¶m.buf, 331 sizeof(struct fcgi_record_header) + 332 ntohs(h->content_len)); 333 } 334 335 /* send "no more params" message */ 336 h->content_len = 0; 337 bufferevent_write(clt->clt_srvbev, ¶m.buf, 338 sizeof(struct fcgi_record_header)); 339 340 bufferevent_settimeout(clt->clt_srvbev, 341 srv_conf->timeout.tv_sec, srv_conf->timeout.tv_sec); 342 bufferevent_enable(clt->clt_srvbev, EV_READ|EV_WRITE); 343 if (clt->clt_toread != 0) { 344 server_read_httpcontent(clt->clt_bev, clt); 345 bufferevent_enable(clt->clt_bev, EV_READ); 346 } else { 347 bufferevent_disable(clt->clt_bev, EV_READ); 348 fcgi_add_stdin(clt, NULL); 349 } 350 351 if (strcmp(desc->http_version, "HTTP/1.1") == 0) { 352 clt->clt_fcgi_chunked = 1; 353 } else { 354 /* HTTP/1.0 does not support chunked encoding */ 355 clt->clt_fcgi_chunked = 0; 356 clt->clt_persist = 0; 357 } 358 clt->clt_fcgi_end = 0; 359 clt->clt_done = 0; 360 361 free(script); 362 return (0); 363 fail: 364 free(script); 365 if (errstr == NULL) 366 errstr = strerror(errno); 367 server_abort_http(clt, 500, errstr); 368 return (-1); 369} 370 371int 372fcgi_add_stdin(struct client *clt, struct evbuffer *evbuf) 373{ 374 struct fcgi_record_header h; 375 376 memset(&h, 0, sizeof(h)); 377 h.version = 1; 378 h.type = FCGI_STDIN; 379 h.id = htons(1); 380 h.padding_len = 0; 381 382 if (evbuf == NULL) { 383 h.content_len = 0; 384 return bufferevent_write(clt->clt_srvbev, &h, 385 sizeof(struct fcgi_record_header)); 386 } else { 387 h.content_len = htons(EVBUFFER_LENGTH(evbuf)); 388 if (bufferevent_write(clt->clt_srvbev, &h, 389 sizeof(struct fcgi_record_header)) == -1) 390 return -1; 391 return bufferevent_write_buffer(clt->clt_srvbev, evbuf); 392 } 393 return (0); 394} 395 396int 397fcgi_add_param(struct server_fcgi_param *p, const char *key, 398 const char *val, struct client *clt) 399{ 400 struct fcgi_record_header *h; 401 int len = 0; 402 int key_len = strlen(key); 403 int val_len = strlen(val); 404 uint8_t *param; 405 406 len += key_len + val_len; 407 len += key_len > 127 ? 4 : 1; 408 len += val_len > 127 ? 4 : 1; 409 410 DPRINTF("%s: %s[%d] => %s[%d], total_len: %d", __func__, key, key_len, 411 val, val_len, p->total_len); 412 413 if (len > FCGI_CONTENT_SIZE) 414 return (-1); 415 416 if (p->total_len + len > FCGI_CONTENT_SIZE) { 417 bufferevent_write(clt->clt_srvbev, p->buf, 418 sizeof(struct fcgi_record_header) + p->total_len); 419 p->total_len = 0; 420 } 421 422 h = (struct fcgi_record_header *)p->buf; 423 param = p->buf + sizeof(*h) + p->total_len; 424 425 if (key_len > 127) { 426 *param++ = ((key_len >> 24) & 0xff) | 0x80; 427 *param++ = ((key_len >> 16) & 0xff); 428 *param++ = ((key_len >> 8) & 0xff); 429 *param++ = (key_len & 0xff); 430 } else 431 *param++ = key_len; 432 433 if (val_len > 127) { 434 *param++ = ((val_len >> 24) & 0xff) | 0x80; 435 *param++ = ((val_len >> 16) & 0xff); 436 *param++ = ((val_len >> 8) & 0xff); 437 *param++ = (val_len & 0xff); 438 } else 439 *param++ = val_len; 440 441 memcpy(param, key, key_len); 442 param += key_len; 443 memcpy(param, val, val_len); 444 445 p->total_len += len; 446 447 h->content_len = htons(p->total_len); 448 return (0); 449} 450 451void 452server_fcgi_read(struct bufferevent *bev, void *arg) 453{ 454 uint8_t buf[FCGI_RECORD_SIZE]; 455 struct client *clt = (struct client *) arg; 456 struct fcgi_record_header *h; 457 size_t len; 458 char *ptr; 459 460 do { 461 len = bufferevent_read(bev, buf, clt->clt_fcgi_toread); 462 /* XXX error handling */ 463 evbuffer_add(clt->clt_srvevb, buf, len); 464 clt->clt_fcgi_toread -= len; 465 DPRINTF("%s: len: %lu toread: %d state: %d type: %d", 466 __func__, len, clt->clt_fcgi_toread, 467 clt->clt_fcgi_state, clt->clt_fcgi_type); 468 469 if (clt->clt_fcgi_toread != 0) 470 return; 471 472 switch (clt->clt_fcgi_state) { 473 case FCGI_READ_HEADER: 474 clt->clt_fcgi_state = FCGI_READ_CONTENT; 475 h = (struct fcgi_record_header *) 476 EVBUFFER_DATA(clt->clt_srvevb); 477 DPRINTF("%s: record header: version %d type %d id %d " 478 "content len %d padding %d", __func__, 479 h->version, h->type, ntohs(h->id), 480 ntohs(h->content_len), h->padding_len); 481 clt->clt_fcgi_type = h->type; 482 clt->clt_fcgi_toread = ntohs(h->content_len); 483 clt->clt_fcgi_padding_len = h->padding_len; 484 evbuffer_drain(clt->clt_srvevb, 485 EVBUFFER_LENGTH(clt->clt_srvevb)); 486 if (clt->clt_fcgi_toread != 0) 487 break; 488 else if (clt->clt_fcgi_type == FCGI_STDOUT && 489 !clt->clt_chunk) { 490 server_abort_http(clt, 500, "empty stdout"); 491 return; 492 } 493 494 /* fallthrough if content_len == 0 */ 495 case FCGI_READ_CONTENT: 496 switch (clt->clt_fcgi_type) { 497 case FCGI_STDERR: 498 if (EVBUFFER_LENGTH(clt->clt_srvevb) > 0 && 499 (ptr = get_string( 500 EVBUFFER_DATA(clt->clt_srvevb), 501 EVBUFFER_LENGTH(clt->clt_srvevb))) 502 != NULL) { 503 server_sendlog(clt->clt_srv_conf, 504 IMSG_LOG_ERROR, "%s", ptr); 505 free(ptr); 506 } 507 break; 508 case FCGI_STDOUT: 509 if (++clt->clt_chunk == 1) { 510 if (server_fcgi_header(clt, 511 server_fcgi_getheaders(clt)) 512 == -1) { 513 server_abort_http(clt, 500, 514 "malformed fcgi headers"); 515 return; 516 } 517 if (!EVBUFFER_LENGTH(clt->clt_srvevb)) 518 break; 519 } 520 /* FALLTHROUGH */ 521 case FCGI_END_REQUEST: 522 if (server_fcgi_writechunk(clt) == -1) { 523 server_abort_http(clt, 500, 524 "encoding error"); 525 return; 526 } 527 break; 528 } 529 evbuffer_drain(clt->clt_srvevb, 530 EVBUFFER_LENGTH(clt->clt_srvevb)); 531 if (!clt->clt_fcgi_padding_len) { 532 clt->clt_fcgi_state = FCGI_READ_HEADER; 533 clt->clt_fcgi_toread = 534 sizeof(struct fcgi_record_header); 535 } else { 536 clt->clt_fcgi_state = FCGI_READ_PADDING; 537 clt->clt_fcgi_toread = 538 clt->clt_fcgi_padding_len; 539 } 540 break; 541 case FCGI_READ_PADDING: 542 evbuffer_drain(clt->clt_srvevb, 543 EVBUFFER_LENGTH(clt->clt_srvevb)); 544 clt->clt_fcgi_state = FCGI_READ_HEADER; 545 clt->clt_fcgi_toread = 546 sizeof(struct fcgi_record_header); 547 break; 548 } 549 } while (len > 0); 550} 551 552int 553server_fcgi_header(struct client *clt, u_int code) 554{ 555 struct http_descriptor *desc = clt->clt_descreq; 556 struct http_descriptor *resp = clt->clt_descresp; 557 const char *error; 558 char tmbuf[32]; 559 struct kv *kv, key; 560 561 if (desc == NULL || (error = server_httperror_byid(code)) == NULL) 562 return (-1); 563 564 if (server_log_http(clt, code, 0) == -1) 565 return (-1); 566 567 /* Add error codes */ 568 if (kv_setkey(&resp->http_pathquery, "%lu", code) == -1 || 569 kv_set(&resp->http_pathquery, "%s", error) == -1) 570 return (-1); 571 572 /* Add headers */ 573 if (kv_add(&resp->http_headers, "Server", HTTPD_SERVERNAME) == NULL) 574 return (-1); 575 576 /* Set chunked encoding */ 577 if (clt->clt_fcgi_chunked) { 578 /* XXX Should we keep and handle Content-Length instead? */ 579 key.kv_key = "Content-Length"; 580 if ((kv = kv_find(&resp->http_headers, &key)) != NULL) 581 kv_delete(&resp->http_headers, kv); 582 583 /* 584 * XXX What if the FastCGI added some kind of Transfer-Encoding? 585 * XXX like gzip, deflate or even "chunked"? 586 */ 587 if (kv_add(&resp->http_headers, 588 "Transfer-Encoding", "chunked") == NULL) 589 return (-1); 590 } 591 592 /* Is it a persistent connection? */ 593 if (clt->clt_persist) { 594 if (kv_add(&resp->http_headers, 595 "Connection", "keep-alive") == NULL) 596 return (-1); 597 } else if (kv_add(&resp->http_headers, "Connection", "close") == NULL) 598 return (-1); 599 600 /* Date header is mandatory and should be added as late as possible */ 601 if (server_http_time(time(NULL), tmbuf, sizeof(tmbuf)) <= 0 || 602 kv_add(&resp->http_headers, "Date", tmbuf) == NULL) 603 return (-1); 604 605 /* Write initial header (fcgi might append more) */ 606 if (server_writeresponse_http(clt) == -1 || 607 server_bufferevent_print(clt, "\r\n") == -1 || 608 server_headers(clt, resp, server_writeheader_http, NULL) == -1 || 609 server_bufferevent_print(clt, "\r\n") == -1) 610 return (-1); 611 612 return (0); 613} 614 615int 616server_fcgi_writeheader(struct client *clt, struct kv *hdr, void *arg) 617{ 618 struct server_fcgi_param *param = arg; 619 char *val, *name, *p; 620 const char *key; 621 int ret; 622 623 if (hdr->kv_flags & KV_FLAG_INVALID) 624 return (0); 625 626 /* The key might have been updated in the parent */ 627 if (hdr->kv_parent != NULL && hdr->kv_parent->kv_key != NULL) 628 key = hdr->kv_parent->kv_key; 629 else 630 key = hdr->kv_key; 631 632 val = hdr->kv_value; 633 634 if (strcasecmp(key, "Content-Length") == 0 || 635 strcasecmp(key, "Content-Type") == 0) { 636 if ((name = strdup(key)) == NULL) 637 return (-1); 638 } else { 639 if (asprintf(&name, "HTTP_%s", key) == -1) 640 return (-1); 641 } 642 643 for (p = name; *p != '\0'; p++) { 644 if (isalpha((unsigned char)*p)) 645 *p = toupper((unsigned char)*p); 646 else 647 *p = '_'; 648 } 649 650 ret = fcgi_add_param(param, name, val, clt); 651 free(name); 652 653 return (ret); 654} 655 656int 657server_fcgi_writechunk(struct client *clt) 658{ 659 struct evbuffer *evb = clt->clt_srvevb; 660 size_t len; 661 662 if (clt->clt_fcgi_type == FCGI_END_REQUEST) { 663 len = 0; 664 } else 665 len = EVBUFFER_LENGTH(evb); 666 667 /* If len is 0, make sure to write the end marker only once */ 668 if (len == 0 && clt->clt_fcgi_end++) 669 return (0); 670 671 if (clt->clt_fcgi_chunked) { 672 if (server_bufferevent_printf(clt, "%zx\r\n", len) == -1 || 673 server_bufferevent_write_chunk(clt, evb, len) == -1 || 674 server_bufferevent_print(clt, "\r\n") == -1) 675 return (-1); 676 } else 677 return (server_bufferevent_write_buffer(clt, evb)); 678 679 return (0); 680} 681 682int 683server_fcgi_getheaders(struct client *clt) 684{ 685 struct http_descriptor *resp = clt->clt_descresp; 686 struct evbuffer *evb = clt->clt_srvevb; 687 int code = 200; 688 char *line, *key, *value; 689 const char *errstr; 690 691 while ((line = evbuffer_getline(evb)) != NULL && *line != '\0') { 692 key = line; 693 694 if ((value = strchr(key, ':')) == NULL) 695 break; 696 if (*value == ':') { 697 *value++ = '\0'; 698 value += strspn(value, " \t"); 699 } else { 700 *value++ = '\0'; 701 } 702 703 DPRINTF("%s: %s: %s", __func__, key, value); 704 705 if (strcasecmp("Status", key) == 0) { 706 value[strcspn(value, " \t")] = '\0'; 707 code = (int)strtonum(value, 100, 600, &errstr); 708 if (errstr != NULL || server_httperror_byid( 709 code) == NULL) 710 code = 200; 711 } else { 712 (void)kv_add(&resp->http_headers, key, value); 713 } 714 free(line); 715 } 716 717 return (code); 718} 719