mod_proxy_fdpass2.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "mod_proxy.h"
  18
  19 #include <sys/types.h>
  20 #include <sys/socket.h>
  21 #include <sys/un.h>
  22 #include <time.h>
  23 #include <stdlib.h>
  24
  25 #ifndef CMSG_DATA
  26 #error This module only works on unix platforms with the correct OS support
  27 #endif
  28
  29 #include "apr_version.h"
  30 #if APR_MAJOR_VERSION < 2
  31 /* for apr_wait_for_io_or_timeout */
  32 #include "apr_support.h"
  33 #endif
  34
  35 #include "mod_proxy_fdpass2.h"
  36
  37 module AP_MODULE_DECLARE_DATA proxy_fdpass2_module;
  38
  39 #define ALTOUT_USOCK_N 10
  40 #define ALTOUT_DEBUG 1
  41 #define ALTOUT_DBG_FILE "/home/log/fdpass2.log"
  42
  43 static int proxy_fdpass2_canon(request_rec *r, char *url)
  44 {
  45     const char *path;
  46     char sfx[16];
  47
  48 #if ALTOUT_DEBUG > 1
  49     {
  50         int mop_fd;
  51         char mop_bf[512];
  52
  53         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
  54         sprintf(mop_bf, "proxy_http_canon: start [%p]\n", r->headers_in);
  55         write(mop_fd, mop_bf, strlen(mop_bf));
  56         close(mop_fd);
  57     }
  58 #endif
  59
  60     if (strncasecmp(url, "fd://", 5) == 0) {
  61         url += 5;
  62     }
  63     else {
  64         return DECLINED;
  65     }
  66
  67     path = ap_server_root_relative(r->pool, url);
  68
  69     sprintf(sfx, "%d.sock", rand() % ALTOUT_USOCK_N);
  70     r->filename = apr_pstrcat(r->pool, "proxy:fd://", path, sfx, NULL);
  71
  72     /* ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r,
  73        "proxy: FD: set r->filename to %s", r->filename); */
  74     return OK;
  75 }
  76
  77 /* TODO: In APR 2.x: Extend apr_sockaddr_t to possibly be a path !!! */
  78 static apr_status_t socket_connect_un(request_rec *r, apr_socket_t *sock,
  79                                       struct sockaddr_un *sa)
  80 {
  81     apr_status_t rv;
  82     apr_os_sock_t rawsock;
  83     apr_interval_time_t t;
  84
  85     rv = apr_os_sock_get(&rawsock, sock);
  86     if (rv != APR_SUCCESS) {
  87         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
  88                       "proxy: FD: apr_os_sock_get failed");
  89         return rv;
  90     }
  91
  92     rv = apr_socket_timeout_get(sock, &t);
  93     if (rv != APR_SUCCESS) {
  94         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
  95                       "proxy: FD: apr_socket_timeout_get failed");
  96         return rv;
  97     }
  98
  99     do {
 100         /* ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 101            "proxy: FD: pre_connect"); */
 102         rv = connect(rawsock, (struct sockaddr*)sa,
 103                      sizeof(*sa) /* + strlen(sa->sun_path)*/ );
 104         /* ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 105            "proxy: FD: post_connect %d", rv); */
 106     } while (rv == -1 && errno == EINTR);
 107
 108     if ((rv == -1) && (errno == EINPROGRESS || errno == EALREADY)
 109         && (t > 0)) {
 110 #if APR_MAJOR_VERSION < 2
 111         rv = apr_wait_for_io_or_timeout(NULL, sock, 0);
 112 #else
 113         rv = apr_socket_wait(sock, APR_WAIT_WRITE);
 114 #endif
 115
 116         if (rv != APR_SUCCESS) {
 117             ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, NULL,
 118                          "proxy: FD: apr_socket_wait failed");
 119             return rv;
 120         }
 121     }
 122
 123     if (rv == -1 && errno != EISCONN) {
 124         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 125                       "proxy: FD: socket_connect_un preexit %d", errno);
 126         return errno;
 127     }
 128
 129     return APR_SUCCESS;
 130 }
 131
 132 static apr_status_t get_socket_from_path(request_rec *r, apr_pool_t *p,
 133                                          const char* path,
 134                                          apr_socket_t **out_sock)
 135 {
 136     struct sockaddr_un sa;
 137     apr_socket_t *s;
 138     apr_status_t rv;
 139     *out_sock = NULL;
 140
 141     /*
 142     ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 143                   "proxy: FD: Failed to connect to '%s' %d xxx",
 144                       url, rv);
 145     ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 146                  "proxy: FD: get_socket_from_path::START");
 147     */
 148
 149     rv = apr_socket_create(&s, AF_UNIX, SOCK_STREAM, 0, p);
 150
 151     if (rv != APR_SUCCESS) {
 152         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 153                       "proxy: FD: get_socket_from_path::create %d", rv);
 154         return rv;
 155     }
 156
 157     sa.sun_family = AF_UNIX;
 158     apr_cpystrn(sa.sun_path, path, sizeof(sa.sun_path));
 159
 160     rv = socket_connect_un(r, s, &sa);
 161     if (rv != APR_SUCCESS) {
 162         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 163                       "proxy: FD: get_socket_from_path::connect_un %d", rv);
 164         return rv;
 165     }
 166
 167     *out_sock = s;
 168
 169     return APR_SUCCESS;
 170 }
 171
 172 #define ANCIL_FD_BUFFER(n) \
 173     struct { \
 174         struct cmsghdr h; \
 175         int fd[n]; \
 176     }
 177
 178 static apr_status_t send_socket(apr_pool_t *p,
 179                                 apr_socket_t *s,
 180                                 apr_socket_t *outbound,
 181                                 apr_socket_t *ctrlsock)
 182 {
 183     apr_status_t rv;
 184     apr_os_sock_t rawsock;
 185     apr_os_sock_t srawsock;
 186     apr_os_sock_t sctrlsock;
 187     struct msghdr msg;
 188     struct cmsghdr *cmsg;
 189     struct iovec iov;
 190     char b = '\0', *buf;
 191     ANCIL_FD_BUFFER(2) ancil_buf;
 192
 193 #if ALTOUT_DEBUG > 1
 194     {
 195         int mop_fd;
 196         char mop_bf[512];
 197
 198         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 199         sprintf(mop_bf, "send_socket: start\n");
 200         write(mop_fd, mop_bf, strlen(mop_bf));
 201         close(mop_fd);
 202     }
 203 #endif
 204
 205     rv = apr_os_sock_get(&rawsock, outbound);
 206     if (rv != APR_SUCCESS) {
 207         return rv;
 208     }
 209
 210     rv = apr_os_sock_get(&srawsock, s);
 211     if (rv != APR_SUCCESS) {
 212         return rv;
 213     }
 214
 215     rv = apr_os_sock_get(&sctrlsock, ctrlsock);
 216     if (rv != APR_SUCCESS) {
 217         return rv;
 218     }
 219
 220 #if ALTOUT_DEBUG > 1
 221     {
 222         int mop_fd;
 223         char mop_bf[512];
 224
 225         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 226         write(mop_fd, "XX", 2);
 227         write(mop_fd, &srawsock, sizeof(apr_os_sock_t));
 228         write(mop_fd, "XX", 2);
 229         close(mop_fd);
 230     }
 231 #endif
 232
 233     memset(&msg, 0, sizeof(msg));
 234
 235     msg.msg_iov = &iov;
 236     msg.msg_iovlen = 1;
 237
 238     iov.iov_base = &b;
 239     iov.iov_len = 1;
 240
 241     msg.msg_control = &ancil_buf;
 242     msg.msg_controllen = sizeof(struct cmsghdr) + sizeof(rawsock) * 2;
 243
 244     // cmsg = apr_palloc(p, sizeof(*cmsg) + sizeof(rawsock));
 245     cmsg = CMSG_FIRSTHDR(&msg);
 246     cmsg->cmsg_len = sizeof(*cmsg) + sizeof(rawsock) * 2;
 247     cmsg->cmsg_level = SOL_SOCKET;
 248     cmsg->cmsg_type = SCM_RIGHTS;
 249
 250     ((int *)CMSG_DATA(cmsg))[0] = rawsock;
 251     ((int *)CMSG_DATA(cmsg))[1] = sctrlsock;
 252
 253     rv = sendmsg(srawsock, &msg, 0);
 254
 255 #if ALTOUT_DEBUG > 1
 256     {
 257         int mop_fd;
 258         char mop_bf[512];
 259
 260         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 261         sprintf(mop_bf, "SENT BYTES: %d\n", rv);
 262         write(mop_fd, mop_bf, strlen(mop_bf));
 263         close(mop_fd);
 264     }
 265
 266     if (rv == -1) {
 267         return errno;
 268     }
 269
 270     return APR_SUCCESS;
 271 }
 272
 273 static int headers_builder(void *rec, const char *key, const char *value)
 274 {
 275     char *s;
 276
 277     s = (char *)rec;
 278
 279 #if ALTOUT_DEBUG > 1
 280     {
 281         int mop_fd;
 282         char mop_bf[512];
 283
 284         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 285         sprintf(mop_bf, "HEADERS_BUILDER: [%s:%s]\n", key, value);
 286         write(mop_fd, mop_bf, strlen(mop_bf));
 287         close(mop_fd);
 288     }
 289
 290     // TODO: verify length
 291     // sprintf(s, "%s%s:%s\n", s, key, value);
 292     strcat(s, key);
 293     strcat(s, ":");
 294     strcat(s, value);
 295     strcat(s, "\n");
 296 }
 297
 298 #define CTRL_BUFF_MAX_SZ (8*1024)
 299
 300 #define DEFAULT_ENCTYPE "application/x-www-form-urlencoded"
 301
 302 int util_read(request_rec *r, const char **rbuf)
 303 {
 304     int rc;
 305
 306     if ((rc = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR)) != OK) {
 307         return rc;
 308     }
 309
 310     if (ap_should_client_block(r)) {
 311         char argsbuffer[HUGE_STRING_LEN];
 312         int rsize, len_read, rpos=0;
 313         long length = r->remaining;
 314         *rbuf = (char *)apr_pcalloc(r->pool, length +1);
 315         if ((len_read = ap_get_client_block(r, argsbuffer,
 316                                             sizeof(argsbuffer))) > 0) {
 317             if ((rpos + len_read) > length) {
 318                 rsize = length - rpos;
 319             } else {
 320                 rsize = len_read;
 321             }
 322
 323             memcpy((char *)*rbuf + rpos, argsbuffer, rsize);
 324             rpos += rsize;
 325         }
 326
 327     }
 328
 329     return rc;
 330 }
 331
 332 int read_post(request_rec *r, const char **data)
 333 {
 334     const char *type;
 335     char *p, s_type[256];
 336     int rc = OK;
 337
 338     s_type[255] = '\0';
 339 #if ALTOUT_DEBUG > 1
 340     {
 341         int mop_fd;
 342         char mop_bf[512];
 343
 344         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 345         sprintf(mop_bf, "read_post: start: numb: %d %d head_in: [%s]\n", r->method_number, M_POST, apr_table_get(r->headers_in, "Content-Type"));
 346         write(mop_fd, mop_bf, strlen(mop_bf));
 347         close(mop_fd);
 348     }
 349 #endif
 350
 351
 352     if (r->method_number != M_POST) {
 353         return rc;
 354     }
 355
 356     type = apr_table_get(r->headers_in, "Content-Type");
 357     strncpy(s_type, type, 255);
 358     if (p = strchr(s_type, ';')) {
 359         *p = '\0';
 360     }
 361
 362     if (strcasecmp(s_type, DEFAULT_ENCTYPE) != 0) {
 363         return DECLINED;
 364     }
 365
 366     if ((rc = util_read(r, data)) != OK) {
 367         return rc;
 368     }
 369
 370 #if ALTOUT_DEBUG > 1
 371     {
 372         int mop_fd;
 373         char mop_bf[512];
 374
 375         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 376         sprintf(mop_bf, "read_post: finish\n");
 377         write(mop_fd, mop_bf, strlen(mop_bf));
 378         close(mop_fd);
 379     }
 380 #endif
 381
 382     return OK;
 383 }
 384
 385
 386 // TODO: sanitize calloc
 387 static int proxy_fdpass2_handler(request_rec *r, proxy_worker *worker,
 388                               proxy_server_conf *conf,
 389                               char *url, const char *proxyname,
 390                               apr_port_t proxyport)
 391 {
 392     apr_status_t rv;
 393     apr_socket_t *sock;
 394     apr_socket_t *clientsock;
 395     char *buf;
 396     char *headers_out = NULL;
 397     int ctrlrawsock[2];
 398     apr_socket_t *ctrlsock = NULL, *clientctrlsock = NULL;
 399     apr_size_t wrlen;
 400     const char *post_data = NULL;
 401
 402     ap_filter_t *f;
 403     ap_filter_rec_t *fg;
 404
 405     if (strncasecmp(url, "fd://", 5) == 0) {
 406         url += 5;
 407     }
 408     else {
 409         return DECLINED;
 410     }
 411
 412     rv = get_socket_from_path(r, r->pool, url, &sock);
 413
 414 #if ALTOUT_DEBUG > 0
 415     time_t t_cur;
 416     int t_rnd;
 417     t_cur = time();
 418     t_rnd = rand();
 419 #endif
 420
 421 #if ALTOUT_DEBUG > 0
 422     {
 423         int mop_fd;
 424         char mop_bf[512];
 425
 426         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 427         sprintf(mop_bf, "%lld: (%d) proxy_fdpass2_handler: start\n", t_cur, t_rnd);
 428         write(mop_fd, mop_bf, strlen(mop_bf));
 429         close(mop_fd);
 430     }
 431 #endif
 432
 433     if (rv != APR_SUCCESS) {
 434         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 435                       "proxy: FD: Failed to connect to '%s' %d xxx",
 436                       url, rv);
 437         return HTTP_INTERNAL_SERVER_ERROR;
 438     }
 439
 440     fg = ap_get_output_filter_handle("HTTP_HEADER");
 441
 442     /*
 443     ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 444                   "proxy: FD: filter fg: %lx  func %lx", fg, ap_http_header_filter);
 445     */
 446
 447     for (f = r->output_filters ; f != NULL ; f = f->next) {
 448         /* ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 449            "proxy: FD: filter loop: %lx", f->frec);
 450         */
 451         if (f->frec == fg) {
 452             /*
 453             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 454                           "proxy: FD: filter found, remove it");
 455             */
 456             ap_remove_output_filter(f);
 457             break;
 458         }
 459     }
 460
 461     if ((headers_out = calloc(CTRL_BUFF_MAX_SZ, 1)) != NULL) {
 462         sprintf(headers_out, "The-Request:%s\n", r->the_request);
 463         apr_table_do(headers_builder, headers_out, r->headers_in, NULL);
 464     }
 465     read_post(r, &post_data);
 466
 467 #if ALTOUT_DEBUG > 1
 468     {
 469         int mop_fd;
 470         char mop_bf[512];
 471
 472         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 473         sprintf(mop_bf, "proxy_fdpass2_handler: headers\n");
 474         write(mop_fd, mop_bf, strlen(mop_bf));
 475         write(mop_fd, headers_out, strlen(headers_out));
 476         close(mop_fd);
 477     }
 478 #endif
 479
 480     /* create a couple of sockets and pass one to the client for headers and so on */
 481     if (socketpair(AF_UNIX, SOCK_STREAM, 0, ctrlrawsock)) {
 482         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 483                       "proxy: FD: Failed create socketpair");
 484         return HTTP_INTERNAL_SERVER_ERROR;
 485     }
 486     rv = apr_os_sock_put(&ctrlsock, &(ctrlrawsock[0]), r->connection->pool);
 487     if (rv != APR_SUCCESS) {
 488         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 489                       "proxy: FD: apr_os_sock_put failed");
 490         return HTTP_INTERNAL_SERVER_ERROR;
 491     }
 492     rv = apr_os_sock_put(&clientctrlsock, &(ctrlrawsock[1]), r->connection->pool);
 493     if (rv != APR_SUCCESS) {
 494         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 495                       "proxy: FD: apr_os_sock_put failed");
 496         return HTTP_INTERNAL_SERVER_ERROR;
 497     }
 498
 499     {
 500         int status;
 501         /* const char *flush_method = worker->flusher ? worker->flusher : "flush"; */
 502         const char *flush_method = "flush";
 503
 504         proxy_fdpass2_flush *flush = ap_lookup_provider(PROXY_FDPASS_FLUSHER,
 505                                                        flush_method, "0");
 506
 507         if (!flush) {
 508             ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 509                           "proxy: FD: Unable to find configured flush "
 510                           "provider '%s'", flush_method);
 511             return HTTP_INTERNAL_SERVER_ERROR;
 512         }
 513
 514         status = flush->flusher(r);
 515         if (status) {
 516             return status;
 517         }
 518     }
 519
 520     /*
 521     if ((buf = apr_table_get(r->headers_in, "Host"))) {
 522         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 523                       "proxy: FD: Host is: [%s]", buf);
 524     }
 525     */
 526
 527     /* XXXXX: THIS IS AN EVIL HACK */
 528     /* There should really be a (documented) public API for this ! */
 529     clientsock = ap_get_module_config(r->connection->conn_config, &core_module);
 530
 531     rv = send_socket(r->pool, sock, clientsock, clientctrlsock);
 532     if (rv != APR_SUCCESS) {
 533         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 534                       "proxy: FD: send_socket failed:");
 535         return HTTP_INTERNAL_SERVER_ERROR;
 536     }
 537     strcat(headers_out, "\n");
 538     wrlen = strlen(headers_out);
 539     rv = apr_socket_send(ctrlsock, headers_out, &wrlen);
 540
 541 #if ALTOUT_DEBUG > 1
 542     {
 543         int mop_fd;
 544         char mop_bf[512];
 545
 546         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 547         write(mop_fd, "HEADERS_OUT\n", 12);
 548         write(mop_fd, headers_out, wrlen);
 549         close(mop_fd);
 550     }
 551 #endif
 552
 553     if (rv != APR_SUCCESS) {
 554         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 555                       "proxy: FD: send headers failed");
 556         return HTTP_INTERNAL_SERVER_ERROR;
 557     }
 558     if (post_data) {
 559         wrlen = strlen(post_data);
 560         rv = apr_socket_send(ctrlsock, post_data, &wrlen);
 561         if (rv != APR_SUCCESS) {
 562             ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 563                           "proxy: FD: send post failed");
 564             return HTTP_INTERNAL_SERVER_ERROR;
 565         }
 566     }
 567     apr_socket_shutdown(ctrlsock, APR_SHUTDOWN_READWRITE);
 568     if (headers_out)
 569         free(headers_out);
 570
 571     {
 572         apr_socket_t *dummy;
 573         /* Create a dummy unconnected socket, and set it as the one we were
 574          * connected to, so that when the core closes it, it doesn't close
 575          * the tcp connection to the client.
 576          */
 577         rv = apr_socket_create(&dummy, APR_INET, SOCK_STREAM, APR_PROTO_TCP,
 578                                r->connection->pool);
 579         if (rv != APR_SUCCESS) {
 580             ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 581                           "proxy: FD: failed to create dummy socket");
 582             return HTTP_INTERNAL_SERVER_ERROR;
 583         }
 584         ap_set_module_config(r->connection->conn_config, &core_module, dummy);
 585     }
 586
 587 #if ALTOUT_DEBUG > 0
 588     {
 589         int mop_fd;
 590         char mop_bf[512];
 591
 592         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 593         sprintf(mop_bf, "%lld: (%d) proxy_fdpass2_handler: end\n", t_cur, t_rnd);
 594         write(mop_fd, mop_bf, strlen(mop_bf));
 595         close(mop_fd);
 596     }
 597 #endif
 598
 599     return OK;
 600 }
 601
 602 static int standard_flush(request_rec *r)
 603 {
 604     int status;
 605     apr_bucket_brigade *bb;
 606     apr_bucket *e;
 607     apr_pool_t *p = r->pool;
 608
 609     r->connection->keepalive = AP_CONN_CLOSE;
 610     /* MOP NOTE: set here the content type */
 611     // ap_set_content_type(r, apr_pstrdup(p, NO_CONTENT_TYPE));
 612     bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
 613     e = apr_bucket_flush_create(r->connection->bucket_alloc);
 614
 615     APR_BRIGADE_INSERT_TAIL(bb, e);
 616
 617     status = ap_pass_brigade(r->output_filters, bb);
 618
 619     if (status != OK) {
 620         ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r,
 621                       "proxy: FD: ap_pass_brigade failed:");
 622         return status;
 623     }
 624
 625     return OK;
 626 }
 627
 628 static const proxy_fdpass2_flush builtin_flush =
 629 {
 630     "flush",
 631     &standard_flush,
 632     NULL
 633 };
 634
 635 static void ap_proxy_fdpass2_register_hooks(apr_pool_t *p)
 636 {
 637     ap_register_provider(p, PROXY_FDPASS_FLUSHER, "flush", "0", &builtin_flush);
 638     proxy_hook_scheme_handler(proxy_fdpass2_handler, NULL, NULL, APR_HOOK_FIRST);
 639     proxy_hook_canon_handler(proxy_fdpass2_canon, NULL, NULL, APR_HOOK_FIRST);
 640 }
 641
 642 module AP_MODULE_DECLARE_DATA proxy_fdpass2_module = {
 643     STANDARD20_MODULE_STUFF,
 644     NULL,              /* create per-directory config structure */
 645     NULL,              /* merge per-directory config structures */
 646     NULL,              /* create per-server config structure */
 647     NULL,              /* merge per-server config structures */
 648     NULL,              /* command apr_table_t */
 649     ap_proxy_fdpass2_register_hooks                /* register hooks */
 650 };