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