src/mod_proxy.c

   1 #include "first.h"
   2
   3 #include "buffer.h"
   4 #include "server.h"
   5 #include "keyvalue.h"
   6 #include "log.h"
   7
   8 #include "http_chunk.h"
   9 #include "fdevent.h"
  10 #include "connections.h"
  11 #include "response.h"
  12 #include "joblist.h"
  13
  14 #include "plugin.h"
  15
  16 #include "inet_ntop_cache.h"
  17 #include "crc32.h"
  18
  19 #include <sys/types.h>
  20
  21 #include <unistd.h>
  22 #include <errno.h>
  23 #include <fcntl.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26 #include <ctype.h>
  27 #include <assert.h>
  28
  29 #include <stdio.h>
  30
  31 #include "sys-socket.h"
  32
  33 #define data_proxy data_fastcgi
  34 #define data_proxy_init data_fastcgi_init
  35
  36 #define PROXY_RETRY_TIMEOUT 60
  37
  38 /**
  39  *
  40  * the proxy module is based on the fastcgi module
  41  *
  42  * 28.06.2004 Jan Kneschke     The first release
  43  * 01.07.2004 Evgeny Rodichev  Several bugfixes and cleanups
  44  *            - co-ordinate up- and downstream flows correctly (proxy_demux_response
  45  *              and proxy_handle_fdevent)
  46  *            - correctly transfer upstream http_response_status;
  47  *            - some unused structures removed.
  48  *
  49  * TODO:      - delay upstream read if write_queue is too large
  50  *              (to prevent memory eating, like in apache). Shoud be
  51  *              configurable).
  52  *            - persistent connection with upstream servers
  53  *            - HTTP/1.1
  54  */
  55 typedef enum {
  56         PROXY_BALANCE_UNSET,
  57         PROXY_BALANCE_FAIR,
  58         PROXY_BALANCE_HASH,
  59         PROXY_BALANCE_RR
  60 } proxy_balance_t;
  61
  62 typedef struct {
  63         array *extensions;
  64         unsigned short debug;
  65
  66         proxy_balance_t balance;
  67 } plugin_config;
  68
  69 typedef struct {
  70         PLUGIN_DATA;
  71
  72         buffer *parse_response;
  73         buffer *balance_buf;
  74
  75         plugin_config **config_storage;
  76
  77         plugin_config conf;
  78 } plugin_data;
  79
  80 typedef enum {
  81         PROXY_STATE_INIT,
  82         PROXY_STATE_CONNECT,
  83         PROXY_STATE_PREPARE_WRITE,
  84         PROXY_STATE_WRITE,
  85         PROXY_STATE_READ
  86 } proxy_connection_state_t;
  87
  88 enum { PROXY_STDOUT, PROXY_END_REQUEST };
  89
  90 typedef struct {
  91         proxy_connection_state_t state;
  92         time_t state_timestamp;
  93
  94         data_proxy *host;
  95
  96         buffer *response;
  97         buffer *response_header;
  98
  99         chunkqueue *wb;
 100         off_t wb_reqlen;
 101
 102         int fd; /* fd to the proxy process */
 103         int fde_ndx; /* index into the fd-event buffer */
 104
 105         size_t path_info_offset; /* start of path_info in uri.path */
 106
 107         connection *remote_conn;  /* dump pointer */
 108         plugin_data *plugin_data; /* dump pointer */
 109 } handler_ctx;
 110
 111
 112 /* ok, we need a prototype */
 113 static handler_t proxy_handle_fdevent(server *srv, void *ctx, int revents);
 114
 115 static handler_ctx * handler_ctx_init(void) {
 116         handler_ctx * hctx;
 117
 118
 119         hctx = calloc(1, sizeof(*hctx));
 120
 121         hctx->state = PROXY_STATE_INIT;
 122         hctx->host = NULL;
 123
 124         hctx->response = buffer_init();
 125         hctx->response_header = buffer_init();
 126
 127         hctx->wb = chunkqueue_init();
 128         hctx->wb_reqlen = 0;
 129
 130         hctx->fd = -1;
 131         hctx->fde_ndx = -1;
 132
 133         return hctx;
 134 }
 135
 136 static void handler_ctx_free(handler_ctx *hctx) {
 137         buffer_free(hctx->response);
 138         buffer_free(hctx->response_header);
 139         chunkqueue_free(hctx->wb);
 140
 141         free(hctx);
 142 }
 143
 144 INIT_FUNC(mod_proxy_init) {
 145         plugin_data *p;
 146
 147         p = calloc(1, sizeof(*p));
 148
 149         p->parse_response = buffer_init();
 150         p->balance_buf = buffer_init();
 151
 152         return p;
 153 }
 154
 155
 156 FREE_FUNC(mod_proxy_free) {
 157         plugin_data *p = p_d;
 158
 159         UNUSED(srv);
 160
 161         buffer_free(p->parse_response);
 162         buffer_free(p->balance_buf);
 163
 164         if (p->config_storage) {
 165                 size_t i;
 166                 for (i = 0; i < srv->config_context->used; i++) {
 167                         plugin_config *s = p->config_storage[i];
 168
 169                         if (NULL == s) continue;
 170
 171                         array_free(s->extensions);
 172
 173                         free(s);
 174                 }
 175                 free(p->config_storage);
 176         }
 177
 178         free(p);
 179
 180         return HANDLER_GO_ON;
 181 }
 182
 183 SETDEFAULTS_FUNC(mod_proxy_set_defaults) {
 184         plugin_data *p = p_d;
 185         data_unset *du;
 186         size_t i = 0;
 187
 188         config_values_t cv[] = {
 189                 { "proxy.server",              NULL, T_CONFIG_LOCAL, T_CONFIG_SCOPE_CONNECTION },       /* 0 */
 190                 { "proxy.debug",               NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },       /* 1 */
 191                 { "proxy.balance",             NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },      /* 2 */
 192                 { NULL,                        NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
 193         };
 194
 195         p->config_storage = calloc(1, srv->config_context->used * sizeof(plugin_config *));
 196
 197         for (i = 0; i < srv->config_context->used; i++) {
 198                 data_config const* config = (data_config const*)srv->config_context->data[i];
 199                 plugin_config *s;
 200
 201                 s = malloc(sizeof(plugin_config));
 202                 s->extensions    = array_init();
 203                 s->debug         = 0;
 204
 205                 cv[0].destination = s->extensions;
 206                 cv[1].destination = &(s->debug);
 207                 cv[2].destination = p->balance_buf;
 208
 209                 buffer_reset(p->balance_buf);
 210
 211                 p->config_storage[i] = s;
 212
 213                 if (0 != config_insert_values_global(srv, config->value, cv, i == 0 ? T_CONFIG_SCOPE_SERVER : T_CONFIG_SCOPE_CONNECTION)) {
 214                         return HANDLER_ERROR;
 215                 }
 216
 217                 if (buffer_string_is_empty(p->balance_buf)) {
 218                         s->balance = PROXY_BALANCE_FAIR;
 219                 } else if (buffer_is_equal_string(p->balance_buf, CONST_STR_LEN("fair"))) {
 220                         s->balance = PROXY_BALANCE_FAIR;
 221                 } else if (buffer_is_equal_string(p->balance_buf, CONST_STR_LEN("round-robin"))) {
 222                         s->balance = PROXY_BALANCE_RR;
 223                 } else if (buffer_is_equal_string(p->balance_buf, CONST_STR_LEN("hash"))) {
 224                         s->balance = PROXY_BALANCE_HASH;
 225                 } else {
 226                         log_error_write(srv, __FILE__, __LINE__, "sb",
 227                                         "proxy.balance has to be one of: fair, round-robin, hash, but not:", p->balance_buf);
 228                         return HANDLER_ERROR;
 229                 }
 230
 231                 if (NULL != (du = array_get_element(config->value, "proxy.server"))) {
 232                         size_t j;
 233                         data_array *da = (data_array *)du;
 234
 235                         if (du->type != TYPE_ARRAY) {
 236                                 log_error_write(srv, __FILE__, __LINE__, "sss",
 237                                                 "unexpected type for key: ", "proxy.server", "expected ( \"ext\" => ( \"backend-label\" => ( \"key\" => \"value\" )))");
 238
 239                                 return HANDLER_ERROR;
 240                         }
 241
 242                         /*
 243                          * proxy.server = ( "<ext>" => ...,
 244                          *                  "<ext>" => ... )
 245                          */
 246
 247                         for (j = 0; j < da->value->used; j++) {
 248                                 data_array *da_ext = (data_array *)da->value->data[j];
 249                                 size_t n;
 250
 251                                 if (da_ext->type != TYPE_ARRAY) {
 252                                         log_error_write(srv, __FILE__, __LINE__, "sssbs",
 253                                                         "unexpected type for key: ", "proxy.server",
 254                                                         "[", da->value->data[j]->key, "](string); expected ( \"ext\" => ( \"backend-label\" => ( \"key\" => \"value\" )))");
 255
 256                                         return HANDLER_ERROR;
 257                                 }
 258
 259                                 /*
 260                                  * proxy.server = ( "<ext>" =>
 261                                  *                     ( "<host>" => ( ... ),
 262                                  *                       "<host>" => ( ... )
 263                                  *                     ),
 264                                  *                    "<ext>" => ... )
 265                                  */
 266
 267                                 for (n = 0; n < da_ext->value->used; n++) {
 268                                         data_array *da_host = (data_array *)da_ext->value->data[n];
 269
 270                                         data_proxy *df;
 271                                         data_array *dfa;
 272
 273                                         config_values_t pcv[] = {
 274                                                 { "host",              NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },      /* 0 */
 275                                                 { "port",              NULL, T_CONFIG_SHORT, T_CONFIG_SCOPE_CONNECTION },       /* 1 */
 276                                                 { NULL,                NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
 277                                         };
 278
 279                                         if (da_host->type != TYPE_ARRAY) {
 280                                                 log_error_write(srv, __FILE__, __LINE__, "ssSBS",
 281                                                                 "unexpected type for key:",
 282                                                                 "proxy.server",
 283                                                                 "[", da_ext->value->data[n]->key, "](string); expected ( \"ext\" => ( \"backend-label\" => ( \"key\" => \"value\" )))");
 284
 285                                                 return HANDLER_ERROR;
 286                                         }
 287
 288                                         df = data_proxy_init();
 289
 290                                         df->port = 80;
 291
 292                                         buffer_copy_buffer(df->key, da_host->key);
 293
 294                                         pcv[0].destination = df->host;
 295                                         pcv[1].destination = &(df->port);
 296
 297                                         if (0 != config_insert_values_internal(srv, da_host->value, pcv, T_CONFIG_SCOPE_CONNECTION)) {
 298                                                 df->free((data_unset*) df);
 299                                                 return HANDLER_ERROR;
 300                                         }
 301
 302                                         if (buffer_string_is_empty(df->host)) {
 303                                                 log_error_write(srv, __FILE__, __LINE__, "sbbbs",
 304                                                                 "missing key (string):",
 305                                                                 da->key,
 306                                                                 da_ext->key,
 307                                                                 da_host->key,
 308                                                                 "host");
 309
 310                                                 df->free((data_unset*) df);
 311                                                 return HANDLER_ERROR;
 312                                         }
 313
 314                                         /* if extension already exists, take it */
 315
 316                                         if (NULL == (dfa = (data_array *)array_get_element(s->extensions, da_ext->key->ptr))) {
 317                                                 dfa = data_array_init();
 318
 319                                                 buffer_copy_buffer(dfa->key, da_ext->key);
 320
 321                                                 array_insert_unique(dfa->value, (data_unset *)df);
 322                                                 array_insert_unique(s->extensions, (data_unset *)dfa);
 323                                         } else {
 324                                                 array_insert_unique(dfa->value, (data_unset *)df);
 325                                         }
 326                                 }
 327                         }
 328                 }
 329         }
 330
 331         return HANDLER_GO_ON;
 332 }
 333
 334 static void proxy_connection_close(server *srv, handler_ctx *hctx) {
 335         plugin_data *p;
 336         connection *con;
 337
 338         p    = hctx->plugin_data;
 339         con  = hctx->remote_conn;
 340
 341         if (hctx->fd != -1) {
 342                 fdevent_event_del(srv->ev, &(hctx->fde_ndx), hctx->fd);
 343                 fdevent_unregister(srv->ev, hctx->fd);
 344
 345                 close(hctx->fd);
 346                 srv->cur_fds--;
 347         }
 348
 349         if (hctx->host) {
 350                 hctx->host->usage--;
 351         }
 352
 353         handler_ctx_free(hctx);
 354         con->plugin_ctx[p->id] = NULL;
 355
 356         /* finish response (if not already con->file_started, con->file_finished) */
 357         if (con->mode == p->id) {
 358                 http_response_backend_done(srv, con);
 359         }
 360 }
 361
 362 static int proxy_establish_connection(server *srv, handler_ctx *hctx) {
 363         struct sockaddr *proxy_addr;
 364         struct sockaddr_in proxy_addr_in;
 365 #if defined(HAVE_SYS_UN_H)
 366         struct sockaddr_un proxy_addr_un;
 367 #endif
 368 #if defined(HAVE_IPV6) && defined(HAVE_INET_PTON)
 369         struct sockaddr_in6 proxy_addr_in6;
 370 #endif
 371         socklen_t servlen;
 372
 373         plugin_data *p    = hctx->plugin_data;
 374         data_proxy *host= hctx->host;
 375         int proxy_fd       = hctx->fd;
 376
 377
 378 #if defined(HAVE_SYS_UN_H)
 379         if (strstr(host->host->ptr, "/")) {
 380                 if (buffer_string_length(host->host) + 1 > sizeof(proxy_addr_un.sun_path)) {
 381                         log_error_write(srv, __FILE__, __LINE__, "sB",
 382                                 "ERROR: Unix Domain socket filename too long:",
 383                                 host->host);
 384                         return -1;
 385                 }
 386
 387                 memset(&proxy_addr_un, 0, sizeof(proxy_addr_un));
 388                 proxy_addr_un.sun_family = AF_UNIX;
 389                 strcpy(proxy_addr_un.sun_path, host->host->ptr);
 390                 servlen = sizeof(proxy_addr_un);
 391                 proxy_addr = (struct sockaddr *) &proxy_addr_un;
 392         } else
 393 #endif
 394 #if defined(HAVE_IPV6) && defined(HAVE_INET_PTON)
 395         if (strstr(host->host->ptr, ":")) {
 396                 memset(&proxy_addr_in6, 0, sizeof(proxy_addr_in6));
 397                 proxy_addr_in6.sin6_family = AF_INET6;
 398                 inet_pton(AF_INET6, host->host->ptr, (char *) &proxy_addr_in6.sin6_addr);
 399                 proxy_addr_in6.sin6_port = htons(host->port);
 400                 servlen = sizeof(proxy_addr_in6);
 401                 proxy_addr = (struct sockaddr *) &proxy_addr_in6;
 402         } else
 403 #endif
 404         {
 405                 memset(&proxy_addr_in, 0, sizeof(proxy_addr_in));
 406                 proxy_addr_in.sin_family = AF_INET;
 407                 proxy_addr_in.sin_addr.s_addr = inet_addr(host->host->ptr);
 408                 proxy_addr_in.sin_port = htons(host->port);
 409                 servlen = sizeof(proxy_addr_in);
 410                 proxy_addr = (struct sockaddr *) &proxy_addr_in;
 411         }
 412
 413
 414         if (-1 == connect(proxy_fd, proxy_addr, servlen)) {
 415                 if (errno == EINPROGRESS || errno == EALREADY) {
 416                         if (p->conf.debug) {
 417                                 log_error_write(srv, __FILE__, __LINE__, "sd",
 418                                                 "connect delayed:", proxy_fd);
 419                         }
 420
 421                         return 1;
 422                 } else {
 423
 424                         log_error_write(srv, __FILE__, __LINE__, "sdsd",
 425                                         "connect failed:", proxy_fd, strerror(errno), errno);
 426
 427                         return -1;
 428                 }
 429         }
 430         if (p->conf.debug) {
 431                 log_error_write(srv, __FILE__, __LINE__, "sd",
 432                                 "connect succeeded: ", proxy_fd);
 433         }
 434
 435         return 0;
 436 }
 437
 438 static void proxy_set_header(connection *con, const char *key, const char *value) {
 439         data_string *ds_dst;
 440
 441         if (NULL == (ds_dst = (data_string *)array_get_unused_element(con->request.headers, TYPE_STRING))) {
 442                 ds_dst = data_string_init();
 443         }
 444
 445         buffer_copy_string(ds_dst->key, key);
 446         buffer_copy_string(ds_dst->value, value);
 447         array_insert_unique(con->request.headers, (data_unset *)ds_dst);
 448 }
 449
 450 static void proxy_append_header(connection *con, const char *key, const char *value) {
 451         data_string *ds_dst;
 452
 453         if (NULL == (ds_dst = (data_string *)array_get_unused_element(con->request.headers, TYPE_STRING))) {
 454                 ds_dst = data_string_init();
 455         }
 456
 457         buffer_copy_string(ds_dst->key, key);
 458         buffer_append_string(ds_dst->value, value);
 459         array_insert_unique(con->request.headers, (data_unset *)ds_dst);
 460 }
 461
 462
 463 static int proxy_create_env(server *srv, handler_ctx *hctx) {
 464         size_t i;
 465
 466         connection *con   = hctx->remote_conn;
 467         buffer *b;
 468
 469         /* build header */
 470
 471         b = buffer_init();
 472
 473         /* request line */
 474         buffer_copy_string(b, get_http_method_name(con->request.http_method));
 475         buffer_append_string_len(b, CONST_STR_LEN(" "));
 476
 477         buffer_append_string_buffer(b, con->request.uri);
 478         buffer_append_string_len(b, CONST_STR_LEN(" HTTP/1.0\r\n"));
 479
 480         proxy_append_header(con, "X-Forwarded-For", (char *)inet_ntop_cache_get_ip(srv, &(con->dst_addr)));
 481         /* http_host is NOT is just a pointer to a buffer
 482          * which is NULL if it is not set */
 483         if (!buffer_string_is_empty(con->request.http_host)) {
 484                 proxy_set_header(con, "X-Host", con->request.http_host->ptr);
 485         }
 486         proxy_set_header(con, "X-Forwarded-Proto", con->uri.scheme->ptr);
 487
 488         /* request header */
 489         for (i = 0; i < con->request.headers->used; i++) {
 490                 data_string *ds;
 491
 492                 ds = (data_string *)con->request.headers->data[i];
 493
 494                 if (!buffer_is_empty(ds->value) && !buffer_is_empty(ds->key)) {
 495                         if (buffer_is_equal_caseless_string(ds->key, CONST_STR_LEN("Connection"))) continue;
 496                         if (buffer_is_equal_caseless_string(ds->key, CONST_STR_LEN("Proxy-Connection"))) continue;
 497
 498                         buffer_append_string_buffer(b, ds->key);
 499                         buffer_append_string_len(b, CONST_STR_LEN(": "));
 500                         buffer_append_string_buffer(b, ds->value);
 501                         buffer_append_string_len(b, CONST_STR_LEN("\r\n"));
 502                 }
 503         }
 504
 505         buffer_append_string_len(b, CONST_STR_LEN("Connection: close\r\n\r\n"));
 506
 507         hctx->wb_reqlen = buffer_string_length(b);
 508         chunkqueue_append_buffer(hctx->wb, b);
 509         buffer_free(b);
 510
 511         /* body */
 512
 513         if (con->request.content_length) {
 514                 chunkqueue *req_cq = con->request_content_queue;
 515
 516                 chunkqueue_steal(hctx->wb, req_cq, req_cq->bytes_in); /*(0 == req_cq->bytes_out)*/
 517                 hctx->wb_reqlen += con->request.content_length;/* (eventual) total request size */
 518         }
 519
 520         return 0;
 521 }
 522
 523 static int proxy_set_state(server *srv, handler_ctx *hctx, proxy_connection_state_t state) {
 524         hctx->state = state;
 525         hctx->state_timestamp = srv->cur_ts;
 526
 527         return 0;
 528 }
 529
 530
 531 static int proxy_response_parse(server *srv, connection *con, plugin_data *p, buffer *in) {
 532         char *s, *ns;
 533         int http_response_status = -1;
 534
 535         UNUSED(srv);
 536
 537         /* [\r]\n -> [\0]\0 */
 538
 539         buffer_copy_buffer(p->parse_response, in);
 540
 541         for (s = p->parse_response->ptr; NULL != (ns = strchr(s, '\n')); s = ns + 1) {
 542                 char *key, *value;
 543                 int key_len;
 544                 data_string *ds;
 545                 int copy_header;
 546
 547                 ns[0] = '\0';
 548                 if (s != ns && ns[-1] == '\r') ns[-1] = '\0';
 549
 550                 if (-1 == http_response_status) {
 551                         /* The first line of a Response message is the Status-Line */
 552
 553                         for (key=s; *key && *key != ' '; key++);
 554
 555                         if (*key) {
 556                                 http_response_status = (int) strtol(key, NULL, 10);
 557                                 if (http_response_status < 100 || http_response_status >= 1000) http_response_status = 502;
 558                         } else {
 559                                 http_response_status = 502;
 560                         }
 561
 562                         con->http_status = http_response_status;
 563                         con->parsed_response |= HTTP_STATUS;
 564                         continue;
 565                 }
 566
 567                 if (NULL == (value = strchr(s, ':'))) {
 568                         /* now we expect: "<key>: <value>\n" */
 569
 570                         continue;
 571                 }
 572
 573                 key = s;
 574                 key_len = value - key;
 575
 576                 value++;
 577                 /* strip WS */
 578                 while (*value == ' ' || *value == '\t') value++;
 579
 580                 copy_header = 1;
 581
 582                 switch(key_len) {
 583                 case 4:
 584                         if (0 == strncasecmp(key, "Date", key_len)) {
 585                                 con->parsed_response |= HTTP_DATE;
 586                         }
 587                         break;
 588                 case 8:
 589                         if (0 == strncasecmp(key, "Location", key_len)) {
 590                                 con->parsed_response |= HTTP_LOCATION;
 591                         }
 592                         break;
 593                 case 10:
 594                         if (0 == strncasecmp(key, "Connection", key_len)) {
 595                                 copy_header = 0;
 596                         }
 597                         break;
 598                 case 14:
 599                         if (0 == strncasecmp(key, "Content-Length", key_len)) {
 600                                 con->response.content_length = strtoul(value, NULL, 10);
 601                                 con->parsed_response |= HTTP_CONTENT_LENGTH;
 602                         }
 603                         break;
 604                 default:
 605                         break;
 606                 }
 607
 608                 if (copy_header) {
 609                         if (NULL == (ds = (data_string *)array_get_unused_element(con->response.headers, TYPE_STRING))) {
 610                                 ds = data_response_init();
 611                         }
 612                         buffer_copy_string_len(ds->key, key, key_len);
 613                         buffer_copy_string(ds->value, value);
 614
 615                         array_insert_unique(con->response.headers, (data_unset *)ds);
 616                 }
 617         }
 618
 619         return 0;
 620 }
 621
 622
 623 static int proxy_demux_response(server *srv, handler_ctx *hctx) {
 624         int fin = 0;
 625         int b;
 626         ssize_t r;
 627
 628         plugin_data *p    = hctx->plugin_data;
 629         connection *con   = hctx->remote_conn;
 630         int proxy_fd       = hctx->fd;
 631
 632         /* check how much we have to read */
 633         if (ioctl(hctx->fd, FIONREAD, &b)) {
 634                 if (errno == EAGAIN) {
 635                         fdevent_event_add(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
 636                         return 0;
 637                 }
 638                 log_error_write(srv, __FILE__, __LINE__, "sd",
 639                                 "ioctl failed: ",
 640                                 proxy_fd);
 641                 return -1;
 642         }
 643
 644
 645         if (p->conf.debug) {
 646                 log_error_write(srv, __FILE__, __LINE__, "sd",
 647                                 "proxy - have to read:", b);
 648         }
 649
 650         if (b > 0) {
 651                 if ((con->conf.stream_response_body & FDEVENT_STREAM_RESPONSE_BUFMIN)) {
 652                         off_t cqlen = chunkqueue_length(con->write_queue);
 653                         if (cqlen + b > 65536 - 4096) {
 654                                 if (!con->is_writable) {
 655                                         /*(defer removal of FDEVENT_IN interest since
 656                                          * connection_state_machine() might be able to send data
 657                                          * immediately, unless !con->is_writable, where
 658                                          * connection_state_machine() might not loop back to call
 659                                          * mod_proxy_handle_subrequest())*/
 660                                         fdevent_event_clr(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
 661                                 }
 662                                 if (cqlen >= 65536-1) return 0;
 663                                 b = 65536 - 1 - (int)cqlen;
 664                         }
 665                 }
 666
 667                 buffer_string_prepare_append(hctx->response, b);
 668
 669                 if (-1 == (r = read(hctx->fd, hctx->response->ptr + buffer_string_length(hctx->response), buffer_string_space(hctx->response)))) {
 670                         if (errno == EAGAIN) {
 671                                 fdevent_event_add(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
 672                                 return 0;
 673                         }
 674                         log_error_write(srv, __FILE__, __LINE__, "sds",
 675                                         "unexpected end-of-file (perhaps the proxy process died):",
 676                                         proxy_fd, strerror(errno));
 677                         return -1;
 678                 }
 679
 680                 /* this should be catched by the b > 0 above */
 681                 force_assert(r);
 682
 683                 buffer_commit(hctx->response, r);
 684
 685 #if 0
 686                 log_error_write(srv, __FILE__, __LINE__, "sdsbs",
 687                                 "demux: Response buffer len", hctx->response->used, ":", hctx->response, ":");
 688 #endif
 689
 690                 if (0 == con->got_response) {
 691                         con->got_response = 1;
 692                         buffer_string_prepare_copy(hctx->response_header, 1023);
 693                 }
 694
 695                 if (0 == con->file_started) {
 696                         char *c;
 697
 698                         /* search for the \r\n\r\n in the string */
 699                         if (NULL != (c = buffer_search_string_len(hctx->response, CONST_STR_LEN("\r\n\r\n")))) {
 700                                 size_t hlen = c - hctx->response->ptr + 4;
 701                                 size_t blen = buffer_string_length(hctx->response) - hlen;
 702                                 /* found */
 703
 704                                 buffer_append_string_len(hctx->response_header, hctx->response->ptr, hlen);
 705 #if 0
 706                                 log_error_write(srv, __FILE__, __LINE__, "sb", "Header:", hctx->response_header);
 707 #endif
 708                                 /* parse the response header */
 709                                 proxy_response_parse(srv, con, p, hctx->response_header);
 710
 711                                 /* enable chunked-transfer-encoding */
 712                                 if (con->request.http_version == HTTP_VERSION_1_1 &&
 713                                     !(con->parsed_response & HTTP_CONTENT_LENGTH)) {
 714                                         con->response.transfer_encoding = HTTP_TRANSFER_ENCODING_CHUNKED;
 715                                 }
 716
 717                                 con->file_started = 1;
 718                                 if (blen > 0) {
 719                                         if (0 != http_chunk_append_mem(srv, con, c + 4, blen)) {
 720                                                 /* error writing to tempfile;
 721                                                  * truncate response or send 500 if nothing sent yet */
 722                                                 fin = 1;
 723                                                 con->file_started = 0;
 724                                         }
 725                                 }
 726                                 buffer_reset(hctx->response);
 727                         } else {
 728                                 /* no luck, no header found */
 729                                 /*(reuse MAX_HTTP_REQUEST_HEADER as max size for response headers from backends)*/
 730                                 if (buffer_string_length(hctx->response) > MAX_HTTP_REQUEST_HEADER) {
 731                                         log_error_write(srv, __FILE__, __LINE__, "sb", "response headers too large for", con->uri.path);
 732                                         con->http_status = 502; /* Bad Gateway */
 733                                         con->mode = DIRECT;
 734                                         fin = 1;
 735                                 }
 736                         }
 737                 } else {
 738                         if (0 != http_chunk_append_buffer(srv, con, hctx->response)) {
 739                                 /* error writing to tempfile;
 740                                  * truncate response or send 500 if nothing sent yet */
 741                                 fin = 1;
 742                         }
 743                         buffer_reset(hctx->response);
 744                 }
 745
 746         } else {
 747                 /* reading from upstream done */
 748                 con->file_finished = 1;
 749
 750                 http_chunk_close(srv, con);
 751
 752                 fin = 1;
 753         }
 754
 755         return fin;
 756 }
 757
 758
 759 static handler_t proxy_write_request(server *srv, handler_ctx *hctx) {
 760         data_proxy *host= hctx->host;
 761         connection *con   = hctx->remote_conn;
 762
 763         int ret;
 764
 765         if (!host || buffer_string_is_empty(host->host) || !host->port) return HANDLER_ERROR;
 766
 767         switch(hctx->state) {
 768         case PROXY_STATE_CONNECT:
 769                 /* wait for the connect() to finish */
 770
 771                 /* connect failed ? */
 772                 if (-1 == hctx->fde_ndx) return HANDLER_ERROR;
 773
 774                 /* wait */
 775                 return HANDLER_WAIT_FOR_EVENT;
 776
 777         case PROXY_STATE_INIT:
 778 #if defined(HAVE_SYS_UN_H)
 779                 if (strstr(host->host->ptr,"/")) {
 780                         if (-1 == (hctx->fd = socket(AF_UNIX, SOCK_STREAM, 0))) {
 781                                 log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed: ", strerror(errno));
 782                                 return HANDLER_ERROR;
 783                         }
 784                 } else
 785 #endif
 786 #if defined(HAVE_IPV6) && defined(HAVE_INET_PTON)
 787                 if (strstr(host->host->ptr,":")) {
 788                         if (-1 == (hctx->fd = socket(AF_INET6, SOCK_STREAM, 0))) {
 789                                 log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed: ", strerror(errno));
 790                                 return HANDLER_ERROR;
 791                         }
 792                 } else
 793 #endif
 794                 {
 795                         if (-1 == (hctx->fd = socket(AF_INET, SOCK_STREAM, 0))) {
 796                                 log_error_write(srv, __FILE__, __LINE__, "ss", "socket failed: ", strerror(errno));
 797                                 return HANDLER_ERROR;
 798                         }
 799                 }
 800                 hctx->fde_ndx = -1;
 801
 802                 srv->cur_fds++;
 803
 804                 fdevent_register(srv->ev, hctx->fd, proxy_handle_fdevent, hctx);
 805
 806                 if (-1 == fdevent_fcntl_set(srv->ev, hctx->fd)) {
 807                         log_error_write(srv, __FILE__, __LINE__, "ss", "fcntl failed: ", strerror(errno));
 808
 809                         return HANDLER_ERROR;
 810                 }
 811
 812                 switch (proxy_establish_connection(srv, hctx)) {
 813                 case 1:
 814                         proxy_set_state(srv, hctx, PROXY_STATE_CONNECT);
 815
 816                         /* connection is in progress, wait for an event and call getsockopt() below */
 817
 818                         fdevent_event_set(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
 819
 820                         return HANDLER_WAIT_FOR_EVENT;
 821                 case -1:
 822                         /* if ECONNREFUSED choose another connection -> FIXME */
 823                         hctx->fde_ndx = -1;
 824
 825                         return HANDLER_ERROR;
 826                 default:
 827                         /* everything is ok, go on */
 828                         proxy_set_state(srv, hctx, PROXY_STATE_PREPARE_WRITE);
 829                         break;
 830                 }
 831
 832                 /* fall through */
 833
 834         case PROXY_STATE_PREPARE_WRITE:
 835                 proxy_create_env(srv, hctx);
 836
 837                 fdevent_event_add(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
 838                 proxy_set_state(srv, hctx, PROXY_STATE_WRITE);
 839
 840                 /* fall through */
 841         case PROXY_STATE_WRITE:;
 842                 ret = srv->network_backend_write(srv, con, hctx->fd, hctx->wb, MAX_WRITE_LIMIT);
 843
 844                 chunkqueue_remove_finished_chunks(hctx->wb);
 845
 846                 if (-1 == ret) { /* error on our side */
 847                         log_error_write(srv, __FILE__, __LINE__, "ssd", "write failed:", strerror(errno), errno);
 848
 849                         return HANDLER_ERROR;
 850                 } else if (-2 == ret) { /* remote close */
 851                         log_error_write(srv, __FILE__, __LINE__, "ssd", "write failed, remote connection close:", strerror(errno), errno);
 852
 853                         return HANDLER_ERROR;
 854                 }
 855
 856                 if (hctx->wb->bytes_out == hctx->wb_reqlen) {
 857                         fdevent_event_clr(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
 858                         shutdown(hctx->fd, SHUT_WR);/* future: remove if HTTP/1.1 request */
 859                         proxy_set_state(srv, hctx, PROXY_STATE_READ);
 860                 } else {
 861                         off_t wblen = hctx->wb->bytes_in - hctx->wb->bytes_out;
 862                         if (hctx->wb->bytes_in < hctx->wb_reqlen && wblen < 65536 - 16384) {
 863                                 /*(con->conf.stream_request_body & FDEVENT_STREAM_REQUEST)*/
 864                                 if (!(con->conf.stream_request_body & FDEVENT_STREAM_REQUEST_POLLIN)) {
 865                                         con->conf.stream_request_body |= FDEVENT_STREAM_REQUEST_POLLIN;
 866                                         con->is_readable = 1; /* trigger optimistic read from client */
 867                                 }
 868                         }
 869                         if (0 == wblen) {
 870                                 fdevent_event_clr(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
 871                         } else {
 872                                 fdevent_event_add(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_OUT);
 873                         }
 874                 }
 875
 876                 return HANDLER_WAIT_FOR_EVENT;
 877         case PROXY_STATE_READ:
 878                 /* waiting for a response */
 879                 return HANDLER_WAIT_FOR_EVENT;
 880         default:
 881                 log_error_write(srv, __FILE__, __LINE__, "s", "(debug) unknown state");
 882                 return HANDLER_ERROR;
 883         }
 884 }
 885
 886 #define PATCH(x) \
 887         p->conf.x = s->x;
 888 static int mod_proxy_patch_connection(server *srv, connection *con, plugin_data *p) {
 889         size_t i, j;
 890         plugin_config *s = p->config_storage[0];
 891
 892         PATCH(extensions);
 893         PATCH(debug);
 894         PATCH(balance);
 895
 896         /* skip the first, the global context */
 897         for (i = 1; i < srv->config_context->used; i++) {
 898                 data_config *dc = (data_config *)srv->config_context->data[i];
 899                 s = p->config_storage[i];
 900
 901                 /* condition didn't match */
 902                 if (!config_check_cond(srv, con, dc)) continue;
 903
 904                 /* merge config */
 905                 for (j = 0; j < dc->value->used; j++) {
 906                         data_unset *du = dc->value->data[j];
 907
 908                         if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.server"))) {
 909                                 PATCH(extensions);
 910                         } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.debug"))) {
 911                                 PATCH(debug);
 912                         } else if (buffer_is_equal_string(du->key, CONST_STR_LEN("proxy.balance"))) {
 913                                 PATCH(balance);
 914                         }
 915                 }
 916         }
 917
 918         return 0;
 919 }
 920 #undef PATCH
 921
 922 static handler_t proxy_send_request(server *srv, handler_ctx *hctx) {
 923         /* ok, create the request */
 924         handler_t rc = proxy_write_request(srv, hctx);
 925         if (HANDLER_ERROR != rc) {
 926                 return rc;
 927         } else {
 928                 data_proxy *host = hctx->host;
 929                 connection *con  = hctx->remote_conn;
 930                 log_error_write(srv, __FILE__, __LINE__,  "sbdd", "proxy-server disabled:",
 931                                 host->host,
 932                                 host->port,
 933                                 hctx->fd);
 934
 935                 /* disable this server */
 936                 host->is_disabled = 1;
 937                 host->disable_ts = srv->cur_ts;
 938
 939                 /* reset the enviroment and restart the sub-request */
 940                 con->mode = DIRECT;/*(avoid changing con->state, con->http_status)*/
 941                 proxy_connection_close(srv, hctx);
 942                 con->mode = hctx->plugin_data->id; /* p->id */
 943
 944                 return HANDLER_COMEBACK;
 945         }
 946 }
 947
 948
 949 static handler_t proxy_recv_response(server *srv, handler_ctx *hctx);
 950
 951
 952 SUBREQUEST_FUNC(mod_proxy_handle_subrequest) {
 953         plugin_data *p = p_d;
 954
 955         handler_ctx *hctx = con->plugin_ctx[p->id];
 956
 957         if (NULL == hctx) return HANDLER_GO_ON;
 958
 959         /* not my job */
 960         if (con->mode != p->id) return HANDLER_GO_ON;
 961
 962         if ((con->conf.stream_response_body & FDEVENT_STREAM_RESPONSE_BUFMIN)
 963             && con->file_started) {
 964                 if (chunkqueue_length(con->write_queue) > 65536 - 4096) {
 965                         fdevent_event_clr(srv->ev, &(hctx->fde_ndx), hctx->fd, FDEVENT_IN);
 966                 } else if (!(fdevent_event_get_interest(srv->ev, hctx->fd) & FDEVENT_IN)) {
 967                         /* optimistic read from backend, which might re-enable FDEVENT_IN */
 968                         handler_t rc = proxy_recv_response(srv, hctx); /*(might invalidate hctx)*/
 969                         if (rc != HANDLER_GO_ON) return rc;            /*(unless HANDLER_GO_ON)*/
 970                 }
 971         }
 972
 973         if (0 == hctx->wb->bytes_in
 974             ? con->state == CON_STATE_READ_POST
 975             : hctx->wb->bytes_in < hctx->wb_reqlen) {
 976                 /*(64k - 4k to attempt to avoid temporary files
 977                  * in conjunction with FDEVENT_STREAM_REQUEST_BUFMIN)*/
 978                 if (hctx->wb->bytes_in - hctx->wb->bytes_out > 65536 - 4096
 979                     && (con->conf.stream_request_body & FDEVENT_STREAM_REQUEST_BUFMIN)){
 980                         con->conf.stream_request_body &= ~FDEVENT_STREAM_REQUEST_POLLIN;
 981                         if (0 != hctx->wb->bytes_in) return HANDLER_WAIT_FOR_EVENT;
 982                 } else {
 983                         handler_t r = connection_handle_read_post_state(srv, con);
 984                         chunkqueue *req_cq = con->request_content_queue;
 985                         if (0 != hctx->wb->bytes_in && !chunkqueue_is_empty(req_cq)) {
 986                                 chunkqueue_steal(hctx->wb, req_cq, req_cq->bytes_in - req_cq->bytes_out);
 987                                 if (fdevent_event_get_interest(srv->ev, hctx->fd) & FDEVENT_OUT) {
 988                                         return (r == HANDLER_GO_ON) ? HANDLER_WAIT_FOR_EVENT : r;
 989                                 }
 990                         }
 991                         if (r != HANDLER_GO_ON) return r;
 992                 }
 993         }
 994
 995         return (0 == hctx->wb->bytes_in || !chunkqueue_is_empty(hctx->wb))
 996           ? proxy_send_request(srv, hctx)
 997           : HANDLER_WAIT_FOR_EVENT;
 998 }
 999
1000
1001 static handler_t proxy_recv_response(server *srv, handler_ctx *hctx) {
1002
1003                 switch (proxy_demux_response(srv, hctx)) {
1004                 case 0:
1005                         break;
1006                 case 1:
1007                         /* we are done */
1008                         proxy_connection_close(srv, hctx);
1009
1010                         return HANDLER_FINISHED;
1011                 case -1: {
1012                         connection *con = hctx->remote_conn;
1013                         if (con->file_started == 0) {
1014                                 /* reading response headers failed */
1015                         } else {
1016                                 /* response might have been already started, kill the connection */
1017                                 con->keep_alive = 0;
1018                                 con->file_finished = 1;
1019                                 con->mode = DIRECT; /*(avoid sending final chunked block)*/
1020                         }
1021
1022                         proxy_connection_close(srv, hctx);
1023
1024                         return HANDLER_FINISHED;
1025                 }
1026                 }
1027
1028                 return HANDLER_GO_ON;
1029 }
1030
1031
1032 static handler_t proxy_handle_fdevent(server *srv, void *ctx, int revents) {
1033         handler_ctx *hctx = ctx;
1034         connection  *con  = hctx->remote_conn;
1035         plugin_data *p    = hctx->plugin_data;
1036
1037         joblist_append(srv, con);
1038
1039         if (revents & FDEVENT_IN) {
1040
1041                 if (p->conf.debug) {
1042                         log_error_write(srv, __FILE__, __LINE__, "sd",
1043                                         "proxy: fdevent-in", hctx->state);
1044                 }
1045
1046                 {
1047                 handler_t rc = proxy_recv_response(srv,hctx);/*(might invalidate hctx)*/
1048                 if (rc != HANDLER_GO_ON) return rc;          /*(unless HANDLER_GO_ON)*/
1049                 }
1050         }
1051
1052         if (revents & FDEVENT_OUT) {
1053                 if (p->conf.debug) {
1054                         log_error_write(srv, __FILE__, __LINE__, "sd",
1055                                         "proxy: fdevent-out", hctx->state);
1056                 }
1057
1058                 if (hctx->state == PROXY_STATE_CONNECT) {
1059                         int socket_error;
1060                         socklen_t socket_error_len = sizeof(socket_error);
1061
1062                         /* try to finish the connect() */
1063                         if (0 != getsockopt(hctx->fd, SOL_SOCKET, SO_ERROR, &socket_error, &socket_error_len)) {
1064                                 log_error_write(srv, __FILE__, __LINE__, "ss",
1065                                         "getsockopt failed:", strerror(errno));
1066
1067                                 return HANDLER_FINISHED;
1068                         }
1069                         if (socket_error != 0) {
1070                                 log_error_write(srv, __FILE__, __LINE__, "ss",
1071                                         "establishing connection failed:", strerror(socket_error),
1072                                         "port:", hctx->host->port);
1073
1074                                 return HANDLER_FINISHED;
1075                         }
1076                         if (p->conf.debug) {
1077                                 log_error_write(srv, __FILE__, __LINE__,  "s", "proxy - connect - delayed success");
1078                         }
1079
1080                         proxy_set_state(srv, hctx, PROXY_STATE_PREPARE_WRITE);
1081                 }
1082
1083                 return proxy_send_request(srv, hctx); /*(might invalidate hctx)*/
1084         }
1085
1086         /* perhaps this issue is already handled */
1087         if (revents & FDEVENT_HUP) {
1088                 if (p->conf.debug) {
1089                         log_error_write(srv, __FILE__, __LINE__, "sd",
1090                                         "proxy: fdevent-hup", hctx->state);
1091                 }
1092
1093                 if (hctx->state == PROXY_STATE_CONNECT) {
1094                         /* connect() -> EINPROGRESS -> HUP */
1095
1096                         /**
1097                          * what is proxy is doing if it can't reach the next hop ?
1098                          *
1099                          */
1100
1101                         if (hctx->host) {
1102                                 hctx->host->is_disabled = 1;
1103                                 hctx->host->disable_ts = srv->cur_ts;
1104                                 log_error_write(srv, __FILE__, __LINE__,  "sbdd", "proxy-server disabled:",
1105                                                 hctx->host->host,
1106                                                 hctx->host->port,
1107                                                 hctx->fd);
1108
1109                                 /* disable this server */
1110                                 hctx->host->is_disabled = 1;
1111                                 hctx->host->disable_ts = srv->cur_ts;
1112
1113                                 /* reset the environment and restart the sub-request */
1114                                 con->mode = DIRECT;/*(avoid changing con->state, con->http_status)*/
1115                                 proxy_connection_close(srv, hctx);
1116                                 con->mode = p->id;
1117                         } else {
1118                                 proxy_connection_close(srv, hctx);
1119                                 con->http_status = 503;
1120                         }
1121                 } else if (con->file_started) {
1122                         /* drain any remaining data from kernel pipe buffers
1123                          * even if (con->conf.stream_response_body
1124                          *          & FDEVENT_STREAM_RESPONSE_BUFMIN)
1125                          * since event loop will spin on fd FDEVENT_HUP event
1126                          * until unregistered. */
1127                         handler_t rc;
1128                         do {
1129                                 rc = proxy_recv_response(srv,hctx);/*(might invalidate hctx)*/
1130                         } while (rc == HANDLER_GO_ON);             /*(unless HANDLER_GO_ON)*/
1131                         return rc; /* HANDLER_FINISHED or HANDLER_ERROR */
1132                 } else {
1133                         proxy_connection_close(srv, hctx);
1134                 }
1135         } else if (revents & FDEVENT_ERR) {
1136                 log_error_write(srv, __FILE__, __LINE__, "sd", "proxy-FDEVENT_ERR, but no HUP", revents);
1137
1138                 if (con->file_started) {
1139                         con->keep_alive = 0;
1140                         con->file_finished = 1;
1141                         con->mode = DIRECT; /*(avoid sending final chunked block)*/
1142                 }
1143                 proxy_connection_close(srv, hctx);
1144         }
1145
1146         return HANDLER_FINISHED;
1147 }
1148
1149 static handler_t mod_proxy_check_extension(server *srv, connection *con, void *p_d) {
1150         plugin_data *p = p_d;
1151         size_t s_len;
1152         unsigned long last_max = ULONG_MAX;
1153         int max_usage = INT_MAX;
1154         int ndx = -1;
1155         size_t k;
1156         buffer *fn;
1157         data_array *extension = NULL;
1158         size_t path_info_offset;
1159
1160         if (con->mode != DIRECT) return HANDLER_GO_ON;
1161
1162         /* Possibly, we processed already this request */
1163         if (con->file_started == 1) return HANDLER_GO_ON;
1164
1165         mod_proxy_patch_connection(srv, con, p);
1166
1167         fn = con->uri.path;
1168         if (buffer_string_is_empty(fn)) return HANDLER_ERROR;
1169         s_len = buffer_string_length(fn);
1170
1171         path_info_offset = 0;
1172
1173         if (p->conf.debug) {
1174                 log_error_write(srv, __FILE__, __LINE__,  "s", "proxy - start");
1175         }
1176
1177         /* check if extension matches */
1178         for (k = 0; k < p->conf.extensions->used; k++) {
1179                 data_array *ext = NULL;
1180                 size_t ct_len;
1181
1182                 ext = (data_array *)p->conf.extensions->data[k];
1183
1184                 if (buffer_is_empty(ext->key)) continue;
1185
1186                 ct_len = buffer_string_length(ext->key);
1187
1188                 if (s_len < ct_len) continue;
1189
1190                 /* check extension in the form "/proxy_pattern" */
1191                 if (*(ext->key->ptr) == '/') {
1192                         if (strncmp(fn->ptr, ext->key->ptr, ct_len) == 0) {
1193                                 if (s_len > ct_len + 1) {
1194                                         char *pi_offset;
1195
1196                                         if (NULL != (pi_offset = strchr(fn->ptr + ct_len + 1, '/'))) {
1197                                                 path_info_offset = pi_offset - fn->ptr;
1198                                         }
1199                                 }
1200                                 extension = ext;
1201                                 break;
1202                         }
1203                 } else if (0 == strncmp(fn->ptr + s_len - ct_len, ext->key->ptr, ct_len)) {
1204                         /* check extension in the form ".fcg" */
1205                         extension = ext;
1206                         break;
1207                 }
1208         }
1209
1210         if (NULL == extension) {
1211                 return HANDLER_GO_ON;
1212         }
1213
1214         if (p->conf.debug) {
1215                 log_error_write(srv, __FILE__, __LINE__,  "s", "proxy - ext found");
1216         }
1217
1218         if (extension->value->used == 1) {
1219                 if ( ((data_proxy *)extension->value->data[0])->is_disabled ) {
1220                         ndx = -1;
1221                 } else {
1222                         ndx = 0;
1223                 }
1224         } else if (extension->value->used != 0) switch(p->conf.balance) {
1225         case PROXY_BALANCE_HASH:
1226                 /* hash balancing */
1227
1228                 if (p->conf.debug) {
1229                         log_error_write(srv, __FILE__, __LINE__,  "sd",
1230                                         "proxy - used hash balancing, hosts:", extension->value->used);
1231                 }
1232
1233                 for (k = 0, ndx = -1, last_max = ULONG_MAX; k < extension->value->used; k++) {
1234                         data_proxy *host = (data_proxy *)extension->value->data[k];
1235                         unsigned long cur_max;
1236
1237                         if (host->is_disabled) continue;
1238
1239                         cur_max = generate_crc32c(CONST_BUF_LEN(con->uri.path)) +
1240                                 generate_crc32c(CONST_BUF_LEN(host->host)) + /* we can cache this */
1241                                 generate_crc32c(CONST_BUF_LEN(con->uri.authority));
1242
1243                         if (p->conf.debug) {
1244                                 log_error_write(srv, __FILE__, __LINE__,  "sbbbd",
1245                                                 "proxy - election:",
1246                                                 con->uri.path,
1247                                                 host->host,
1248                                                 con->uri.authority,
1249                                                 cur_max);
1250                         }
1251
1252                         if ((last_max == ULONG_MAX) || /* first round */
1253                             (cur_max > last_max)) {
1254                                 last_max = cur_max;
1255
1256                                 ndx = k;
1257                         }
1258                 }
1259
1260                 break;
1261         case PROXY_BALANCE_FAIR:
1262                 /* fair balancing */
1263                 if (p->conf.debug) {
1264                         log_error_write(srv, __FILE__, __LINE__,  "s",
1265                                         "proxy - used fair balancing");
1266                 }
1267
1268                 for (k = 0, ndx = -1, max_usage = INT_MAX; k < extension->value->used; k++) {
1269                         data_proxy *host = (data_proxy *)extension->value->data[k];
1270
1271                         if (host->is_disabled) continue;
1272
1273                         if (host->usage < max_usage) {
1274                                 max_usage = host->usage;
1275
1276                                 ndx = k;
1277                         }
1278                 }
1279
1280                 break;
1281         case PROXY_BALANCE_RR: {
1282                 data_proxy *host;
1283
1284                 /* round robin */
1285                 if (p->conf.debug) {
1286                         log_error_write(srv, __FILE__, __LINE__,  "s",
1287                                         "proxy - used round-robin balancing");
1288                 }
1289
1290                 /* just to be sure */
1291                 force_assert(extension->value->used < INT_MAX);
1292
1293                 host = (data_proxy *)extension->value->data[0];
1294
1295                 /* Use last_used_ndx from first host in list */
1296                 k = host->last_used_ndx;
1297                 ndx = k + 1; /* use next host after the last one */
1298                 if (ndx < 0) ndx = 0;
1299
1300                 /* Search first active host after last_used_ndx */
1301                 while ( ndx < (int) extension->value->used
1302                                 && (host = (data_proxy *)extension->value->data[ndx])->is_disabled ) ndx++;
1303
1304                 if (ndx >= (int) extension->value->used) {
1305                         /* didn't found a higher id, wrap to the start */
1306                         for (ndx = 0; ndx <= (int) k; ndx++) {
1307                                 host = (data_proxy *)extension->value->data[ndx];
1308                                 if (!host->is_disabled) break;
1309                         }
1310
1311                         /* No active host found */
1312                         if (host->is_disabled) ndx = -1;
1313                 }
1314
1315                 /* Save new index for next round */
1316                 ((data_proxy *)extension->value->data[0])->last_used_ndx = ndx;
1317
1318                 break;
1319         }
1320         default:
1321                 break;
1322         }
1323
1324         /* found a server */
1325         if (ndx != -1) {
1326                 data_proxy *host = (data_proxy *)extension->value->data[ndx];
1327
1328                 /*
1329                  * if check-local is disabled, use the uri.path handler
1330                  *
1331                  */
1332
1333                 /* init handler-context */
1334                 handler_ctx *hctx;
1335                 hctx = handler_ctx_init();
1336
1337                 hctx->path_info_offset = path_info_offset;
1338                 hctx->remote_conn      = con;
1339                 hctx->plugin_data      = p;
1340                 hctx->host             = host;
1341
1342                 con->plugin_ctx[p->id] = hctx;
1343
1344                 host->usage++;
1345
1346                 con->mode = p->id;
1347
1348                 if (p->conf.debug) {
1349                         log_error_write(srv, __FILE__, __LINE__,  "sbd",
1350                                         "proxy - found a host",
1351                                         host->host, host->port);
1352                 }
1353
1354                 return HANDLER_GO_ON;
1355         } else {
1356                 /* no handler found */
1357                 con->http_status = 500;
1358
1359                 log_error_write(srv, __FILE__, __LINE__,  "sb",
1360                                 "no proxy-handler found for:",
1361                                 fn);
1362
1363                 return HANDLER_FINISHED;
1364         }
1365         return HANDLER_GO_ON;
1366 }
1367
1368 static handler_t mod_proxy_connection_reset(server *srv, connection *con, void *p_d) {
1369         plugin_data *p = p_d;
1370         handler_ctx *hctx = con->plugin_ctx[p->id];
1371         if (hctx) proxy_connection_close(srv, hctx);
1372
1373         return HANDLER_GO_ON;
1374 }
1375
1376 /**
1377  *
1378  * the trigger re-enables the disabled connections after the timeout is over
1379  *
1380  * */
1381
1382 TRIGGER_FUNC(mod_proxy_trigger) {
1383         plugin_data *p = p_d;
1384
1385         if (p->config_storage) {
1386                 size_t i, n, k;
1387                 for (i = 0; i < srv->config_context->used; i++) {
1388                         plugin_config *s = p->config_storage[i];
1389
1390                         if (!s) continue;
1391
1392                         /* get the extensions for all configs */
1393
1394                         for (k = 0; k < s->extensions->used; k++) {
1395                                 data_array *extension = (data_array *)s->extensions->data[k];
1396
1397                                 /* get all hosts */
1398                                 for (n = 0; n < extension->value->used; n++) {
1399                                         data_proxy *host = (data_proxy *)extension->value->data[n];
1400
1401                                         if (!host->is_disabled ||
1402                                             srv->cur_ts - host->disable_ts < 5) continue;
1403
1404                                         log_error_write(srv, __FILE__, __LINE__,  "sbd",
1405                                                         "proxy - re-enabled:",
1406                                                         host->host, host->port);
1407
1408                                         host->is_disabled = 0;
1409                                 }
1410                         }
1411                 }
1412         }
1413
1414         return HANDLER_GO_ON;
1415 }
1416
1417
1418 int mod_proxy_plugin_init(plugin *p);
1419 int mod_proxy_plugin_init(plugin *p) {
1420         p->version      = LIGHTTPD_VERSION_ID;
1421         p->name         = buffer_init_string("proxy");
1422
1423         p->init         = mod_proxy_init;
1424         p->cleanup      = mod_proxy_free;
1425         p->set_defaults = mod_proxy_set_defaults;
1426         p->connection_reset        = mod_proxy_connection_reset; /* end of req-resp cycle */
1427         p->handle_connection_close = mod_proxy_connection_reset; /* end of client connection */
1428         p->handle_uri_clean        = mod_proxy_check_extension;
1429         p->handle_subrequest       = mod_proxy_handle_subrequest;
1430         p->handle_trigger          = mod_proxy_trigger;
1431
1432         p->data         = NULL;
1433
1434         return 0;
1435 }