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(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_error(APLOG_MARK, APLOG_ERR, rv, NULL,
  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_error(APLOG_MARK, APLOG_ERR, rv, NULL,
  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_error(APLOG_MARK, APLOG_ERR, rv, NULL,
 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(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_error(APLOG_MARK, APLOG_ERR, rv, NULL,
 143                  "proxy: FD: Failed to connect to '%s' %d xxx",
 144                       url, rv);
 145     ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
 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_error(APLOG_MARK, APLOG_ERR, rv, NULL,
 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(s, &sa);
 161     if (rv != APR_SUCCESS) {
 162         ap_log_error(APLOG_MARK, APLOG_ERR, rv, NULL,
 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 #endif
 266
 267     if (rv == -1) {
 268         return errno;
 269     }
 270
 271     return APR_SUCCESS;
 272 }
 273
 274 static int headers_builder(void *rec, const char *key, const char *value)
 275 {
 276     char *s;
 277
 278     s = (char *)rec;
 279
 280 #if ALTOUT_DEBUG > 1
 281     {
 282         int mop_fd;
 283         char mop_bf[512];
 284
 285         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 286         sprintf(mop_bf, "HEADERS_BUILDER: [%s:%s]\n", key, value);
 287         write(mop_fd, mop_bf, strlen(mop_bf));
 288         close(mop_fd);
 289     }
 290 #endif
 291
 292     // TODO: verify length
 293     // sprintf(s, "%s%s:%s\n", s, key, value);
 294     strcat(s, key);
 295     strcat(s, ":");
 296     strcat(s, value);
 297     strcat(s, "\n");
 298 }
 299
 300 #define CTRL_BUFF_MAX_SZ (8*1024)
 301
 302 #define DEFAULT_ENCTYPE "application/x-www-form-urlencoded"
 303
 304 int util_read(request_rec *r, const char **rbuf)
 305 {
 306     int rc;
 307
 308     if ((rc = ap_setup_client_block(r, REQUEST_CHUNKED_ERROR)) != OK) {
 309         return rc;
 310     }
 311
 312     if (ap_should_client_block(r)) {
 313         char argsbuffer[HUGE_STRING_LEN];
 314         int rsize, len_read, rpos=0;
 315         long length = r->remaining;
 316         *rbuf = (char *)apr_pcalloc(r->pool, length +1);
 317         if ((len_read = ap_get_client_block(r, argsbuffer,
 318                                             sizeof(argsbuffer))) > 0) {
 319             if ((rpos + len_read) > length) {
 320                 rsize = length - rpos;
 321             } else {
 322                 rsize = len_read;
 323             }
 324
 325             memcpy((char *)*rbuf + rpos, argsbuffer, rsize);
 326             rpos += rsize;
 327         }
 328
 329     }
 330
 331     return rc;
 332 }
 333
 334 int read_post(request_rec *r, const char **data)
 335 {
 336     const char *type;
 337     char *p, s_type[256];
 338     int rc = OK;
 339
 340     s_type[255] = '\0';
 341 #if ALTOUT_DEBUG > 1
 342     {
 343         int mop_fd;
 344         char mop_bf[512];
 345
 346         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 347         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"));
 348         write(mop_fd, mop_bf, strlen(mop_bf));
 349         close(mop_fd);
 350     }
 351 #endif
 352
 353
 354     if (r->method_number != M_POST) {
 355         return rc;
 356     }
 357
 358     type = apr_table_get(r->headers_in, "Content-Type");
 359     strncpy(s_type, type, 255);
 360     if (p = strchr(s_type, ';')) {
 361         *p = '\0';
 362     }
 363
 364     if (strcasecmp(s_type, DEFAULT_ENCTYPE) != 0) {
 365         return DECLINED;
 366     }
 367
 368     if ((rc = util_read(r, data)) != OK) {
 369         return rc;
 370     }
 371
 372 #if ALTOUT_DEBUG > 1
 373     {
 374         int mop_fd;
 375         char mop_bf[512];
 376
 377         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 378         sprintf(mop_bf, "read_post: finish\n");
 379         write(mop_fd, mop_bf, strlen(mop_bf));
 380         close(mop_fd);
 381     }
 382 #endif
 383
 384     return OK;
 385 }
 386
 387
 388 // TODO: sanitize calloc
 389 static int proxy_fdpass2_handler(request_rec *r, proxy_worker *worker,
 390                               proxy_server_conf *conf,
 391                               char *url, const char *proxyname,
 392                               apr_port_t proxyport)
 393 {
 394     apr_status_t rv;
 395     apr_socket_t *sock;
 396     apr_socket_t *clientsock;
 397     char *buf;
 398     char *headers_out = NULL;
 399     int ctrlrawsock[2];
 400     apr_socket_t *ctrlsock = NULL, *clientctrlsock = NULL;
 401     apr_size_t wrlen;
 402     const char *post_data = NULL;
 403
 404     ap_filter_t *f;
 405     ap_filter_rec_t *fg;
 406
 407     if (strncasecmp(url, "fd://", 5) == 0) {
 408         url += 5;
 409     }
 410     else {
 411         return DECLINED;
 412     }
 413
 414     rv = get_socket_from_path(r->pool, url, &sock);
 415
 416 #if ALTOUT_DEBUG > 0
 417     long long t_cur;
 418     int t_rnd;
 419     t_cur = (long long)time(NULL);
 420     t_rnd = rand();
 421 #endif
 422
 423 #if ALTOUT_DEBUG > 0
 424     {
 425         int mop_fd;
 426         char mop_bf[512];
 427
 428         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 429         sprintf(mop_bf, "%lld: (%d) proxy_fdpass2_handler: start\n", t_cur, t_rnd);
 430         write(mop_fd, mop_bf, strlen(mop_bf));
 431         close(mop_fd);
 432     }
 433 #endif
 434
 435     if (rv != APR_SUCCESS) {
 436         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 437                       "proxy: FD: Failed to connect to '%s' %d xxx",
 438                       url, rv);
 439         return HTTP_INTERNAL_SERVER_ERROR;
 440     }
 441
 442     fg = ap_get_output_filter_handle("HTTP_HEADER");
 443
 444     /*
 445     ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 446                   "proxy: FD: filter fg: %lx  func %lx", fg, ap_http_header_filter);
 447     */
 448
 449     for (f = r->output_filters ; f != NULL ; f = f->next) {
 450         /* ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 451            "proxy: FD: filter loop: %lx", f->frec);
 452         */
 453         if (f->frec == fg) {
 454             /*
 455             ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r,
 456                           "proxy: FD: filter found, remove it");
 457             */
 458             ap_remove_output_filter(f);
 459             break;
 460         }
 461     }
 462
 463     if ((headers_out = calloc(CTRL_BUFF_MAX_SZ, 1)) != NULL) {
 464         sprintf(headers_out, "The-Request:%s\n", r->the_request);
 465         apr_table_do(headers_builder, headers_out, r->headers_in, NULL);
 466     }
 467     read_post(r, &post_data);
 468
 469 #if ALTOUT_DEBUG > 1
 470     {
 471         int mop_fd;
 472         char mop_bf[512];
 473
 474         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 475         sprintf(mop_bf, "proxy_fdpass2_handler: headers\n");
 476         write(mop_fd, mop_bf, strlen(mop_bf));
 477         write(mop_fd, headers_out, strlen(headers_out));
 478         close(mop_fd);
 479     }
 480 #endif
 481
 482     /* create a couple of sockets and pass one to the client for headers and so on */
 483     if (socketpair(AF_UNIX, SOCK_STREAM, 0, ctrlrawsock)) {
 484         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 485                       "proxy: FD: Failed create socketpair");
 486         return HTTP_INTERNAL_SERVER_ERROR;
 487     }
 488     rv = apr_os_sock_put(&ctrlsock, &(ctrlrawsock[0]), r->connection->pool);
 489     if (rv != APR_SUCCESS) {
 490         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01152)
 491                       "proxy: FD: apr_os_sock_put failed");
 492         return HTTP_INTERNAL_SERVER_ERROR;
 493     }
 494     rv = apr_os_sock_put(&clientctrlsock, &(ctrlrawsock[1]), r->connection->pool);
 495     if (rv != APR_SUCCESS) {
 496         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01152)
 497                       "proxy: FD: apr_os_sock_put failed");
 498         return HTTP_INTERNAL_SERVER_ERROR;
 499     }
 500
 501     {
 502         int status;
 503         /* const char *flush_method = worker->s->flusher ? worker->s->flusher : "flush"; */
 504         const char *flush_method = "flush";
 505
 506         proxy_fdpass2_flush *flush = ap_lookup_provider(PROXY_FDPASS_FLUSHER,
 507                                                         flush_method, "0");
 508
 509         if (!flush) {
 510             ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01153)
 511                           "proxy: FD: Unable to find configured flush "
 512                           "provider '%s'", flush_method);
 513             return HTTP_INTERNAL_SERVER_ERROR;
 514         }
 515
 516         status = flush->flusher(r);
 517         if (status) {
 518             return status;
 519         }
 520     }
 521
 522     /*
 523     if ((buf = apr_table_get(r->headers_in, "Host"))) {
 524         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 525                       "proxy: FD: Host is: [%s]", buf);
 526     }
 527     */
 528
 529     /* XXXXX: THIS IS AN EVIL HACK */
 530     /* There should really be a (documented) public API for this ! */
 531     /* oldmop clientsock = ap_get_module_config(r->connection->conn_config, &core_module); */
 532     clientsock = ap_get_core_module_config(r->connection->conn_config);
 533
 534
 535     rv = send_socket(r->pool, sock, clientsock, clientctrlsock);
 536     if (rv != APR_SUCCESS) {
 537         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01154)
 538                       "proxy: FD: send_socket failed:");
 539         return HTTP_INTERNAL_SERVER_ERROR;
 540     }
 541     strcat(headers_out, "\n");
 542     wrlen = strlen(headers_out);
 543     rv = apr_socket_send(ctrlsock, headers_out, &wrlen);
 544
 545 #if ALTOUT_DEBUG > 1
 546     {
 547         int mop_fd;
 548         char mop_bf[512];
 549
 550         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 551         write(mop_fd, "HEADERS_OUT\n", 12);
 552         write(mop_fd, headers_out, wrlen);
 553         close(mop_fd);
 554     }
 555 #endif
 556
 557     if (rv != APR_SUCCESS) {
 558         ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 559                       "proxy: FD: send headers failed");
 560         return HTTP_INTERNAL_SERVER_ERROR;
 561     }
 562     if (post_data) {
 563         wrlen = strlen(post_data);
 564         rv = apr_socket_send(ctrlsock, post_data, &wrlen);
 565         if (rv != APR_SUCCESS) {
 566             ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r,
 567                           "proxy: FD: send post failed");
 568             return HTTP_INTERNAL_SERVER_ERROR;
 569         }
 570     }
 571     apr_socket_shutdown(ctrlsock, APR_SHUTDOWN_READWRITE);
 572     if (headers_out) {
 573         free(headers_out);
 574     }
 575
 576     {
 577         apr_socket_t *dummy;
 578         /* Create a dummy unconnected socket, and set it as the one we were
 579          * connected to, so that when the core closes it, it doesn't close
 580          * the tcp connection to the client.
 581          */
 582         rv = apr_socket_create(&dummy, APR_INET, SOCK_STREAM, APR_PROTO_TCP,
 583                                r->connection->pool);
 584         if (rv != APR_SUCCESS) {
 585             ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01155)
 586                           "proxy: FD: failed to create dummy socket");
 587             return HTTP_INTERNAL_SERVER_ERROR;
 588         }
 589         ap_set_core_module_config(r->connection->conn_config, dummy);
 590     }
 591
 592 #if ALTOUT_DEBUG > 0
 593     {
 594         int mop_fd;
 595         char mop_bf[512];
 596
 597         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 598         sprintf(mop_bf, "%lld: (%d) proxy_fdpass2_handler: end\n", t_cur, t_rnd);
 599         write(mop_fd, mop_bf, strlen(mop_bf));
 600         close(mop_fd);
 601     }
 602 #endif
 603     /* close socket pair before end proxy */
 604     close(ctrlrawsock[0]);
 605     close(ctrlrawsock[1]);
 606
 607     return OK;
 608 }
 609
 610 static int standard_flush(request_rec *r)
 611 {
 612     int status;
 613     apr_bucket_brigade *bb;
 614     apr_bucket *e;
 615     apr_pool_t *p = r->pool;
 616
 617     r->connection->keepalive = AP_CONN_CLOSE;
 618     /* MOP NOTE: set here the content type */
 619     // ap_set_content_type(r, apr_pstrdup(p, NO_CONTENT_TYPE));
 620     bb = apr_brigade_create(r->pool, r->connection->bucket_alloc);
 621     e = apr_bucket_flush_create(r->connection->bucket_alloc);
 622
 623     APR_BRIGADE_INSERT_TAIL(bb, e);
 624
 625     status = ap_pass_brigade(r->output_filters, bb);
 626
 627     if (status != OK) {
 628         ap_log_rerror(APLOG_MARK, APLOG_ERR, status, r, APLOGNO(01156)
 629                       "proxy: FD: ap_pass_brigade failed:");
 630         return status;
 631     }
 632
 633 #if ALTOUT_DEBUG > 0
 634     long long t_cur;
 635     int t_rnd;
 636     t_cur = (long long)time(NULL);
 637     t_rnd = rand();
 638 #endif
 639
 640 #if ALTOUT_DEBUG > 0
 641     {
 642         int mop_fd;
 643         char mop_bf[512];
 644
 645         mop_fd = open(ALTOUT_DBG_FILE, O_WRONLY | O_APPEND | O_CREAT, 0644);
 646         sprintf(mop_bf, "%lld: (%d) proxy_fdpass2_handler: flusher\n", t_cur, t_rnd);
 647         write(mop_fd, mop_bf, strlen(mop_bf));
 648         close(mop_fd);
 649     }
 650 #endif
 651
 652     return OK;
 653 }
 654
 655 static const proxy_fdpass2_flush builtin_flush =
 656 {
 657     "flush",
 658     &standard_flush,
 659     NULL
 660 };
 661
 662 static void ap_proxy_fdpass2_register_hooks(apr_pool_t *p)
 663 {
 664     ap_register_provider(p, PROXY_FDPASS_FLUSHER, "flush", "0", &builtin_flush);
 665     proxy_hook_scheme_handler(proxy_fdpass2_handler, NULL, NULL, APR_HOOK_FIRST);
 666     proxy_hook_canon_handler(proxy_fdpass2_canon, NULL, NULL, APR_HOOK_FIRST);
 667 }
 668
 669 module AP_MODULE_DECLARE_DATA proxy_fdpass2_module = {
 670     STANDARD20_MODULE_STUFF,
 671     NULL,              /* create per-directory config structure */
 672     NULL,              /* merge per-directory config structures */
 673     NULL,              /* create per-server config structure */
 674     NULL,              /* merge per-server config structures */
 675     NULL,              /* command apr_table_t */
 676     ap_proxy_fdpass2_register_hooks                /* register hooks */
 677 };