httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@locus.apache.org
Subject cvs commit: apache-2.0/src/lib/apr/buckets ryan.patch
Date Mon, 31 Jul 2000 23:30:05 GMT
rbb         00/07/31 16:30:05

  Modified:    src/lib/apr/buckets ryan.patch
  Log:
  Update the bucket brigade patch to work with the latest code.  This is
  a much smaller patch than previous ones IMO.  It also contains a lot of
  comments to help explain what is happening.  This patch works with all
  legacy modules, as well as newer modules.  I have removed the chunking
  filter with the understanding that it was mucking up the patch, and making
  things hard to follow.  After we decide on a filter design, adding chunking
  back in should be easy to do.
  
  Revision  Changes    Path
  1.7       +306 -220  apache-2.0/src/lib/apr/buckets/ryan.patch
  
  Index: ryan.patch
  ===================================================================
  RCS file: /home/cvs/apache-2.0/src/lib/apr/buckets/ryan.patch,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- ryan.patch	2000/07/20 21:24:39	1.6
  +++ ryan.patch	2000/07/31 23:30:04	1.7
  @@ -1,14 +1,10 @@
  -? include/util_filter.h
  -? lib/apr/buckets/Makefile.in
  -? lib/apr/include/apr_buf.h
  -? main/util_filter.c
   Index: ap/Makefile.in
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/ap/Makefile.in,v
   retrieving revision 1.4
   diff -u -d -b -w -u -r1.4 Makefile.in
   --- ap/Makefile.in	2000/06/12 20:41:13	1.4
  -+++ ap/Makefile.in	2000/07/20 21:16:23
  ++++ ap/Makefile.in	2000/07/31 23:24:38
   @@ -1,5 +1,5 @@
    
    LTLIBRARY_NAME    = libap.la
  @@ -19,30 +15,45 @@
   Index: include/ap_iol.h
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/include/ap_iol.h,v
  -retrieving revision 1.19
  -diff -u -d -b -w -u -r1.19 ap_iol.h
  ---- include/ap_iol.h	2000/05/29 04:22:02	1.19
  -+++ include/ap_iol.h	2000/07/20 21:16:23
  -@@ -58,6 +58,7 @@
  +retrieving revision 1.21
  +diff -u -d -b -w -u -r1.21 ap_iol.h
  +--- include/ap_iol.h	2000/07/29 17:43:01	1.21
  ++++ include/ap_iol.h	2000/07/31 23:24:40
  +@@ -58,7 +58,9 @@
    #define AP_IOL_H
    
    #include "apr_general.h" /* For ap_s?size_t */
   +#include "apr_network_io.h" /* For ap_hdtr_t */
    #include "apr_errno.h" /* For ap_status_t and the APR_errnos */
  ++#include "ap_config.h" /* For ap_status_t and the APR_errnos */
    
    typedef struct ap_iol ap_iol;
  + typedef struct ap_iol_methods ap_iol_methods;
   Index: include/http_protocol.h
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/include/http_protocol.h,v
   retrieving revision 1.19
   diff -u -d -b -w -u -r1.19 http_protocol.h
   --- include/http_protocol.h	2000/07/11 03:48:17	1.19
  -+++ include/http_protocol.h	2000/07/20 21:16:23
  -@@ -89,7 +89,7 @@
  ++++ include/http_protocol.h	2000/07/31 23:24:40
  +@@ -88,8 +88,19 @@
  +  */
    API_EXPORT(void) ap_basic_http_header(request_rec *r);
    
  - /* Send the Status-Line and header fields for HTTP response */
  +-/* Send the Status-Line and header fields for HTTP response */
   -
  ++/* Send the Status-Line and header fields for HTTP response.  Two functions
  ++ * are needed here because we are doing two very different things.  1)  We
  ++ * setup the response based on the header values.  For example, se setup
  ++ * chunking based on the values in the headers.  This is done in
  ++ * ap_send_http_header.  A slightly incorrect name, but it is the name from
  ++ * 1.3, so this means modules don't need to change as much.  2)  Actually
  ++ * send the headers over the wire.  Currently this is done in
  ++ * ap_send_http_header_real.  This should most likely be changed to just
  ++ * create a bucket that contains the headers.  In this way, the headers are
  ++ * treated just like regular data, and we avoid BUFF all together.  That however
  ++ * is an enhancement that can be made after the core filtering is in place.
  ++ */
   +API_EXPORT(void) ap_send_http_header_real(request_rec *l);
    API_EXPORT(void) ap_send_http_header(request_rec *l);
    
  @@ -50,15 +61,14 @@
   Index: include/httpd.h
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/include/httpd.h,v
  -retrieving revision 1.64
  -diff -u -d -b -w -u -r1.64 httpd.h
  ---- include/httpd.h	2000/06/30 21:18:13	1.64
  -+++ include/httpd.h	2000/07/20 21:16:23
  -@@ -596,6 +596,11 @@
  +retrieving revision 1.66
  +diff -u -d -b -w -u -r1.66 httpd.h
  +--- include/httpd.h	2000/07/29 19:50:07	1.66
  ++++ include/httpd.h	2000/07/31 23:24:41
  +@@ -589,6 +589,10 @@
    				 * pointer back to the main request.
    				 */
    
  -+    ap_array_header_t *filters; /* The array of filters to call */
   +    int headers_sent;           /* Have we sent the headers for this request
   +                                 * yet.
   +                                 */
  @@ -66,48 +76,121 @@
        /* Info about the request itself... we begin with stuff that only
         * protocol.c should ever touch...
         */
  +Index: include/util_filter.h
  +===================================================================
  +RCS file: /home/cvs/apache-2.0/src/include/util_filter.h,v
  +retrieving revision 1.1
  +diff -u -d -b -w -u -r1.1 util_filter.h
  +--- include/util_filter.h	2000/07/28 20:30:53	1.1
  ++++ include/util_filter.h	2000/07/31 23:24:41
  +@@ -65,6 +65,7 @@
  + 
  + #include "httpd.h"
  + #include "apr.h"
  ++#include "apr_buf.h"
  + 
  + /*
  +  * FILTER CHAIN
  +@@ -114,7 +115,7 @@
  +  * next/prev to insert/remove/replace elements in the bucket list, but
  +  * the types and values of the individual buckets should not be altered.
  +  */
  +-typedef ap_status_t (*ap_filter_func)();
  ++typedef ap_status_t (*ap_filter_func)(request_rec *r, ap_filter_t *f, ap_bucket_brigade
*b);
  + 
  + /*
  +  * ap_filter_type:
  +@@ -166,8 +167,22 @@
  + 
  +     ap_filter_type ftype;
  +     ap_filter_t *next;
  ++    ap_filter_t *prev;
  + };
  + 
  ++/* This function just passes the current bucket brigade down to the next
  ++ * filter on the filter stack.  When a filter actually writes to the network
  ++ * (usually either core or SSL), that filter should return the number of bytes
  ++ * actually written and it will get propogated back up to the handler.  If
  ++ * nobody writes the data to the network, then this function will most likely
  ++ * seg fault.  I haven't come up with a good way to detect that case yet, and
  ++ * it should never happen.  Regardless, it's an unrecoverable error for the
  ++ * current request.  I would just rather it didn't take out the whole child
  ++ * process.  
  ++ */
  ++API_EXPORT(int) ap_pass_brigade(request_rec *r, ap_filter_t *filter,
  ++                                 ap_bucket_brigade *bucket);
  ++
  + /*
  +  * ap_register_filter():
  +  *
  +@@ -192,9 +207,28 @@
  +  * calls to ap_add_filter). If the current filter chain contains filters
  +  * from another request, then this filter will be added before those other
  +  * filters.
  ++ * 
  ++ * To re-iterate that last comment.  This function is building a FIFO
  ++ * list of filters.  Take note of that when adding your filter to the chain.
  +  */
  + API_EXPORT(void) ap_add_filter(const char *name, void *ctx, request_rec *r);
  + 
  ++/* The next two filters are for abstraction purposes only.  They could be
  ++ * done away with, but that would require that we break modules if we ever
  ++ * want to change our filter registration method.  The basic idea, is that
  ++ * all filters have a place to store data, the ctx pointer.  These functions
  ++ * fill out that pointer with a bucket brigade, and retrieve that data on
  ++ * the next call.  The nice thing about these functions, is that they
  ++ * automatically concatenate the bucket brigades together for you.  This means
  ++ * that if you have already stored a brigade in the filters ctx pointer, then
  ++ * when you add more it will be tacked onto the end of that brigade.  When
  ++ * you retrieve data, if you pass in a bucket brigade to the get function,
  ++ * it will append the current brigade onto the one that you are retrieving.
  ++ */ 
  ++API_EXPORT(ap_bucket_brigade *) ap_get_saved_data(request_rec *r, 
  ++                                   ap_filter_t *f, ap_bucket_brigade **b);
  ++API_EXPORT(void) ap_save_data_to_filter(request_rec *r, ap_filter_t *f,
  ++                                   ap_bucket_brigade **b);    
  + 
  + /*
  +  * Things to do later:
  +@@ -206,12 +240,6 @@
  +  *      bucket_brigade, but I am trying to keep this patch neutral.  (If this
  +  *      comment breaks that, well sorry, but the information must be there
  +  *      somewhere.  :-)
  +- *
  +- * Add a function like ap_pass_data.  This function will basically just
  +- * call the next filter in the chain, until the current filter is NULL.  If the
  +- * current filter is NULL, that means that nobody wrote to the network, and
  +- * we have a HUGE bug, so we need to return an error and log it to the 
  +- * log file.
  +  */
  + #ifdef __cplusplus
  + }
   Index: lib/apr/configure.in
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/lib/apr/configure.in,v
  -retrieving revision 1.136
  -diff -u -d -b -w -u -r1.136 configure.in
  ---- lib/apr/configure.in	2000/07/15 15:39:05	1.136
  -+++ lib/apr/configure.in	2000/07/20 21:16:24
  -@@ -682,8 +682,8 @@
  +retrieving revision 1.142
  +diff -u -d -b -w -u -r1.142 configure.in
  +--- lib/apr/configure.in	2000/07/30 12:01:53	1.142
  ++++ lib/apr/configure.in	2000/07/31 23:24:42
  +@@ -688,8 +688,8 @@
    AC_SUBST(EXEEXT)
    
    echo "Construct Makefiles and header files."
  --MAKEFILE1="Makefile lib/Makefile "
  --SUBDIRS="lib "
  -+MAKEFILE1="Makefile lib/Makefile buckets/Makefile"
  -+SUBDIRS="lib buckets"
  +-MAKEFILE1="Makefile lib/Makefile strings/Makefile passwd/Makefile tables/Makefile"
  +-SUBDIRS="lib strings passwd tables "
  ++MAKEFILE1="Makefile lib/Makefile strings/Makefile passwd/Makefile tables/Makefile buckets/Makefile"
  ++SUBDIRS="lib strings passwd tables buckets "
    for dir in $MODULES
    do
        test -d $dir || $MKDIR -p $dir
  -Index: main/Makefile.in
  -===================================================================
  -RCS file: /home/cvs/apache-2.0/src/main/Makefile.in,v
  -retrieving revision 1.16
  -diff -u -d -b -w -u -r1.16 Makefile.in
  ---- main/Makefile.in	2000/07/01 14:14:15	1.16
  -+++ main/Makefile.in	2000/07/20 21:16:29
  -@@ -8,7 +8,7 @@
  - 	http_protocol.c http_request.c http_vhost.c util.c util_date.c \
  - 	util_script.c util_uri.c util_md5.c util_cfgtree.c util_ebcdic.c \
  - 	rfc1413.c http_connection.c iol_file.c iol_socket.c listen.c \
  --        mpm_common.c util_charset.c util_debug.c util_xml.c
  -+        mpm_common.c util_charset.c util_debug.c util_xml.c util_filter.c
  - 
  - include $(top_srcdir)/build/ltlib.mk
  - 
   Index: main/http_core.c
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/main/http_core.c,v
  -retrieving revision 1.88
  -diff -u -d -b -w -u -r1.88 http_core.c
  ---- main/http_core.c	2000/07/11 03:48:18	1.88
  -+++ main/http_core.c	2000/07/20 21:16:29
  -@@ -71,6 +71,8 @@
  +retrieving revision 1.93
  +diff -u -d -b -w -u -r1.93 http_core.c
  +--- main/http_core.c	2000/07/29 19:50:08	1.93
  ++++ main/http_core.c	2000/07/31 23:24:56
  +@@ -72,6 +72,8 @@
    #include "util_md5.h"
    #include "apr_fnmatch.h"
    #include "http_connection.h"
  @@ -116,7 +199,7 @@
    #include "util_ebcdic.h"
    #include "mpm.h"
    #ifdef HAVE_NETDB_H
  -@@ -86,6 +88,10 @@
  +@@ -87,6 +89,10 @@
    #include <strings.h>
    #endif
    
  @@ -127,34 +210,10 @@
    /* Allow Apache to use ap_mmap */
    #ifdef USE_MMAP_FILES
    #include "apr_mmap.h"
  -@@ -2872,6 +2878,76 @@
  +@@ -2880,6 +2886,52 @@
        return OK;
    }
    
  -+/* This is an incredibly stupid chunking filter.  This will need to be somewhat
  -+ * smart about when it actually sends the data, but this implements some sort
  -+ * of chunking for right now.
  -+ */
  -+static int chunk_filter(request_rec *r, ap_filter_t *f, ap_bucket_brigade *b)
  -+{
  -+    ap_bucket *dptr = b->head;
  -+    ap_bucket_brigade *c = ap_bucket_brigade_create(r->pool);
  -+    int len = 0;
  -+
  -+    while (dptr) { 
  -+        len += ap_get_bucket_len(dptr);
  -+        dptr = dptr->next;
  -+    }
  -+     
  -+    ap_brigade_printf(c, "%x\r\n", len);
  -+    ap_bucket_brigade_catenate(c, b);
  -+    dptr = ap_bucket_rwmem_create();
  -+    dptr->insert(dptr, "\r\n", 2, &len);
  -+    ap_bucket_brigade_append_buckets(c, dptr);
  -+
  -+    return ap_pass_brigade(r, f, c);
  -+}
  -+
   +/* Default filter.  This filter should almost always be used.  It's only job
   + * is to send the headers if they haven't already been sent, and then send
   + * the actual data.  To send the data, we create an iovec out of the bucket
  @@ -192,11 +251,11 @@
   +        dptr = dptr->next;
   +    }
   +    if (len < MIN_SIZE_TO_WRITE && b->tail->color != AP_BUCKET_eos) {
  -+        ap_save_data_to_filter(r, f, b);
  ++        ap_save_data_to_filter(r, f, &b);
   +        return 0;
   +    } 
   +    else {
  -+        ap_bucket_brigade_to_iol(&bytes_sent, b, r->connection->client->iol);
  ++        ap_brigade_to_iol(&bytes_sent, b, r->connection->client->iol);
   +        return bytes_sent;
   +    }
   +}
  @@ -204,37 +263,40 @@
    static const handler_rec core_handlers[] = {
    { "*/*", default_handler },
    { "default-handler", default_handler },
  -@@ -2894,6 +2970,14 @@
  +@@ -2902,6 +2954,11 @@
    static unsigned short core_port(const request_rec *r)
        { return DEFAULT_HTTP_PORT; }
    
   +static void core_register_filter(request_rec *r)
   +{
  -+    if (r->chunked) {
  -+        ap_hook_filter(chunk_filter, r, NULL, NULL, AP_HOOK_TRANSPORT);
  -+    }
  -+    ap_hook_filter(core_filter, r, NULL, NULL, AP_HOOK_TRANSPORT_LAST);
  ++    ap_add_filter("CORE", NULL, r);
   +}
   +
    static void register_hooks(void)
    {
        ap_hook_post_config(core_post_config,NULL,NULL,AP_HOOK_REALLY_FIRST);
  -@@ -2906,6 +2990,8 @@
  +@@ -2914,6 +2971,14 @@
        /* FIXME: I suspect we can eliminate the need for these - Ben */
        ap_hook_type_checker(do_nothing,NULL,NULL,AP_HOOK_REALLY_LAST);
        ap_hook_access_checker(do_nothing,NULL,NULL,AP_HOOK_REALLY_LAST);
   +
  ++    /* This is kind of odd, and it would be cool to clean it up a bit.
  ++     * The first function just registers the core's register_filter hook.
  ++     * The other associates a global name with the filter defined
  ++     * by the core module.
  ++     */
   +    ap_hook_insert_filter(core_register_filter, NULL, NULL, AP_HOOK_MIDDLE);
  ++    ap_register_filter("CORE", core_filter, AP_FTYPE_CONNECTION);
    }
    
    API_VAR_EXPORT module core_module = {
   Index: main/http_protocol.c
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/main/http_protocol.c,v
  -retrieving revision 1.96
  -diff -u -d -b -w -u -r1.96 http_protocol.c
  ---- main/http_protocol.c	2000/07/13 16:26:42	1.96
  -+++ main/http_protocol.c	2000/07/20 21:16:29
  +retrieving revision 1.99
  +diff -u -d -b -w -u -r1.99 http_protocol.c
  +--- main/http_protocol.c	2000/07/28 20:31:00	1.99
  ++++ main/http_protocol.c	2000/07/31 23:24:57
   @@ -64,6 +64,8 @@
     */
    
  @@ -242,9 +304,9 @@
   +#include "apr_buf.h"
   +#include "util_filter.h"
    #include "ap_config.h"
  + #include "apr_strings.h"
    #include "httpd.h"
  - #include "http_config.h"
  -@@ -1812,7 +1814,11 @@
  +@@ -1824,7 +1826,11 @@
            ap_rfc822_date(date, r->request_time);
            ap_table_addn(r->headers_out, "Expires", date);
        }
  @@ -256,61 +318,56 @@
        /* Send the entire ap_table_t of header fields, terminated by an empty line. */
    
        ap_table_do((int (*) (void *, const char *, const char *)) ap_send_header_field,
  -@@ -2443,15 +2449,23 @@
  +@@ -2468,101 +2474,84 @@
  + API_EXPORT(size_t) ap_send_mmap(ap_mmap_t *mm, request_rec *r, size_t offset,
                                 size_t length)
    {
  -     size_t total_bytes_sent = 0;
  +-    size_t total_bytes_sent = 0;
   -    int n;
   -    ap_ssize_t w;
   -    char *addr;
  +-    
  +-    if (length == 0)
  +-        return 0;
  +-
  +-
  +-    length += offset;
  +-    while (!r->connection->aborted && offset < length) {
  +-        if (length - offset > MMAP_SEGMENT_SIZE) {
  +-            n = MMAP_SEGMENT_SIZE;
  +-        }
  +-        else {
  +-            n = length - offset;
  +-        }
  ++    size_t bytes_sent = 0;
   +    ap_bucket_brigade *bb = NULL;
  -+    ap_bucket *b = NULL;
  -+    ap_filter_t *f;
  -     
  -+    /* if you are using the older API's, then Apache will initiate the 
  -+     * filtering for you.
  -+     */
  -+    f = ap_init_filter(r->pool);   
  -+ 
  -     if (length == 0)
  -         return 0;
    
  --
  -     length += offset;
  -+/* We can remove all of the MMAP_SEGMENT_SIZE stuff from Apache, because
  -+ * it is an optimization to be used for sending data.  Since we are using
  -+ * bucket-brigades we need to move this optimization down to the bucket
  -+ * brigade stuff, but that can wait for a day or two.
  -     while (!r->connection->aborted && offset < length) {
  -         if (length - offset > MMAP_SEGMENT_SIZE) {
  -             n = MMAP_SEGMENT_SIZE;
  -@@ -2467,76 +2481,132 @@
  -         total_bytes_sent += w;
  -         offset += w;
  -     }
  -+ */
  +-        ap_mmap_offset((void**)&addr, mm, offset);
  +-        w = ap_rwrite(addr, n, r);
  +-        if (w < 0)
  +-            break;
  +-        total_bytes_sent += w;
  +-        offset += w;
  +-    }
  ++    /* WE probably need to do something to make sure we are respecting the
  ++     * offset and length.  I think I know how to do this, but I will wait
  ++     * until after the commit to actually write the code.
  ++     */
  ++    bb = ap_brigade_create(r->pool);
  ++    ap_brigade_append_buckets(bb, 
  ++                            ap_bucket_mmap_create(mm, mm->size, &bytes_sent));
  ++    bytes_sent = ap_pass_brigade(r, NULL, bb);
    
   -    SET_BYTES_SENT(r);
  -+    /* This is far too complex for a final API, but it is an okay
  -+     * start.  To finish this off, we will need a very clean API
  -+     * that does all of this for us.
  -+     */
  -+    bb = ap_bucket_brigade_create(r->pool);
  -+    b = ap_bucket_mmap_create();
  -+    b->insert(b, mm, mm->size, &total_bytes_sent);
  -+    bb->head = bb->tail = b;
  -+    total_bytes_sent = ap_pass_brigade(r, f, bb);
  -+
  -     return total_bytes_sent;
  +-    return total_bytes_sent;
  ++    return bytes_sent;
    }
    #endif /* USE_MMAP_FILES */
    
    API_EXPORT(int) ap_rputc(int c, request_rec *r)
    {
   +    ap_bucket_brigade *bb = NULL;
  -+    ap_bucket *b = NULL;
   +    ap_ssize_t written;
  -+    ap_filter_t *f;
   +
        if (r->connection->aborted)
            return EOF;
  @@ -320,21 +377,10 @@
   -        return EOF;
   -    }
   -    SET_BYTES_SENT(r);
  -+    /* if you are using the older API's, then Apache will initiate the 
  -+     * filtering for you.
  -+     */
  -+    f = ap_init_filter(r->pool);   
  ++    bb = ap_brigade_create(r->pool);
  ++    ap_brigade_append_buckets(bb, ap_bucket_rwmem_create(&c, 1, &written)); 
  ++    ap_pass_brigade(r, NULL, bb);
   +
  -+    /* This is far too complex for a final API, but it is an okay
  -+     * start.  To finish this off, we will need a very clean API
  -+     * that does all of this for us.
  -+     */
  -+    bb = ap_bucket_brigade_create(r->pool);
  -+    b = ap_bucket_rwmem_create();
  -+    b->insert(b, &c, 1, &written); 
  -+    bb->head = bb->tail = b;
  -+    ap_pass_brigade(r, f, bb);
  -+
        return c;
    }
    
  @@ -342,9 +388,7 @@
    {
   -    int rcode;
   +    ap_bucket_brigade *bb = NULL;
  -+    ap_bucket *b = NULL;
   +    ap_ssize_t written;
  -+    ap_filter_t *f;
    
        if (r->connection->aborted)
            return EOF;
  @@ -356,21 +400,11 @@
   -    }
   -    SET_BYTES_SENT(r);
   -    return rcode;
  -+    /* if you are using the older API's, then Apache will initiate the 
  -+     * filtering for you.
  -+     */
  -+    f = ap_init_filter(r->pool);   
  ++    bb = ap_brigade_create(r->pool);
  ++    ap_brigade_append_buckets(bb, 
  ++                           ap_bucket_rwmem_create(str, strlen(str), &written)); 
  ++    ap_pass_brigade(r, NULL, bb);
   +
  -+    /* This is far too complex for a final API, but it is an okay
  -+     * start.  To finish this off, we will need a very clean API
  -+     * that does all of this for us.
  -+     */
  -+    bb = ap_bucket_brigade_create(r->pool);
  -+    b = ap_bucket_rwmem_create();
  -+    b->insert(b, str, strlen(str), &written); 
  -+    bb->head = bb->tail = b;
  -+    ap_pass_brigade(r, f, bb);
  -+
   +    return written;
    }
    
  @@ -379,9 +413,7 @@
   -    ap_ssize_t n;
   -    ap_status_t rv;
   +    ap_bucket_brigade *bb = NULL;
  -+    ap_bucket *b = NULL;
   +    ap_ssize_t written;
  -+    ap_filter_t *f;
    
        if (r->connection->aborted)
            return EOF;
  @@ -394,20 +426,9 @@
   -    }
   -    SET_BYTES_SENT(r);
   -    return n;
  -+    /* if you are using the older API's, then Apache will initiate the 
  -+     * filtering for you.
  -+     */
  -+    f = ap_init_filter(r->pool);   
  -+
  -+    /* This is far too complex for a final API, but it is an okay
  -+     * start.  To finish this off, we will need a very clean API
  -+     * that does all of this for us.
  -+     */
  -+    bb = ap_bucket_brigade_create(r->pool);
  -+    b = ap_bucket_rwmem_create();
  -+    b->insert(b, buf, nbyte, &written); 
  -+    bb->head = bb->tail = b;
  -+    ap_pass_brigade(r, f, bb);
  ++    bb = ap_brigade_create(r->pool);
  ++    ap_brigade_append_buckets(bb, ap_bucket_rwmem_create(buf, nbyte, &written)); 
  ++    ap_pass_brigade(r, NULL, bb);
   +    return written;
    }
    
  @@ -416,16 +437,11 @@
   -    int n;
   +    ap_bucket_brigade *bb = NULL;
   +    ap_ssize_t written;
  -+    ap_filter_t *f;
    
        if (r->connection->aborted)
            return EOF;
  - 
  +-
   -    n = ap_vbprintf(r->connection->client, fmt, va);
  -+    /* if you are using the older API's, then Apache will initiate the 
  -+     * filtering for you.
  -+     */
  -+    f = ap_init_filter(r->pool);   
    
   -    if (n < 0) {
   -        check_first_conn_error(r, "vrprintf", 0);
  @@ -433,13 +449,9 @@
   -    }
   -    SET_BYTES_SENT(r);
   -    return n;
  -+    /* This is far too complex for a final API, but it is an okay
  -+     * start.  To finish this off, we will need a very clean API
  -+     * that does all of this for us.
  -+     */
  -+    bb = ap_bucket_brigade_create(r->pool);
  ++    bb = ap_brigade_create(r->pool);
   +    written = ap_brigade_vprintf(bb, fmt, va);
  -+    ap_pass_brigade(r, f, bb);
  ++    ap_pass_brigade(r, NULL, bb);
   +    return written;
    }
    
  @@ -449,7 +461,7 @@
    API_EXPORT_NONSTD(int) ap_rprintf(request_rec *r, const char *fmt, ...)
    {
        va_list va;
  -@@ -2546,46 +2616,58 @@
  +@@ -2572,46 +2561,35 @@
            return EOF;
    
        va_start(va, fmt);
  @@ -469,23 +481,13 @@
    {
   +    ap_bucket_brigade *bb = NULL;
   +    ap_ssize_t written;
  -+    ap_filter_t *f;
        va_list va;
   -    int n;
    
        if (r->connection->aborted)
            return EOF;
  - 
  -+    /* if you are using the older API's, then Apache will initiate the 
  -+     * filtering for you.
  -+     */
  -+    f = ap_init_filter(r->pool);   
  -+
  -+    /* This is far too complex for a final API, but it is an okay
  -+     * start.  To finish this off, we will need a very clean API
  -+     * that does all of this for us.
  -+     */
  -+    bb = ap_bucket_brigade_create(r->pool);
  +-
  ++    bb = ap_brigade_create(r->pool);
        va_start(va, r);
   -    n = ap_vbputstrs(r->connection->client, va);
   +    written = ap_brigade_vputstrs(bb, va);
  @@ -498,7 +500,7 @@
   -
   -    SET_BYTES_SENT(r);
   -    return n;
  -+    ap_pass_brigade(r, f, bb);
  ++    ap_pass_brigade(r, NULL, bb);
   +    return written;
    }
    
  @@ -506,37 +508,25 @@
    {
   -    ap_status_t rv;
   +    ap_bucket_brigade *bb;
  -+    ap_bucket *b;
  -+    ap_filter_t *f;
    
   -    if ((rv = ap_bflush(r->connection->client)) != APR_SUCCESS) {
   -        check_first_conn_error(r, "rflush", rv);
   -        return EOF;
   -    }
  -+    /* if you are using the older API's, then Apache will initiate the 
  -+     * filtering for you.
  -+     */
  -+    f = ap_init_filter(r->pool);   
  -+
  -+    /* This is far too complex for a final API, but it is an okay
  -+     * start.  To finish this off, we will need a very clean API
  -+     * that does all of this for us.
  -+     */
  -+    bb = ap_bucket_brigade_create(r->pool);
  -+    b = ap_bucket_eos_create();
  -+    bb->head = bb->tail = b;
  -+    ap_pass_brigade(r, f, bb);
  ++    bb = ap_brigade_create(r->pool);
  ++    ap_brigade_append_buckets(bb, ap_bucket_eos_create());
  ++    ap_pass_brigade(r, NULL, bb);
        return 0;
    }
    
   Index: main/http_request.c
   ===================================================================
   RCS file: /home/cvs/apache-2.0/src/main/http_request.c,v
  -retrieving revision 1.35
  -diff -u -d -b -w -u -r1.35 http_request.c
  ---- main/http_request.c	2000/06/24 17:33:57	1.35
  -+++ main/http_request.c	2000/07/20 21:16:29
  -@@ -1263,6 +1263,12 @@
  +retrieving revision 1.37
  +diff -u -d -b -w -u -r1.37 http_request.c
  +--- main/http_request.c	2000/07/28 20:31:01	1.37
  ++++ main/http_request.c	2000/07/31 23:24:57
  +@@ -1276,6 +1276,12 @@
            return;
        }
    
  @@ -549,3 +539,99 @@
        /* Take care of little things that need to happen when we're done */
        ap_finalize_request_protocol(r);
    }
  +Index: main/util_filter.c
  +===================================================================
  +RCS file: /home/cvs/apache-2.0/src/main/util_filter.c,v
  +retrieving revision 1.1
  +diff -u -d -b -w -u -r1.1 util_filter.c
  +--- main/util_filter.c	2000/07/28 20:31:02	1.1
  ++++ main/util_filter.c	2000/07/31 23:24:57
  +@@ -73,7 +73,7 @@
  + } ap_filter_rec_t;
  + 
  + /* ### make this visible for direct manipulation?
  +-   ### use a hash table
  ++ * ### use a hash table
  + */
  + static ap_filter_rec_t *registered_filters = NULL;
  + 
  +@@ -144,3 +144,63 @@
  +     }
  + }
  + 
  ++/* Pass the buckets to the next filter in the filter stack.  If the
  ++ * current filter is a handler, we should get NULL passed in instead of
  ++ * the current filter.  At that point, we can just call the first filter in
  ++ * the stack, or r->filters.
  ++ */
  ++API_EXPORT(int) ap_pass_brigade(request_rec *r, ap_filter_t *filter,
  ++                                 ap_bucket_brigade *bb)
  ++{
  ++    if (filter) {
  ++        return (*filter->next->filter_func)(r, filter->next, bb);
  ++    }
  ++    else {
  ++        return (*r->filters->filter_func)(r, r->filters, bb);
  ++    }
  ++}
  ++
  ++API_EXPORT(ap_bucket_brigade *) ap_get_saved_data(request_rec *r,
  ++                                   ap_filter_t *f, ap_bucket_brigade **b)
  ++{
  ++    ap_bucket_brigade *bb = (ap_bucket_brigade *)f->ctx;
  ++
  ++    /* If we have never stored any data in the filter, then we had better
  ++     * create an empty bucket brigade so that we can concat.
  ++     */
  ++    if (!bb) {
  ++        bb = ap_brigade_create(r->pool);
  ++    }
  ++
  ++    /* join the two brigades together.  *b is now empty so we can 
  ++     * safely destroy it. 
  ++     */
  ++    ap_brigade_catenate(bb, *b);
  ++    ap_brigade_destroy(*b);
  ++    /* clear out the filter's context pointer.  If we don't do this, then
  ++     * when we save more data to the filter, we will be appended to what is
  ++     * currently there.  This will mean repeating data.... BAD!  :-)
  ++     */
  ++    f->ctx = NULL;
  ++    
  ++    return bb;
  ++}
  ++
  ++API_EXPORT(void) ap_save_data_to_filter(request_rec *r, ap_filter_t *f,
  ++                                   ap_bucket_brigade **b)
  ++{
  ++    ap_bucket_brigade *bb = (ap_bucket_brigade *)f->ctx;
  ++
  ++    /* If have never stored any data in the filter, then we had better
  ++     * create an empty bucket brigade so that we can concat.
  ++     */
  ++    if (!bb) {
  ++        bb = ap_brigade_create(r->pool);
  ++    }
  ++
  ++    /* Apend b to bb.  This means b is now empty, and we can destory it safely. 
  ++     */
  ++    ap_brigade_catenate(bb, *b);
  ++    ap_brigade_destroy(*b);
  ++    f->ctx = bb;
  ++}
  +Index: os/unix/os.h
  +===================================================================
  +RCS file: /home/cvs/apache-2.0/src/os/unix/os.h,v
  +retrieving revision 1.10
  +diff -u -d -b -w -u -r1.10 os.h
  +--- os/unix/os.h	2000/05/15 23:02:57	1.10
  ++++ os/unix/os.h	2000/07/31 23:25:01
  +@@ -59,8 +59,6 @@
  + #ifndef APACHE_OS_H
  + #define APACHE_OS_H
  + 
  +-#include "ap_config.h"
  +-
  + #ifndef PLATFORM
  + #define PLATFORM "Unix"
  + #endif
  
  
  

Mime
View raw message