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