httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pque...@apache.org
Subject svn commit: r646206 - in /httpd/sandbox/amsterdam/d: build/build-modules-c.awk include/http_core.h server/Makefile.in server/serf_filters.c
Date Wed, 09 Apr 2008 07:21:18 GMT
Author: pquerna
Date: Wed Apr  9 00:21:01 2008
New Revision: 646206

URL: http://svn.apache.org/viewvc?rev=646206&view=rev
Log:
Move the core serf filters to the core.

Added:
    httpd/sandbox/amsterdam/d/server/serf_filters.c
Modified:
    httpd/sandbox/amsterdam/d/build/build-modules-c.awk
    httpd/sandbox/amsterdam/d/include/http_core.h
    httpd/sandbox/amsterdam/d/server/Makefile.in

Modified: httpd/sandbox/amsterdam/d/build/build-modules-c.awk
URL: http://svn.apache.org/viewvc/httpd/sandbox/amsterdam/d/build/build-modules-c.awk?rev=646206&r1=646205&r2=646206&view=diff
==============================================================================
--- httpd/sandbox/amsterdam/d/build/build-modules-c.awk (original)
+++ httpd/sandbox/amsterdam/d/build/build-modules-c.awk Wed Apr  9 00:21:01 2008
@@ -16,6 +16,8 @@
     RS = " "
     modules[n++] = "core"
     pmodules[pn++] = "core"
+    modules[n++] = "serf_filters"
+    pmodules[pn++] = "serf_filters"
 } 
 {
     modules[n] = $1;

Modified: httpd/sandbox/amsterdam/d/include/http_core.h
URL: http://svn.apache.org/viewvc/httpd/sandbox/amsterdam/d/include/http_core.h?rev=646206&r1=646205&r2=646206&view=diff
==============================================================================
--- httpd/sandbox/amsterdam/d/include/http_core.h (original)
+++ httpd/sandbox/amsterdam/d/include/http_core.h Wed Apr  9 00:21:01 2008
@@ -315,6 +315,7 @@
  * the code that cares really is in http_core.c.  Also, another accessor.
  */
 AP_DECLARE_DATA extern module core_module;
+AP_DECLARE_DATA extern module serf_filters_module;
 
 /**
  * @brief  Per-request configuration 

Modified: httpd/sandbox/amsterdam/d/server/Makefile.in
URL: http://svn.apache.org/viewvc/httpd/sandbox/amsterdam/d/server/Makefile.in?rev=646206&r1=646205&r2=646206&view=diff
==============================================================================
--- httpd/sandbox/amsterdam/d/server/Makefile.in (original)
+++ httpd/sandbox/amsterdam/d/server/Makefile.in Wed Apr  9 00:21:01 2008
@@ -14,7 +14,7 @@
 	mpm_common.c util_charset.c util_cookies.c util_debug.c util_xml.c \
 	util_expr.c util_filter.c util_pcre.c exports.c \
 	scoreboard.c error_bucket.c protocol.c core.c request.c provider.c \
-	eoc_bucket.c eor_bucket.c core_filters.c
+	eoc_bucket.c eor_bucket.c core_filters.c serf_filters.c
 
 TARGETS = delete-exports $(LTLIBRARY_NAME) $(CORE_IMPLIB_FILE) export_vars.h httpd.exp
 

Added: httpd/sandbox/amsterdam/d/server/serf_filters.c
URL: http://svn.apache.org/viewvc/httpd/sandbox/amsterdam/d/server/serf_filters.c?rev=646206&view=auto
==============================================================================
--- httpd/sandbox/amsterdam/d/server/serf_filters.c (added)
+++ httpd/sandbox/amsterdam/d/server/serf_filters.c Wed Apr  9 00:21:01 2008
@@ -0,0 +1,376 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "httpd.h"
+#include "http_core.h"
+#include "http_config.h"
+#include "http_protocol.h"
+#include "http_request.h"
+#include "http_log.h"
+
+#include "serf.h"
+#include "serf_bucket_types.h"
+#include "serf_bucket_util.h"
+#include "apr_uri.h"
+
+typedef struct {
+    serf_context_t *serf_ctx;
+    serf_bucket_alloc_t *serf_bkt_alloc;
+    serf_bucket_t *serf_in_bucket;
+    serf_bucket_t *serf_out_bucket;
+    apr_bucket_brigade *out_brigade;
+    apr_bucket_brigade *tmp_brigade;
+    apr_status_t serf_bucket_status;
+} serf_core_ctx_t;
+
+typedef struct {
+    apr_pool_t *pool;
+    serf_bucket_alloc_t *allocator;
+    serf_core_ctx_t *core_ctx;
+    apr_bucket_brigade *bb;
+    apr_bucket_brigade *tmp_bb;
+    apr_size_t last_read;
+} brigade_bucket_ctx_t;
+
+/* Forward-declare */
+const serf_bucket_type_t serf_bucket_type_brigade;
+
+static serf_bucket_t * brigade_create(ap_filter_t *f,
+                                      apr_bucket_brigade *bb,
+                                      serf_core_ctx_t *core_ctx)
+{
+    brigade_bucket_ctx_t *ctx;
+
+    ctx = serf_bucket_mem_alloc(core_ctx->serf_bkt_alloc, sizeof(*ctx));
+    ctx->allocator = core_ctx->serf_bkt_alloc;
+    ctx->pool = serf_bucket_allocator_get_pool(ctx->allocator);
+    ctx->core_ctx = core_ctx;
+    ctx->last_read = 0;
+
+    /* Replace witha more optimized mechanism for converting */
+    ap_save_brigade(f, &ctx->bb, &bb, f->c->pool);
+    ctx->tmp_bb = apr_brigade_create(f->c->pool, f->c->bucket_alloc);
+
+    return serf_bucket_create(&serf_bucket_type_brigade, ctx->allocator, ctx);
+}
+
+static void brigade_collapse(serf_bucket_t *bucket)
+{
+    brigade_bucket_ctx_t *ctx = bucket->data;
+    apr_status_t status;
+
+    if (ctx->last_read) {
+        apr_bucket *end, *f;
+        status = apr_brigade_partition(ctx->bb, ctx->last_read, &end);
+        f = APR_BRIGADE_FIRST(ctx->bb);
+        while (f != end && f != APR_BRIGADE_SENTINEL(ctx->bb)) {
+            apr_bucket_delete(f);
+            f = APR_BRIGADE_FIRST(ctx->bb);
+        }
+        ctx->last_read = 0;
+    }
+}
+
+static apr_status_t brigade_read(serf_bucket_t *bucket,
+                                 apr_size_t requested,
+                                 const char **data, apr_size_t *len)
+{
+    brigade_bucket_ctx_t *ctx = bucket->data;
+    apr_status_t status;
+
+    brigade_collapse(bucket);
+
+    if (APR_BRIGADE_EMPTY(ctx->bb) ||
+        APR_BUCKET_IS_EOS(APR_BRIGADE_FIRST(ctx->bb)) ||
+        AP_BUCKET_IS_EOR(APR_BRIGADE_FIRST(ctx->bb))) {
+        *len = 0;
+        return APR_EOF;
+    }
+
+    status = apr_bucket_read(APR_BRIGADE_FIRST(ctx->bb), data, len,
+                             APR_BLOCK_READ);
+
+    if (requested < *len) {
+        *len = requested;
+    }
+    ctx->last_read = *len;
+
+    return status;
+}
+
+static apr_status_t brigade_readline(serf_bucket_t *bucket,
+                                     int acceptable, int *found,
+                                     const char **data, apr_size_t *len)
+{
+    brigade_bucket_ctx_t *ctx = bucket->data;
+    apr_status_t orig_status, status;
+
+    orig_status = apr_brigade_split_line(ctx->tmp_bb, ctx->bb,
+                                         APR_BLOCK_READ, HUGE_STRING_LEN);
+    if (APR_STATUS_IS_EAGAIN(orig_status)) {
+        if (found) {
+            *found = SERF_NEWLINE_NONE;
+        }
+        status = APR_SUCCESS;
+    }
+    else {
+        status = orig_status;
+    }
+
+    apr_brigade_pflatten(ctx->tmp_bb, (char**)data, len, ctx->pool);
+    apr_brigade_cleanup(ctx->tmp_bb);
+
+    if (orig_status == APR_SUCCESS && found) {
+        if (*len > 2 && (*data)[*len-2] == '\r' && (*data)[*len-1] ==
'\n') {
+            *found = SERF_NEWLINE_CRLF;
+        }
+        else if (*len && (*data)[*len-1] == '\r') {
+            *found = SERF_NEWLINE_CR;
+        } else if (*len && (*data)[*len-1] == '\n') {
+            *found = SERF_NEWLINE_LF;
+        } else {
+            *found = SERF_NEWLINE_NONE;
+        }
+    }
+    return status;
+}
+
+static apr_status_t brigade_peek(serf_bucket_t *bucket,
+                                 const char **data,
+                                 apr_size_t *len)
+{
+    brigade_bucket_ctx_t *ctx = bucket->data;
+
+    brigade_collapse(bucket);
+
+    if (APR_BRIGADE_EMPTY(ctx->bb) ||
+        APR_BUCKET_IS_EOS(APR_BRIGADE_FIRST(ctx->bb)) ||
+        AP_BUCKET_IS_EOR(APR_BRIGADE_FIRST(ctx->bb))) {
+        *len = 0;
+        return APR_EOF;
+    }
+
+    return apr_bucket_read(APR_BRIGADE_FIRST(ctx->bb), data, len,
+                           APR_BLOCK_READ);
+}
+
+static void brigade_destroy(serf_bucket_t *bucket)
+{
+    brigade_bucket_ctx_t *ctx = bucket->data;
+
+    apr_brigade_destroy(ctx->bb);
+    apr_brigade_destroy(ctx->tmp_bb);
+
+    serf_default_destroy_and_data(bucket);
+}
+
+const serf_bucket_type_t serf_bucket_type_brigade = {
+    "BRIGADE",
+    brigade_read,
+    brigade_readline,
+    serf_default_read_iovec,
+    serf_default_read_for_sendfile,
+    serf_default_read_bucket,
+    brigade_peek,
+    brigade_destroy,
+};
+
+static serf_core_ctx_t* init_ctx(ap_filter_t *f, apr_socket_t *socket)
+{
+    serf_core_ctx_t *ctx;
+
+    ctx = apr_pcalloc(f->c->pool, sizeof(*ctx));
+
+    ctx->serf_ctx = serf_context_create(f->c->pool);
+    ctx->serf_bkt_alloc = serf_bucket_allocator_create(f->c->pool, NULL, NULL);
+    ctx->serf_in_bucket = serf_bucket_socket_create(socket,
+                                                    ctx->serf_bkt_alloc);
+    ctx->serf_out_bucket = serf_bucket_aggregate_create(ctx->serf_bkt_alloc);
+
+    ctx->out_brigade = apr_brigade_create(f->c->pool, f->c->bucket_alloc);
+    ctx->tmp_brigade = apr_brigade_create(f->c->pool, f->c->bucket_alloc);
+
+    return ctx;
+}
+
+static int serf_input_filter(ap_filter_t *f, apr_bucket_brigade *bb,
+                             ap_input_mode_t mode, apr_read_type_e block,
+                             apr_off_t readbytes)
+{
+    apr_status_t status;
+    core_net_rec *net = f->ctx;
+    serf_core_ctx_t *ctx = (serf_core_ctx_t*)net->in_ctx;
+
+    if (mode == AP_MODE_INIT) {
+        return APR_SUCCESS;
+    }
+    if (!ctx)
+    {
+        ctx = init_ctx(f, net->client_socket);
+        net->in_ctx = (void*)ctx;
+    }
+
+    if (mode == AP_MODE_GETLINE) {
+        const char *data;
+        apr_size_t len;
+        int found;
+        apr_bucket *b;
+
+        ctx->serf_bucket_status = serf_bucket_readline(ctx->serf_in_bucket,
+                                                       SERF_NEWLINE_ANY,
+                                                       &found, &data, &len);
+        b = apr_bucket_transient_create(data, len, f->c->bucket_alloc);
+        APR_BRIGADE_INSERT_TAIL(bb, b);
+        return APR_SUCCESS;
+    }
+    if (mode == AP_MODE_READBYTES) {
+        const char *data;
+        apr_size_t len;
+        apr_bucket *b;
+
+        ctx->serf_bucket_status = serf_bucket_read(ctx->serf_in_bucket,
+                                                   readbytes, &data, &len);
+        b = apr_bucket_transient_create(data, len, f->c->bucket_alloc);
+        APR_BRIGADE_INSERT_TAIL(bb, b);
+        return APR_SUCCESS;
+    }
+
+    if (mode == AP_MODE_SPECULATIVE) {
+        const char *data;
+        apr_size_t len;
+        apr_bucket *b;
+        serf_bucket_t *sb;
+
+        ctx->serf_bucket_status = serf_bucket_peek(ctx->serf_in_bucket,
+                                                   &data, &len);
+
+        b = apr_bucket_transient_create(data, len, f->c->bucket_alloc);
+        APR_BRIGADE_INSERT_TAIL(bb, b);
+        return APR_SUCCESS;
+    }
+
+    if (mode == AP_MODE_EATCRLF || mode == AP_MODE_EXHAUSTIVE) {
+        abort();
+    }
+}
+
+static apr_status_t serf_output_filter(ap_filter_t *f,
+                                       apr_bucket_brigade *new_bb)
+{
+    apr_status_t rv;
+    serf_bucket_t *b;
+    conn_rec *c = f->c;
+    core_net_rec *net = f->ctx;
+    serf_core_ctx_t *ctx = (serf_core_ctx_t*)net->in_ctx;
+    if (!ctx) {
+        ctx = init_ctx(f, net->client_socket);
+        net->in_ctx = (void*)ctx;
+    }
+
+    if (new_bb) {
+        b = brigade_create(f, new_bb, ctx);
+        serf_bucket_aggregate_append(ctx->serf_out_bucket, b);
+        c->data_in_output_filters = 1;
+    }
+
+    if (c->data_in_output_filters && new_bb == NULL) {
+        do {
+            apr_status_t srv;
+            const char *buf;
+            apr_size_t len = 0;
+
+            srv = serf_bucket_read(ctx->serf_out_bucket, SERF_READ_ALL_AVAIL,
+                                   &buf, &len);
+
+            if (SERF_BUCKET_READ_ERROR(srv)) {
+                /* bad, logme */
+                return srv;
+            }
+
+            /* write data to network here. */
+            if (len > 0) {
+                apr_size_t blen = len;
+                rv = apr_socket_send(net->client_socket, buf, &blen);
+                if (blen != len) {
+                    b = serf_bucket_simple_create(buf+blen, len - blen, NULL, NULL, ctx->serf_bkt_alloc);
+                    serf_bucket_aggregate_prepend(ctx->serf_out_bucket, b);
+                    srv = APR_SUCCESS;
+                }
+            }
+
+            if (APR_STATUS_IS_EOF(srv)) {
+                c->data_in_output_filters = 0;
+                break;
+            }
+            if (APR_STATUS_IS_EAGAIN(srv)) {
+                break;
+            }
+        } while (rv == APR_SUCCESS);
+    }
+
+    return APR_SUCCESS;
+}
+
+static ap_filter_rec_t *serf_input_filter_handle;
+static ap_filter_rec_t *serf_output_filter_handle;
+
+static int serf_pre_connection(conn_rec *c, void *csd)
+{
+    core_net_rec *net = apr_palloc(c->pool, sizeof(*net));
+    apr_status_t status;
+
+    apr_socket_timeout_set(csd, 0);
+
+    net->c = c;
+    net->in_ctx = NULL;
+    net->out_ctx = NULL;
+    net->client_socket = csd;
+
+    ap_set_module_config(net->c->conn_config, &serf_filters_module, csd);
+    ap_add_input_filter_handle(serf_input_filter_handle, net, NULL, net->c);
+    ap_add_output_filter_handle(serf_output_filter_handle, net, NULL, net->c);
+
+    return DONE;
+}
+
+static const command_rec serf_cmds[] =
+{
+    {NULL}
+};
+
+static void register_hooks(apr_pool_t *p)
+{
+    ap_hook_pre_connection(serf_pre_connection, NULL, NULL, APR_HOOK_MIDDLE);
+    serf_input_filter_handle =
+        ap_register_input_filter("SERF_IN", serf_input_filter, NULL,
+                                 AP_FTYPE_NETWORK);
+    serf_output_filter_handle =
+        ap_register_output_filter("SERF_OUT", serf_output_filter, NULL,
+                                  AP_FTYPE_NETWORK);
+
+}
+
+module AP_MODULE_DECLARE_DATA serf_filters_module =
+{
+    STANDARD20_MODULE_STUFF,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    serf_cmds,
+    register_hooks
+};
+



Mime
View raw message