server_fcgi.c revision 1.26
1/* $OpenBSD: server_fcgi.c,v 1.26 2014/08/06 20:56:23 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#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 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 char hbuf[MAXHOSTNAMELEN]; 98 struct server_config *srv_conf = clt->clt_srv_conf; 99 struct http_descriptor *desc = clt->clt_desc; 100 struct sockaddr_un sun; 101 struct fcgi_record_header *h; 102 struct fcgi_begin_request_body *begin; 103 size_t len; 104 ssize_t scriptlen; 105 int fd = -1, ret; 106 const char *errstr = NULL; 107 char *str, *p, *script = NULL; 108 in_port_t port; 109 struct sockaddr_storage ss; 110 111 if (srv_conf->socket[0] == ':') { 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 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) 129 goto fail; 130 131 memset(&sun, 0, sizeof(sun)); 132 sun.sun_family = AF_UNIX; 133 len = strlcpy(sun.sun_path, 134 srv_conf->socket, sizeof(sun.sun_path)); 135 if (len >= sizeof(sun.sun_path)) { 136 errstr = "socket path to long"; 137 goto fail; 138 } 139 sun.sun_len = len; 140 141 if (connect(fd, (struct sockaddr *)&sun, sizeof(sun)) == -1) 142 goto fail; 143 } 144 145 socket_set_blockmode(fd, BM_NONBLOCK); 146 147 memset(hbuf, 0, sizeof(hbuf)); 148 clt->clt_fcgi_state = FCGI_READ_HEADER; 149 clt->clt_fcgi_toread = sizeof(struct fcgi_record_header); 150 151 if (clt->clt_srvevb != NULL) 152 evbuffer_free(clt->clt_srvevb); 153 154 clt->clt_srvevb = evbuffer_new(); 155 if (clt->clt_srvevb == NULL) { 156 errstr = "failed to allocate evbuffer"; 157 goto fail; 158 } 159 160 clt->clt_fd = fd; 161 if (clt->clt_srvbev != NULL) 162 bufferevent_free(clt->clt_srvbev); 163 164 clt->clt_srvbev = bufferevent_new(fd, server_fcgi_read, 165 NULL, server_file_error, clt); 166 if (clt->clt_srvbev == NULL) { 167 errstr = "failed to allocate fcgi buffer event"; 168 goto fail; 169 } 170 171 memset(¶m, 0, sizeof(param)); 172 173 h = (struct fcgi_record_header *)¶m.buf; 174 h->version = 1; 175 h->type = FCGI_BEGIN_REQUEST; 176 h->id = htons(1); 177 h->content_len = htons(sizeof(struct fcgi_begin_request_body)); 178 h->padding_len = 0; 179 180 begin = (struct fcgi_begin_request_body *)¶m.buf[sizeof(struct 181 fcgi_record_header)]; 182 begin->role = htons(FCGI_RESPONDER); 183 184 bufferevent_write(clt->clt_srvbev, ¶m.buf, 185 sizeof(struct fcgi_record_header) + 186 sizeof(struct fcgi_begin_request_body)); 187 188 h->type = FCGI_PARAMS; 189 h->content_len = param.total_len = 0; 190 191 if (asprintf(&script, "%s%s", srv_conf->root, 192 desc->http_path) == -1 || 193 (scriptlen = path_info(script)) == -1) { 194 errstr = "failed to get script name"; 195 goto fail; 196 } 197 198 if (scriptlen) { 199 if (fcgi_add_param(¶m, "PATH_INFO", 200 script + scriptlen, clt) == -1) { 201 errstr = "failed to encode param"; 202 goto fail; 203 } 204 script[scriptlen] = '\0'; 205 } 206 207 if (fcgi_add_param(¶m, "SCRIPT_NAME", 208 script + strlen(srv_conf->root), clt) == -1) { 209 errstr = "failed to encode param"; 210 goto fail; 211 } 212 if (fcgi_add_param(¶m, "SCRIPT_FILENAME", script, clt) == -1) { 213 errstr = "failed to encode param"; 214 goto fail; 215 } 216 217 if (desc->http_query) 218 if (fcgi_add_param(¶m, "QUERY_STRING", desc->http_query, 219 clt) == -1) { 220 errstr = "failed to encode param"; 221 goto fail; 222 } 223 224 if (fcgi_add_param(¶m, "DOCUMENT_ROOT", srv_conf->root, 225 clt) == -1) { 226 errstr = "failed to encode param"; 227 goto fail; 228 } 229 if (fcgi_add_param(¶m, "DOCUMENT_URI", desc->http_path, 230 clt) == -1) { 231 errstr = "failed to encode param"; 232 goto fail; 233 } 234 if (fcgi_add_param(¶m, "GATEWAY_INTERFACE", "CGI/1.1", 235 clt) == -1) { 236 errstr = "failed to encode param"; 237 goto fail; 238 } 239 240 /* Add HTTP_* headers */ 241 if (server_headers(clt, server_fcgi_writeheader, ¶m) == -1) { 242 errstr = "failed to encode param"; 243 goto fail; 244 } 245 246 if (srv_conf->flags & SRVFLAG_SSL) 247 if (fcgi_add_param(¶m, "HTTPS", "on", clt) == -1) { 248 errstr = "failed to encode param"; 249 goto fail; 250 } 251 252 (void)print_host(&clt->clt_ss, hbuf, sizeof(hbuf)); 253 if (fcgi_add_param(¶m, "REMOTE_ADDR", hbuf, clt) == -1) { 254 errstr = "failed to encode param"; 255 goto fail; 256 } 257 258 (void)snprintf(hbuf, sizeof(hbuf), "%d", ntohs(clt->clt_port)); 259 if (fcgi_add_param(¶m, "REMOTE_PORT", hbuf, clt) == -1) { 260 errstr = "failed to encode param"; 261 goto fail; 262 } 263 264 if (fcgi_add_param(¶m, "REQUEST_METHOD", 265 server_httpmethod_byid(desc->http_method), clt) == -1) { 266 errstr = "failed to encode param"; 267 goto fail; 268 } 269 270 if (!desc->http_query) { 271 if (fcgi_add_param(¶m, "REQUEST_URI", desc->http_path, 272 clt) == -1) { 273 errstr = "failed to encode param"; 274 goto fail; 275 } 276 } else if (asprintf(&str, "%s?%s", desc->http_path, 277 desc->http_query) != -1) { 278 ret = fcgi_add_param(¶m, "REQUEST_URI", str, clt); 279 free(str); 280 if (ret == -1) { 281 errstr = "failed to encode param"; 282 goto fail; 283 } 284 } 285 286 (void)print_host(&clt->clt_srv_ss, hbuf, sizeof(hbuf)); 287 if (fcgi_add_param(¶m, "SERVER_ADDR", hbuf, clt) == -1) { 288 errstr = "failed to encode param"; 289 goto fail; 290 } 291 292 (void)snprintf(hbuf, sizeof(hbuf), "%d", 293 ntohs(server_socket_getport(&clt->clt_srv_ss))); 294 if (fcgi_add_param(¶m, "SERVER_PORT", hbuf, clt) == -1) { 295 errstr = "failed to encode param"; 296 goto fail; 297 } 298 299 if (fcgi_add_param(¶m, "SERVER_NAME", srv_conf->name, 300 clt) == -1) { 301 errstr = "failed to encode param"; 302 goto fail; 303 } 304 305 if (fcgi_add_param(¶m, "SERVER_PROTOCOL", desc->http_version, 306 clt) == -1) { 307 errstr = "failed to encode param"; 308 goto fail; 309 } 310 311 if (fcgi_add_param(¶m, "SERVER_SOFTWARE", HTTPD_SERVERNAME, 312 clt) == -1) { 313 errstr = "failed to encode param"; 314 goto fail; 315 } 316 317 if (param.total_len != 0) { /* send last params record */ 318 bufferevent_write(clt->clt_srvbev, ¶m.buf, 319 sizeof(struct fcgi_record_header) + 320 ntohs(h->content_len)); 321 } 322 323 /* send "no more params" message */ 324 h->content_len = 0; 325 bufferevent_write(clt->clt_srvbev, ¶m.buf, 326 sizeof(struct fcgi_record_header)); 327 328 bufferevent_settimeout(clt->clt_srvbev, 329 srv_conf->timeout.tv_sec, srv_conf->timeout.tv_sec); 330 bufferevent_enable(clt->clt_srvbev, EV_READ|EV_WRITE); 331 if (clt->clt_toread != 0) { 332 server_read_httpcontent(clt->clt_bev, clt); 333 bufferevent_enable(clt->clt_bev, EV_READ); 334 } else { 335 bufferevent_disable(clt->clt_bev, EV_READ); 336 fcgi_add_stdin(clt, NULL); 337 } 338 339 /* 340 * persist is not supported yet because we don't get the 341 * Content-Length from slowcgi and don't support chunked encoding. 342 */ 343 clt->clt_persist = 0; 344 clt->clt_done = 0; 345 346 free(script); 347 return (0); 348 fail: 349 free(script); 350 if (errstr == NULL) 351 errstr = strerror(errno); 352 server_abort_http(clt, 500, errstr); 353 return (-1); 354} 355 356int 357fcgi_add_stdin(struct client *clt, struct evbuffer *evbuf) 358{ 359 struct fcgi_record_header h; 360 361 memset(&h, 0, sizeof(h)); 362 h.version = 1; 363 h.type = FCGI_STDIN; 364 h.id = htons(1); 365 h.padding_len = 0; 366 367 if (evbuf == NULL) { 368 h.content_len = 0; 369 return bufferevent_write(clt->clt_srvbev, &h, 370 sizeof(struct fcgi_record_header)); 371 } else { 372 h.content_len = htons(EVBUFFER_LENGTH(evbuf)); 373 if (bufferevent_write(clt->clt_srvbev, &h, 374 sizeof(struct fcgi_record_header)) == -1) 375 return -1; 376 return bufferevent_write_buffer(clt->clt_srvbev, evbuf); 377 } 378 return (0); 379} 380 381int 382fcgi_add_param(struct server_fcgi_param *p, const char *key, 383 const char *val, struct client *clt) 384{ 385 struct fcgi_record_header *h; 386 int len = 0; 387 int key_len = strlen(key); 388 int val_len = strlen(val); 389 uint8_t *param; 390 391 len += key_len + val_len; 392 len += key_len > 127 ? 4 : 1; 393 len += val_len > 127 ? 4 : 1; 394 395 DPRINTF("%s: %s[%d] => %s[%d], total_len: %d", __func__, key, key_len, 396 val, val_len, p->total_len); 397 398 if (len > FCGI_CONTENT_SIZE) 399 return (-1); 400 401 if (p->total_len + len > FCGI_CONTENT_SIZE) { 402 bufferevent_write(clt->clt_srvbev, p->buf, 403 sizeof(struct fcgi_record_header) + p->total_len); 404 p->total_len = 0; 405 } 406 407 h = (struct fcgi_record_header *)p->buf; 408 param = p->buf + sizeof(*h) + p->total_len; 409 410 if (key_len > 127) { 411 *param++ = ((key_len >> 24) & 0xff) | 0x80; 412 *param++ = ((key_len >> 16) & 0xff); 413 *param++ = ((key_len >> 8) & 0xff); 414 *param++ = (key_len & 0xff); 415 } else 416 *param++ = key_len; 417 418 if (val_len > 127) { 419 *param++ = ((val_len >> 24) & 0xff) | 0x80; 420 *param++ = ((val_len >> 16) & 0xff); 421 *param++ = ((val_len >> 8) & 0xff); 422 *param++ = (val_len & 0xff); 423 } else 424 *param++ = val_len; 425 426 memcpy(param, key, key_len); 427 param += key_len; 428 memcpy(param, val, val_len); 429 430 p->total_len += len; 431 432 h->content_len = htons(p->total_len); 433 return (0); 434} 435 436void 437server_fcgi_read(struct bufferevent *bev, void *arg) 438{ 439 uint8_t buf[FCGI_RECORD_SIZE]; 440 struct client *clt = (struct client *) arg; 441 struct fcgi_record_header *h; 442 size_t len; 443 444 do { 445 len = bufferevent_read(bev, &buf, clt->clt_fcgi_toread); 446 /* XXX error handling */ 447 evbuffer_add(clt->clt_srvevb, &buf, len); 448 clt->clt_fcgi_toread -= len; 449 DPRINTF("%s: len: %lu toread: %d state: %d", __func__, len, 450 clt->clt_fcgi_toread, clt->clt_fcgi_state); 451 452 if (clt->clt_fcgi_toread != 0) 453 return; 454 455 switch (clt->clt_fcgi_state) { 456 case FCGI_READ_HEADER: 457 clt->clt_fcgi_state = FCGI_READ_CONTENT; 458 h = (struct fcgi_record_header *) 459 EVBUFFER_DATA(clt->clt_srvevb); 460 DPRINTF("%s: record header: version %d type %d id %d " 461 "content len %d padding %d", __func__, 462 h->version, h->type, ntohs(h->id), 463 ntohs(h->content_len), h->padding_len); 464 clt->clt_fcgi_type = h->type; 465 clt->clt_fcgi_toread = ntohs(h->content_len); 466 clt->clt_fcgi_padding_len = h->padding_len; 467 evbuffer_drain(clt->clt_srvevb, 468 EVBUFFER_LENGTH(clt->clt_srvevb)); 469 if (clt->clt_fcgi_toread != 0) 470 break; 471 else if (clt->clt_fcgi_type == FCGI_STDOUT && 472 !clt->clt_chunk) { 473 server_abort_http(clt, 500, "empty stdout"); 474 return; 475 } 476 477 /* fallthrough if content_len == 0 */ 478 case FCGI_READ_CONTENT: 479 if (clt->clt_fcgi_type == FCGI_STDOUT && 480 EVBUFFER_LENGTH(clt->clt_srvevb) > 0) { 481 if (++clt->clt_chunk == 1) 482 server_fcgi_header(clt, 200); 483 server_bufferevent_write_buffer(clt, 484 clt->clt_srvevb); 485 } 486 evbuffer_drain(clt->clt_srvevb, 487 EVBUFFER_LENGTH(clt->clt_srvevb)); 488 if (!clt->clt_fcgi_padding_len) { 489 clt->clt_fcgi_state = FCGI_READ_HEADER; 490 clt->clt_fcgi_toread = 491 sizeof(struct fcgi_record_header); 492 } else { 493 clt->clt_fcgi_state = FCGI_READ_PADDING; 494 clt->clt_fcgi_toread = 495 clt->clt_fcgi_padding_len; 496 } 497 break; 498 case FCGI_READ_PADDING: 499 evbuffer_drain(clt->clt_srvevb, 500 EVBUFFER_LENGTH(clt->clt_srvevb)); 501 clt->clt_fcgi_state = FCGI_READ_HEADER; 502 clt->clt_fcgi_toread = 503 sizeof(struct fcgi_record_header); 504 break; 505 } 506 } while (len > 0); 507} 508 509int 510server_fcgi_header(struct client *clt, u_int code) 511{ 512 struct http_descriptor *desc = clt->clt_desc; 513 const char *error; 514 char tmbuf[32]; 515 516 if (desc == NULL || (error = server_httperror_byid(code)) == NULL) 517 return (-1); 518 519 if (server_log_http(clt, code, 0) == -1) 520 return (-1); 521 522 kv_purge(&desc->http_headers); 523 524 /* Add error codes */ 525 if (kv_setkey(&desc->http_pathquery, "%lu", code) == -1 || 526 kv_set(&desc->http_pathquery, "%s", error) == -1) 527 return (-1); 528 529 /* Add headers */ 530 if (kv_add(&desc->http_headers, "Server", HTTPD_SERVERNAME) == NULL) 531 return (-1); 532 533 /* Is it a persistent connection? */ 534 if (clt->clt_persist) { 535 if (kv_add(&desc->http_headers, 536 "Connection", "keep-alive") == NULL) 537 return (-1); 538 } else if (kv_add(&desc->http_headers, "Connection", "close") == NULL) 539 return (-1); 540 541 /* Date header is mandatory and should be added last */ 542 server_http_date(tmbuf, sizeof(tmbuf)); 543 if (kv_add(&desc->http_headers, "Date", tmbuf) == NULL) 544 return (-1); 545 546 /* Write initial header (fcgi might append more) */ 547 if (server_writeresponse_http(clt) == -1 || 548 server_bufferevent_print(clt, "\r\n") == -1 || 549 server_headers(clt, server_writeheader_http, NULL) == -1) 550 return (-1); 551 552 return (0); 553} 554 555int 556server_fcgi_writeheader(struct client *clt, struct kv *hdr, void *arg) 557{ 558 struct server_fcgi_param *param = arg; 559 char *val, *name, *p; 560 const char *key; 561 int ret; 562 563 if (hdr->kv_flags & KV_FLAG_INVALID) 564 return (0); 565 566 /* The key might have been updated in the parent */ 567 if (hdr->kv_parent != NULL && hdr->kv_parent->kv_key != NULL) 568 key = hdr->kv_parent->kv_key; 569 else 570 key = hdr->kv_key; 571 572 val = hdr->kv_value; 573 574 if (strcasecmp(key, "Content-Length") == 0 || 575 strcasecmp(key, "Content-Type") == 0) { 576 if ((name = strdup(key)) == NULL) 577 return (-1); 578 } else { 579 if (asprintf(&name, "HTTP_%s", key) == -1) 580 return (-1); 581 } 582 583 for (p = name; *p != '\0'; p++) { 584 if (isalpha((unsigned char)*p)) 585 *p = toupper((unsigned char)*p); 586 else 587 *p = '_'; 588 } 589 590 ret = fcgi_add_param(param, name, val, clt); 591 free(name); 592 593 return (ret); 594} 595