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