serf-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rhuij...@apache.org
Subject svn commit: r1710686 - in /serf/trunk: buckets/hpack_buckets.c buckets/http2_frame_buckets.c protocols/http2_buckets.h serf_bucket_types.h serf_private.h test/test_buckets.c
Date Mon, 26 Oct 2015 20:15:02 GMT
Author: rhuijben
Date: Mon Oct 26 20:15:02 2015
New Revision: 1710686

URL: http://svn.apache.org/viewvc?rev=1710686&view=rev
Log:
Turn all the http2 related new bucket types and their functions
into private types. No functional changes.

This patch breaks compilin http2_protocol.c. I'll fix that in
a separate commit that does contain functional changes.

* buckets/hpack_buckets.c
  (includes): Add http2_buckets.h.
  (serf_hpack_table_create): Rename to...
  (serf__hpack_table_create): ... this.
  (hpack_copy_from_headers,
   serf__bucket_hpack_create_from_request): Update caller.
  (serf_bucket_hpack_create): Rename to...
  (serf__bucket_hpack_create): ... this.
  (serf_bucket_hpack_setc): Rename to...
   serf__bucket_hpack_setc): ... this. Update caller
  (serf_bucket_hpack_setx): Rename to...
  (serf__bucket_hpack_setx): ... this.
  (serf_bucket_type_hpack): Rename to...
  (serf_bucket_type__hpack): ... this.
  (serf_bucket_hpack_decode_create): Rename to...
  (serf__bucket_hpack_decode_create): ... this.
  (serf_bucket_type_hpack_decode): Rename to...
  (serf_bucket_type__hpack_decode): ... this.

* buckets/http2_frame_buckets.c
  (includes): Add http2_buckets.h.
  (serf_bucket_http2_unframe_create): Rename to...
  (serf__bucket_http2_unframe_create): ... this.
  (serf_bucket_http2_unframe_read_info): Rename to...
  (serf__bucket_http2_unframe_read_info): ... this.
  (*): Update caller.
  (serf_bucket_http2_unpad_create): Rename to...
  (serf__bucket_http2_unpad_create): ... this.
  (serf_bucket_type_http2_unpad): Rename to...
  (serf_bucket_type__http2_unpad): ... this.
  (serf_bucket_http2_frame_create): Rename to...
  (serf__bucket_http2_frame_create): ... this.
  (serf_bucket_type_http2_frame): Rename to...
  (serf_bucket_type__http2_frame): ... this.

* protocols/http2_buckets.h
  New file, copied from serf_bucket_types.h.

* serf_bucket_types.h
  Remove all http2 types and functions.

* serf_private.h
  (serf_hpack_table_t): Add typedef.

* test/test_buckets.c
  (includes): Add http2_buckets.h.
  (test_http2_unframe_buckets,
   test_http2_unpad_buckets,
   test_hpack_header_encode,
   test_http2_frame_bucket_basic): Update caller.

Added:
    serf/trunk/protocols/http2_buckets.h
      - copied, changed from r1710678, serf/trunk/serf_bucket_types.h
Modified:
    serf/trunk/buckets/hpack_buckets.c
    serf/trunk/buckets/http2_frame_buckets.c
    serf/trunk/serf_bucket_types.h
    serf/trunk/serf_private.h
    serf/trunk/test/test_buckets.c

Modified: serf/trunk/buckets/hpack_buckets.c
URL: http://svn.apache.org/viewvc/serf/trunk/buckets/hpack_buckets.c?rev=1710686&r1=1710685&r2=1710686&view=diff
==============================================================================
--- serf/trunk/buckets/hpack_buckets.c (original)
+++ serf/trunk/buckets/hpack_buckets.c Mon Oct 26 20:15:02 2015
@@ -25,6 +25,7 @@
 #include "serf.h"
 #include "serf_bucket_util.h"
 #include "serf_private.h"
+#include "protocols/http2_buckets.h"
 
 #include "hpack_huffman.inc"
 #define EOS_CHAR (256)
@@ -372,9 +373,9 @@ static const apr_uint64_t hpack_static_t
 
 
 serf_hpack_table_t *
-serf_hpack_table_create(int for_http2,
-                        apr_size_t default_max_table_size,
-                        apr_pool_t *result_pool)
+serf__hpack_table_create(int for_http2,
+                         apr_size_t default_max_table_size,
+                         apr_pool_t *result_pool)
 {
   serf_hpack_table_t *tbl = apr_pcalloc(result_pool, sizeof(*tbl));
 
@@ -470,7 +471,7 @@ hpack_copy_from_headers(void *baton,
       return APR_SUCCESS;
     }
 
-  serf_bucket_hpack_setc(hpack, key, value);
+  serf__bucket_hpack_setc(hpack, key, value);
 
   return APR_SUCCESS;
 }
@@ -485,7 +486,7 @@ serf__bucket_hpack_create_from_request(s
 {
   const char *uri, *method, *host;
 
-  serf_bucket_t *hpack = serf_bucket_hpack_create(hpack_table, allocator);
+  serf_bucket_t *hpack = serf__bucket_hpack_create(hpack_table, allocator);
 
   serf_bucket_t *headers = serf_bucket_request_get_headers(request);
 
@@ -493,10 +494,10 @@ serf__bucket_hpack_create_from_request(s
 
   serf__bucket_request_read(request, NULL, &uri, &method);
 
-  serf_bucket_hpack_setc(hpack, ":method", method);
-  serf_bucket_hpack_setc(hpack, ":scheme", scheme);
-  serf_bucket_hpack_setc(hpack, ":authority", host);
-  serf_bucket_hpack_setc(hpack, ":path", uri);
+  serf__bucket_hpack_setc(hpack, ":method", method);
+  serf__bucket_hpack_setc(hpack, ":scheme", scheme);
+  serf__bucket_hpack_setc(hpack, ":authority", host);
+  serf__bucket_hpack_setc(hpack, ":path", uri);
 
   serf_bucket_headers_do(headers, hpack_copy_from_headers, hpack);
 
@@ -507,8 +508,8 @@ serf__bucket_hpack_create_from_request(s
 
 
 serf_bucket_t *
-serf_bucket_hpack_create(serf_hpack_table_t *hpack_table,
-                         serf_bucket_alloc_t *allocator)
+serf__bucket_hpack_create(serf_hpack_table_t *hpack_table,
+                          serf_bucket_alloc_t *allocator)
 {
   serf_hpack_context_t *ctx = serf_bucket_mem_alloc(allocator, sizeof(*ctx));
 
@@ -516,25 +517,27 @@ serf_bucket_hpack_create(serf_hpack_tabl
   ctx->tbl = hpack_table;
   ctx->first = ctx->last = NULL;
 
-  return serf_bucket_create(&serf_bucket_type_hpack, allocator, ctx);
+  return serf_bucket_create(&serf_bucket_type__hpack, allocator, ctx);
 }
 
-void serf_bucket_hpack_setc(serf_bucket_t *hpack_bucket,
-                            const char *key,
-                            const char *value)
+void 
+serf__bucket_hpack_setc(serf_bucket_t *hpack_bucket,
+                        const char *key,
+                        const char *value)
 {
-  serf_bucket_hpack_setx(hpack_bucket,
-                         key, strlen(key), TRUE,
-                         value, strlen(value), TRUE);
+  serf__bucket_hpack_setx(hpack_bucket,
+                          key, strlen(key), TRUE,
+                          value, strlen(value), TRUE);
 }
 
-void serf_bucket_hpack_setx(serf_bucket_t *hpack_bucket,
-                            const char *key,
-                            apr_size_t key_size,
-                            int key_copy,
-                            const char *value,
-                            apr_size_t value_size,
-                            int value_copy)
+void
+serf__bucket_hpack_setx(serf_bucket_t *hpack_bucket,
+                        const char *key,
+                        apr_size_t key_size,
+                        int key_copy,
+                        const char *value,
+                        apr_size_t value_size,
+                        int value_copy)
 {
   serf_hpack_context_t *ctx = hpack_bucket->data;
   serf_hpack_entry_t *entry;
@@ -820,7 +823,7 @@ serf_hpack_destroy_and_data(serf_bucket_
 /* ### need to implement */
 #define serf_hpack_readline NULL
 
-const serf_bucket_type_t serf_bucket_type_hpack = {
+const serf_bucket_type_t serf_bucket_type__hpack = {
   "HPACK",
   serf_hpack_read,
   serf_hpack_readline,
@@ -889,17 +892,17 @@ hpack_decode_databuf_reader(void *baton,
                             apr_size_t *len);
 
 serf_bucket_t *
-serf_bucket_hpack_decode_create(serf_bucket_t *stream,
-                                apr_status_t (*item_callback)(
+serf__bucket_hpack_decode_create(serf_bucket_t *stream,
+                                 apr_status_t (*item_callback)(
                                         void *baton,
                                         const char *key,
                                         apr_size_t key_size,
                                         const char *value,
                                         apr_size_t value_size),
-                                void *item_baton,
-                                apr_size_t max_entry_size,
-                                serf_hpack_table_t *hpack_table,
-                                serf_bucket_alloc_t *alloc)
+                                 void *item_baton,
+                                 apr_size_t max_entry_size,
+                                 serf_hpack_table_t *hpack_table,
+                                 serf_bucket_alloc_t *alloc)
 {
   serf_hpack_decode_ctx_t *ctx = serf_bucket_mem_calloc(alloc, sizeof(*ctx));
 
@@ -933,7 +936,7 @@ serf_bucket_hpack_decode_create(serf_buc
   ctx->tbl->rl_start = ctx->tbl->rl_first;
   ctx->tbl->rl_indexable = ctx->tbl->rl_count;
 
-  return serf_bucket_create(&serf_bucket_type_hpack_decode, alloc, ctx);
+  return serf_bucket_create(&serf_bucket_type__hpack_decode, alloc, ctx);
 }
 
 static apr_status_t
@@ -1558,7 +1561,7 @@ serf_hpack_decode_destroy(serf_bucket_t
   serf_default_destroy_and_data(bucket);
 }
 
-const serf_bucket_type_t serf_bucket_type_hpack_decode = {
+const serf_bucket_type_t serf_bucket_type__hpack_decode = {
   "HPACK-DECODE",
   serf_hpack_decode_read,
   serf_hpack_decode_readline,
@@ -1567,4 +1570,4 @@ const serf_bucket_type_t serf_bucket_typ
   serf_default_read_bucket,
   serf_hpack_decode_peek,
   serf_hpack_decode_destroy
-};
\ No newline at end of file
+};

Modified: serf/trunk/buckets/http2_frame_buckets.c
URL: http://svn.apache.org/viewvc/serf/trunk/buckets/http2_frame_buckets.c?rev=1710686&r1=1710685&r2=1710686&view=diff
==============================================================================
--- serf/trunk/buckets/http2_frame_buckets.c (original)
+++ serf/trunk/buckets/http2_frame_buckets.c Mon Oct 26 20:15:02 2015
@@ -26,6 +26,8 @@
 #include "serf_bucket_util.h"
 #include "serf_private.h"
 
+#include "protocols/http2_buckets.h"
+
 /* https://tools.ietf.org/html/rfc7540#section-4.1 */
 #define FRAME_PREFIX_SIZE 9 
 
@@ -47,10 +49,10 @@ typedef struct http2_unframe_context_t
 } http2_unframe_context_t;
 
 serf_bucket_t *
-serf_bucket_http2_unframe_create(serf_bucket_t *stream,
-                                 int destroy_stream,
-                                 apr_size_t max_payload_size,
-                                 serf_bucket_alloc_t *allocator)
+serf__bucket_http2_unframe_create(serf_bucket_t *stream,
+                                  int destroy_stream,
+                                  apr_size_t max_payload_size,
+                                  serf_bucket_alloc_t *allocator)
 {
   http2_unframe_context_t *ctx;
 
@@ -60,14 +62,14 @@ serf_bucket_http2_unframe_create(serf_bu
   ctx->prefix_remaining = sizeof(ctx->prefix_buffer);
   ctx->destroy_stream = (destroy_stream != 0);
 
-  return serf_bucket_create(&serf_bucket_type_http2_unframe, allocator, ctx);
+  return serf_bucket_create(&serf_bucket_type__http2_unframe, allocator, ctx);
 }
 
 apr_status_t
-serf_bucket_http2_unframe_read_info(serf_bucket_t *bucket,
-                                    apr_int32_t *stream_id,
-                                    unsigned char *frame_type,
-                                    unsigned char *flags)
+serf__bucket_http2_unframe_read_info(serf_bucket_t *bucket,
+                                     apr_int32_t *stream_id,
+                                     unsigned char *frame_type,
+                                     unsigned char *flags)
 {
   http2_unframe_context_t *ctx = bucket->data;
   const char *data;
@@ -110,8 +112,8 @@ serf_bucket_http2_unframe_read_info(serf
           ctx->payload_remaining = payload_length;
 
           /* Use recursion to fill output arguments if necessary */
-          serf_bucket_http2_unframe_read_info(bucket, stream_id, frame_type,
-                                              flags);
+          serf__bucket_http2_unframe_read_info(bucket, stream_id, frame_type,
+                                               flags);
 
           /* https://tools.ietf.org/html/rfc7540#section-4.2
             An endpoint MUST send an error code of FRAME_SIZE_ERROR if a frame
@@ -138,7 +140,7 @@ serf_http2_unframe_read(serf_bucket_t *b
   http2_unframe_context_t *ctx = bucket->data;
   apr_status_t status;
 
-  status = serf_bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
+  status = serf__bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
 
   if (status)
     {
@@ -177,7 +179,7 @@ serf_http2_unframe_read_iovec(serf_bucke
   http2_unframe_context_t *ctx = bucket->data;
   apr_status_t status;
 
-  status = serf_bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
+  status = serf__bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
 
   if (status)
     {
@@ -221,7 +223,7 @@ serf_http2_unframe_peek(serf_bucket_t *b
   http2_unframe_context_t *ctx = bucket->data;
   apr_status_t status;
 
-  status = serf_bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
+  status = serf__bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
 
   if (status)
     {
@@ -256,7 +258,7 @@ serf_http2_unframe_get_remaining(serf_bu
   http2_unframe_context_t *ctx = bucket->data;
   apr_status_t status;
 
-  status = serf_bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
+  status = serf__bucket_http2_unframe_read_info(bucket, NULL, NULL, NULL);
 
   if (status)
     return SERF_LENGTH_UNKNOWN;
@@ -267,7 +269,7 @@ serf_http2_unframe_get_remaining(serf_bu
 /* ### need to implement */
 #define serf_http2_unframe_readline NULL
 
-const serf_bucket_type_t serf_bucket_type_http2_unframe = {
+const serf_bucket_type_t serf_bucket_type__http2_unframe = {
   "H2-UNFRAME",
   serf_http2_unframe_read,
   serf_http2_unframe_readline /* ### TODO */,
@@ -292,9 +294,9 @@ typedef struct http2_unpad_context_t
 } http2_unpad_context_t;
 
 serf_bucket_t *
-serf_bucket_http2_unpad_create(serf_bucket_t *stream,
-                               int destroy_stream,
-                               serf_bucket_alloc_t *allocator)
+serf__bucket_http2_unpad_create(serf_bucket_t *stream,
+                                int destroy_stream,
+                                serf_bucket_alloc_t *allocator)
 {
   http2_unpad_context_t *ctx;
 
@@ -303,7 +305,7 @@ serf_bucket_http2_unpad_create(serf_buck
   ctx->padsize_read = FALSE;
   ctx->destroy_stream = destroy_stream;
 
-  return serf_bucket_create(&serf_bucket_type_http2_unpad, allocator, ctx);
+  return serf_bucket_create(&serf_bucket_type__http2_unpad, allocator, ctx);
 }
 
 static apr_status_t
@@ -509,7 +511,7 @@ serf_http2_unpad_get_remaining(serf_buck
 /* ### need to implement */
 #define serf_h2_dechunk_readline NULL
 
-const serf_bucket_type_t serf_bucket_type_http2_unpad = {
+const serf_bucket_type_t serf_bucket_type__http2_unpad = {
   "H2-UNPAD",
   serf_http2_unpad_read,
   serf_h2_dechunk_readline /* ### TODO */,
@@ -554,23 +556,23 @@ typedef struct serf_http2_frame_context_
 } serf_http2_frame_context_t;
 
 serf_bucket_t *
-serf_bucket_http2_frame_create(serf_bucket_t *stream,
-                               unsigned char frame_type,
-                               unsigned char flags,
-                               apr_int32_t *stream_id,
-                               void (*stream_id_alloc)(
-                                                  void *baton,
-                                                  apr_int32_t *stream_id),
-                               void *stream_id_baton,
-                               apr_size_t max_payload_size,
-                               apr_int32_t (*alloc_window)(
-                                                  void *baton,
-                                                  unsigned char frametype,
-                                                  apr_int32_t stream_id,
-                                                  apr_size_t requested,
-                                                  int peek),
-                               void *alloc_window_baton,
-                               serf_bucket_alloc_t *alloc)
+serf__bucket_http2_frame_create(serf_bucket_t *stream,
+                                unsigned char frame_type,
+                                unsigned char flags,
+                                apr_int32_t *stream_id,
+                                void (*stream_id_alloc)(
+                                                   void *baton,
+                                                   apr_int32_t *stream_id),
+                                void *stream_id_baton,
+                                apr_size_t max_payload_size,
+                                apr_int32_t (*alloc_window)(
+                                                   void *baton,
+                                                   unsigned char frametype,
+                                                   apr_int32_t stream_id,
+                                                   apr_size_t requested,
+                                                   int peek),
+                                void *alloc_window_baton,
+                                serf_bucket_alloc_t *alloc)
 {
   serf_http2_frame_context_t *ctx = serf_bucket_mem_alloc(alloc, sizeof(*ctx));
 
@@ -612,7 +614,7 @@ serf_bucket_http2_frame_create(serf_buck
 
   ctx->end_of_stream = ctx->end_of_headers = ctx->created_frame = FALSE;
 
-  return serf_bucket_create(&serf_bucket_type_http2_frame, alloc, ctx);
+  return serf_bucket_create(&serf_bucket_type__http2_frame, alloc, ctx);
 }
 
 
@@ -770,7 +772,7 @@ serf_http2_frame_destroy(serf_bucket_t *
 /* ### need to implement */
 #define serf_http2_frame_readline NULL
 
-const serf_bucket_type_t serf_bucket_type_http2_frame = {
+const serf_bucket_type_t serf_bucket_type__http2_frame = {
   "H2-FRAME",
   serf_http2_frame_read,
   serf_http2_frame_readline,

Copied: serf/trunk/protocols/http2_buckets.h (from r1710678, serf/trunk/serf_bucket_types.h)
URL: http://svn.apache.org/viewvc/serf/trunk/protocols/http2_buckets.h?p2=serf/trunk/protocols/http2_buckets.h&p1=serf/trunk/serf_bucket_types.h&r1=1710678&r2=1710686&rev=1710686&view=diff
==============================================================================
--- serf/trunk/serf_bucket_types.h (original)
+++ serf/trunk/protocols/http2_buckets.h Mon Oct 26 20:15:02 2015
@@ -18,17 +18,10 @@
  * ====================================================================
  */
 
-#ifndef SERF_BUCKET_TYPES_H
-#define SERF_BUCKET_TYPES_H
-
-#include <apr_mmap.h>
-#include <apr_hash.h>
-
-/* this header and serf.h refer to each other, so take a little extra care */
-#ifndef SERF_H
-#include "serf.h"
-#endif
+#ifndef SERF_PROTOCOL_HTTP2_BUCKETS_H
+#define SERF_PROTOCOL_HTTP2_BUCKETS_H
 
+#include "serf_bucket_types.h"
 
 /**
  * @file serf_bucket_types.h
@@ -42,728 +35,14 @@ extern "C" {
 
 /* ==================================================================== */
 
-
-extern const serf_bucket_type_t serf_bucket_type_request;
-#define SERF_BUCKET_IS_REQUEST(b) SERF_BUCKET_CHECK((b), request)
-
-serf_bucket_t *serf_bucket_request_create(
-    const char *method,
-    const char *URI,
-    serf_bucket_t *body,
-    serf_bucket_alloc_t *allocator);
-
-/* Send a Content-Length header with @a len. The @a body bucket should
-   contain precisely that much data.  */
-void serf_bucket_request_set_CL(
-    serf_bucket_t *bucket,
-    apr_int64_t len);
-
-serf_bucket_t *serf_bucket_request_get_headers(
-    serf_bucket_t *request);
-
-/** Transform @a bucket in-place into a request bucket.
- *
- * It is callers responsibility to free resources held by the original
- * bucket */
-void serf_bucket_request_become(
-    serf_bucket_t *bucket,
-    const char *method,
-    const char *uri,
-    serf_bucket_t *body);
-
-/**
- * Sets the root url of the remote host. If this request contains a relative
- * url, it will be prefixed with the root url to form an absolute url.
- * @a bucket is the request bucket. @a root_url is the absolute url of the
- * root of the remote host, without the closing '/'.
- */
-void serf_bucket_request_set_root(
-    serf_bucket_t *bucket,
-    const char *root_url);
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_response;
-#define SERF_BUCKET_IS_RESPONSE(b) SERF_BUCKET_CHECK((b), response)
-
-serf_bucket_t *serf_bucket_response_create(
-    serf_bucket_t *stream,
-    serf_bucket_alloc_t *allocator);
-
-#define SERF_HTTP_VERSION(major, minor)  ((major) * 1000 + (minor))
-#define SERF_HTTP_11 SERF_HTTP_VERSION(1, 1)
-#define SERF_HTTP_10 SERF_HTTP_VERSION(1, 0)
-#define SERF_HTTP_VERSION_MAJOR(shv) ((int)shv / 1000)
-#define SERF_HTTP_VERSION_MINOR(shv) ((int)shv % 1000)
-
-typedef struct serf_status_line {
-    int version;
-    int code;
-    const char *reason;
-} serf_status_line;
-
-/**
- * Return the Status-Line information, if available. This function
- * works like other bucket read functions: it may return APR_EAGAIN or
- * APR_EOF to signal the state of the bucket for reading. A return
- * value of APR_SUCCESS will always indicate that status line
- * information was returned; for other return values the caller must
- * check the version field in @a sline. A value of 0 means that the
- * data is not (yet) present.
- */
-apr_status_t serf_bucket_response_status(
-    serf_bucket_t *bkt,
-    serf_status_line *sline);
-
-/**
- * Wait for the HTTP headers to be processed for a @a response.
- *
- * If the headers are available, APR_SUCCESS is returned.
- * If the headers aren't available, APR_EAGAIN is returned.
- */
-apr_status_t serf_bucket_response_wait_for_headers(
-    serf_bucket_t *response);
-
-/**
- * Get the headers bucket for @a response.
- */
-serf_bucket_t *serf_bucket_response_get_headers(
-    serf_bucket_t *response);
-
-/**
- * Advise the response @a bucket that this was from a HEAD request and
- * that it should not expect to see a response body.
- */
-void serf_bucket_response_set_head(
-    serf_bucket_t *bucket);
-
-/* ==================================================================== */
-
-extern const serf_bucket_type_t serf_bucket_type_response_body;
-#define SERF_BUCKET_IS_RESPONSE_BODY(b) SERF_BUCKET_CHECK((b), response_body)
-
-serf_bucket_t *serf_bucket_response_body_create(
-    serf_bucket_t *stream,
-    apr_uint64_t limit,
-    serf_bucket_alloc_t *allocator);
-
-/* ==================================================================== */
-
-extern const serf_bucket_type_t serf_bucket_type_bwtp_frame;
-#define SERF_BUCKET_IS_BWTP_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_frame)
-
-extern const serf_bucket_type_t serf_bucket_type_bwtp_incoming_frame;
-#define SERF_BUCKET_IS_BWTP_INCOMING_FRAME(b) SERF_BUCKET_CHECK((b), bwtp_incoming_frame)
-
-int serf_bucket_bwtp_frame_get_channel(
-    serf_bucket_t *hdr);
-
-int serf_bucket_bwtp_frame_get_type(
-    serf_bucket_t *hdr);
-
-const char *serf_bucket_bwtp_frame_get_phrase(
-    serf_bucket_t *hdr);
-
-serf_bucket_t *serf_bucket_bwtp_frame_get_headers(
-    serf_bucket_t *hdr);
-
-serf_bucket_t *serf_bucket_bwtp_channel_open(
-    int channel,
-    const char *URI,
-    serf_bucket_alloc_t *allocator);
-
-serf_bucket_t *serf_bucket_bwtp_channel_close(
-    int channel,
-    serf_bucket_alloc_t *allocator);
-
-serf_bucket_t *serf_bucket_bwtp_header_create(
-    int channel,
-    const char *phrase,
-    serf_bucket_alloc_t *allocator);
-
-serf_bucket_t *serf_bucket_bwtp_message_create(
-    int channel,
-    serf_bucket_t *body,
-    serf_bucket_alloc_t *allocator);
-
-serf_bucket_t *serf_bucket_bwtp_incoming_frame_create(
-    serf_bucket_t *bkt,
-    serf_bucket_alloc_t *allocator);
-
-apr_status_t serf_bucket_bwtp_incoming_frame_wait_for_headers(
-    serf_bucket_t *bkt);
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_aggregate;
-#define SERF_BUCKET_IS_AGGREGATE(b) SERF_BUCKET_CHECK((b), aggregate)
-
-typedef apr_status_t (*serf_bucket_aggregate_eof_t)(
-    void *baton,
-    serf_bucket_t *aggregate_bucket);
-
-/** serf_bucket_aggregate_cleanup will instantly destroy all buckets in
-    the aggregate bucket that have been read completely. Whereas normally, 
-    these buckets are destroyed on every read operation. */ 
-void serf_bucket_aggregate_cleanup(
-    serf_bucket_t *bucket,
-    serf_bucket_alloc_t *allocator);
-
-serf_bucket_t *serf_bucket_aggregate_create(
-    serf_bucket_alloc_t *allocator);
-
-/* Creates a stream bucket.
-   A stream bucket is like an aggregate bucket, but:
-   - it doesn't destroy its child buckets on cleanup
-   - one can always keep adding child buckets, the handler FN should return
-     APR_EOF when no more buckets will be added.
-
-  Note: keep this factory function internal for now. If it turns out this
-  bucket type is useful outside serf, we should make it an actual separate
-  type.
-  */
-serf_bucket_t *serf__bucket_stream_create(
-    serf_bucket_alloc_t *allocator,
-    serf_bucket_aggregate_eof_t fn,
-    void *baton);
-
-/** Transform @a bucket in-place into an aggregate bucket.
- *
- * It is callers responsibility to free resources held by the original
- * bucket */
-void serf_bucket_aggregate_become(
-    serf_bucket_t *bucket);
-
-void serf_bucket_aggregate_prepend(
-    serf_bucket_t *aggregate_bucket,
-    serf_bucket_t *prepend_bucket);
-
-void serf_bucket_aggregate_append(
-    serf_bucket_t *aggregate_bucket,
-    serf_bucket_t *append_bucket);
-    
-void serf_bucket_aggregate_hold_open(
-    serf_bucket_t *aggregate_bucket,
-    serf_bucket_aggregate_eof_t fn,
-    void *baton);
-
-void serf_bucket_aggregate_prepend_iovec(
-    serf_bucket_t *aggregate_bucket,
-    struct iovec *vecs,
-    int vecs_count);
-
-void serf_bucket_aggregate_append_iovec(
-    serf_bucket_t *aggregate_bucket,
-    struct iovec *vecs,
-    int vecs_count);
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_file;
-#define SERF_BUCKET_IS_FILE(b) SERF_BUCKET_CHECK((b), file)
-
-serf_bucket_t *serf_bucket_file_create(
-    apr_file_t *file,
-    serf_bucket_alloc_t *allocator);
-
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_socket;
-#define SERF_BUCKET_IS_SOCKET(b) SERF_BUCKET_CHECK((b), socket)
-
-serf_bucket_t *serf_bucket_socket_create(
-    apr_socket_t *skt,
-    serf_bucket_alloc_t *allocator);
-
-/**
- * Call @a progress_func every time bytes are read from the socket, pass
- * the number of bytes read.
- *
- * When using serf's bytes read & written progress indicator, pass 
- * @a serf_context_progress_delta for progress_func and the serf_context for
- * progress_baton.
- */
-void serf_bucket_socket_set_read_progress_cb(
-    serf_bucket_t *bucket,
-    const serf_progress_t progress_func,
-    void *progress_baton);
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_simple;
-#define SERF_BUCKET_IS_SIMPLE(b) SERF_BUCKET_CHECK((b), simple)
-
-typedef void (*serf_simple_freefunc_t)(
-    void *baton,
-    const char *data);
-
-serf_bucket_t *serf_bucket_simple_create(
-    const char *data,
-    apr_size_t len,
-    serf_simple_freefunc_t freefunc,
-    void *freefunc_baton,
-    serf_bucket_alloc_t *allocator);
-
-/**
- * Equivalent to serf_bucket_simple_create, except that the bucket takes
- * ownership of a private copy of the data.
- */
-serf_bucket_t *serf_bucket_simple_copy_create(
-    const char *data,
-    apr_size_t len,
-    serf_bucket_alloc_t *allocator);
-
-/**
- * Equivalent to serf_bucket_simple_create, except that the bucket assumes
- * responsibility for freeing the data on this allocator without making
- * a copy.  It is assumed that data was created by a call from allocator.
- */
-serf_bucket_t *serf_bucket_simple_own_create(
-    const char *data,
-    apr_size_t len,
-    serf_bucket_alloc_t *allocator);
-
-#define SERF_BUCKET_SIMPLE_STRING(s,a) \
-    serf_bucket_simple_create(s, strlen(s), NULL, NULL, a);
-
-#define SERF_BUCKET_SIMPLE_STRING_LEN(s,l,a) \
-    serf_bucket_simple_create(s, l, NULL, NULL, a);
-
-/* ==================================================================== */
-
-
-/* Note: apr_mmap_t is always defined, but if APR doesn't have mmaps, then
-   the caller can never create an apr_mmap_t to pass to this function. */
-
-extern const serf_bucket_type_t serf_bucket_type_mmap;
-#define SERF_BUCKET_IS_MMAP(b) SERF_BUCKET_CHECK((b), mmap)
-
-serf_bucket_t *serf_bucket_mmap_create(
-    apr_mmap_t *mmap,
-    serf_bucket_alloc_t *allocator);
-
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_headers;
-#define SERF_BUCKET_IS_HEADERS(b) SERF_BUCKET_CHECK((b), headers)
-
-serf_bucket_t *serf_bucket_headers_create(
-    serf_bucket_alloc_t *allocator);
-
-/**
- * Set, default: value copied.
- *
- * Set the specified @a header within the bucket, copying the @a value
- * into space from this bucket's allocator. The header is NOT copied,
- * so it should remain in scope at least as long as the bucket.
- */
-void serf_bucket_headers_set(
-    serf_bucket_t *headers_bucket,
-    const char *header,
-    const char *value);
-
-/**
- * Set, copies: header and value copied.
- *
- * Copy the specified @a header and @a value into the bucket, using space
- * from this bucket's allocator.
- */
-void serf_bucket_headers_setc(
-    serf_bucket_t *headers_bucket,
-    const char *header,
-    const char *value);
-
-/**
- * Set, no copies.
- *
- * Set the specified @a header and @a value into the bucket, without
- * copying either attribute. Both attributes should remain in scope at
- * least as long as the bucket.
- *
- * @note In the case where a header already exists this will result
- *       in a reallocation and copy, @see serf_bucket_headers_setn.
- */
-void serf_bucket_headers_setn(
-    serf_bucket_t *headers_bucket,
-    const char *header,
-    const char *value);
-
-/**
- * Set, extended: fine grained copy control of header and value.
- *
- * Set the specified @a header, with length @a header_size with the
- * @a value, and length @a value_size, into the bucket. The header will
- * be copied if @a header_copy is set, and the value is copied if
- * @a value_copy is set. If the values are not copied, then they should
- * remain in scope at least as long as the bucket.
- *
- * If @a headers_bucket already contains a header with the same name
- * as @a header, then append @a value to the existing value,
- * separating with a comma (as per RFC 2616, section 4.2).  In this
- * case, the new value must be allocated and the header re-used, so
- * behave as if @a value_copy were true and @a header_copy false.
- */
-void serf_bucket_headers_setx(
-    serf_bucket_t *headers_bucket,
-    const char *header,
-    apr_size_t header_size,
-    int header_copy,
-    const char *value,
-    apr_size_t value_size,
-    int value_copy);
-
-const char *serf_bucket_headers_get(
-    serf_bucket_t *headers_bucket,
-    const char *header);
-
-/**
- * @param baton opaque baton as passed to @see serf_bucket_headers_do
- * @param key The header key from this iteration through the table
- * @param value The header value from this iteration through the table
- */
-typedef int (serf_bucket_headers_do_callback_fn_t)(
-    void *baton,
-    const char *key,
-    const char *value);
-
-/**
- * Iterates over all headers of the message and invokes the callback 
- * function with header key and value. Stop iterating when no more
- * headers are available or when the callback function returned a 
- * non-0 value.
- *
- * @param headers_bucket headers to iterate over
- * @param func callback routine to invoke for every header in the bucket
- * @param baton baton to pass on each invocation to func
- */
-void serf_bucket_headers_do(
-    serf_bucket_t *headers_bucket,
-    serf_bucket_headers_do_callback_fn_t func,
-    void *baton);
-
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_chunk;
-#define SERF_BUCKET_IS_CHUNK(b) SERF_BUCKET_CHECK((b), chunk)
-
-serf_bucket_t *serf_bucket_chunk_create(
-    serf_bucket_t *stream,
-    serf_bucket_alloc_t *allocator);
-
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_dechunk;
-#define SERF_BUCKET_IS_DECHUNK(b) SERF_BUCKET_CHECK((b), dechunk)
-
-serf_bucket_t *serf_bucket_dechunk_create(
-    serf_bucket_t *stream,
-    serf_bucket_alloc_t *allocator);
-
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_deflate;
-#define SERF_BUCKET_IS_DEFLATE(b) SERF_BUCKET_CHECK((b), deflate)
-
-#define SERF_DEFLATE_GZIP 0
-#define SERF_DEFLATE_DEFLATE 1
-
-serf_bucket_t *serf_bucket_deflate_create(
-    serf_bucket_t *stream,
-    serf_bucket_alloc_t *allocator,
-    int format);
-
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_limit;
-#define SERF_BUCKET_IS_LIMIT(b) SERF_BUCKET_CHECK((b), limit)
-
-serf_bucket_t *serf_bucket_limit_create(
-    serf_bucket_t *stream,
-    apr_uint64_t limit,
-    serf_bucket_alloc_t *allocator);
-
-
-/* ==================================================================== */
-#define SERF_SSL_CERT_NOTYETVALID       0x0001
-#define SERF_SSL_CERT_EXPIRED           0x0002
-#define SERF_SSL_CERT_UNKNOWNCA         0x0004
-#define SERF_SSL_CERT_SELF_SIGNED       0x0008
-#define SERF_SSL_CERT_UNKNOWN_FAILURE   0x0010
-#define SERF_SSL_CERT_REVOKED           0x0020
-#define SERF_SSL_CERT_UNABLE_TO_GET_CRL 0x0040
-#define SERF_SSL_CERT_INVALID_HOST      0x0080
-
-#define SERF_SSL_OCSP_RESPONDER_TRYLATER        0x0100
-#define SERF_SSL_OCSP_RESPONDER_ERROR           0x0200
-#define SERF_SSL_OCSP_RESPONDER_UNKNOWN_FAILURE 0x0400
-
-extern const serf_bucket_type_t serf_bucket_type_ssl_encrypt;
-#define SERF_BUCKET_IS_SSL_ENCRYPT(b) SERF_BUCKET_CHECK((b), ssl_encrypt)
-
-typedef struct serf_ssl_context_t serf_ssl_context_t;
-typedef struct serf_ssl_certificate_t serf_ssl_certificate_t;
-
-typedef apr_status_t (*serf_ssl_need_client_cert_t)(
-    void *data,
-    const char **cert_path);
-
-typedef apr_status_t (*serf_ssl_need_cert_password_t)(
-    void *data,
-    const char *cert_path,
-    const char **password);
-
-/* Callback type for server certificate status info and OCSP responses.
-   Note that CERT can be NULL in case its called from the OCSP callback. */
-typedef apr_status_t (*serf_ssl_need_server_cert_t)(
-    void *data, 
-    int failures,
-    const serf_ssl_certificate_t *cert);
-
-typedef apr_status_t (*serf_ssl_server_cert_chain_cb_t)(
-    void *data,
-    int failures,
-    int error_depth,
-    const serf_ssl_certificate_t * const * certs,
-    apr_size_t certs_len);
-
-void serf_ssl_client_cert_provider_set(
-    serf_ssl_context_t *context,
-    serf_ssl_need_client_cert_t callback,
-    void *data,
-    void *cache_pool);
-
-void serf_ssl_client_cert_password_set(
-    serf_ssl_context_t *context,
-    serf_ssl_need_cert_password_t callback,
-    void *data,
-    void *cache_pool);
-
-/**
- * Set a callback to override the default SSL server certificate validation 
- * algorithm.
- */
-void serf_ssl_server_cert_callback_set(
-    serf_ssl_context_t *context,
-    serf_ssl_need_server_cert_t callback,
-    void *data);
-
-/**
- * Set callbacks to override the default SSL server certificate validation 
- * algorithm for the current certificate or the entire certificate chain. 
- */
-void serf_ssl_server_cert_chain_callback_set(
-    serf_ssl_context_t *context,
-    serf_ssl_need_server_cert_t cert_callback,
-    serf_ssl_server_cert_chain_cb_t cert_chain_callback,
-    void *data);
-
-/**
- * Use the default root CA certificates as included with the OpenSSL library.
- */
-apr_status_t serf_ssl_use_default_certificates(
-    serf_ssl_context_t *context);
-
-/**
- * Allow SNI indicators to be sent to the server.
- */
-apr_status_t serf_ssl_set_hostname(
-    serf_ssl_context_t *context, const char *hostname);
-
-
-typedef apr_status_t (*serf_ssl_protocol_result_cb_t)(
-    void *data,
-    const char *protocol);
-
-/**
- * Enables ALPN negotiation with the server. Setups that the supported protocols
- * will be sent to the server, and enables handling the response via a callback.
- *
- * SUPPORTED_PROTOCOLS is a comma separated list of protocols. No whitespace
- * should be added as the values are used literally. E.g. "h2,http/1.1,h2-16"
- *
- * Returns APR_ENOTIMPL when the ssl library doesn't implement ALPN.
- *
- * If successfull CALLBACK will be called as soon as the protocol is negotiated
- * or directly after the secured stream is connected.
- *
- * @since New in 1.4.
- */
-apr_status_t serf_ssl_negotiate_protocol(
-    serf_ssl_context_t *context,
-    const char *protocols,
-    serf_ssl_protocol_result_cb_t callback,
-    void *callback_data);
-
-/**
- * Return the depth of the certificate.
- */
-int serf_ssl_cert_depth(
-    const serf_ssl_certificate_t *cert);
-
-/**
- * Extract the fields of the issuer in a table with keys (E, CN, OU, O, L, 
- * ST and C). The returned table will be allocated in @a pool.
- */
-apr_hash_t *serf_ssl_cert_issuer(
-    const serf_ssl_certificate_t *cert,
-    apr_pool_t *pool);
-
-/**
- * Extract the fields of the subject in a table with keys (E, CN, OU, O, L, 
- * ST and C). The returned table will be allocated in @a pool.
- */
-apr_hash_t *serf_ssl_cert_subject(
-    const serf_ssl_certificate_t *cert,
-    apr_pool_t *pool);
-
-/**
- * Extract the fields of the certificate in a table with keys (sha1, notBefore,
- * notAfter, subjectAltName). The returned table will be allocated in @a pool.
- */
-apr_hash_t *serf_ssl_cert_certificate(
-    const serf_ssl_certificate_t *cert,
-    apr_pool_t *pool);
-
-/**
- * Export a certificate to base64-encoded, zero-terminated string.
- * The returned string is allocated in @a pool. Returns NULL on failure.
- */
-const char *serf_ssl_cert_export(
-    const serf_ssl_certificate_t *cert,
-    apr_pool_t *pool);
-
-/**
- * Load a CA certificate file from a path @a file_path. If the file was loaded
- * and parsed correctly, a certificate @a cert will be created and returned.
- * This certificate object will be alloced in @a pool.
- */
-apr_status_t serf_ssl_load_cert_file(
-    serf_ssl_certificate_t **cert,
-    const char *file_path,
-    apr_pool_t *pool);
-
-/**
- * Adds the certificate @a cert to the list of trusted certificates in 
- * @a ssl_ctx that will be used for verification. 
- * See also @a serf_ssl_load_cert_file.
- */
-apr_status_t serf_ssl_trust_cert(
-    serf_ssl_context_t *ssl_ctx,
-    serf_ssl_certificate_t *cert);
-
-/** 
- * Load a CRL .pem file from @a file_path and enable CRL checking.
- */
-apr_status_t serf_ssl_add_crl_from_file(serf_ssl_context_t *ssl_ctx,
-                                        const char *file_path,
-                                        apr_pool_t *pool);
-
-/**
- * Enable or disable CRL checking of all server certificates.
- * @a enabled = 1 to enable CRL checking, 0 to disable CRL checking.
- * Default = disabled.
- */
-apr_status_t serf_ssl_check_crl(serf_ssl_context_t *ssl_ctx,
-                                int enabled);
-
-/**
- * Enable or disable certificate status request (OCSP stapling) checking of all
- * server certificates.
- * @a enabled = 1 to enable checking, 0 to disable checking.
- * Default = disabled.
- */
-apr_status_t
-serf_ssl_check_cert_status_request(serf_ssl_context_t *ssl_ctx, int enabled);
-
-/**
- * Enable or disable SSL compression on a SSL session.
- * @a enabled = 1 to enable compression, 0 to disable compression.
- * Default = disabled.
- */
-apr_status_t serf_ssl_use_compression(
-    serf_ssl_context_t *ssl_ctx,
-    int enabled);
-
-serf_bucket_t *serf_bucket_ssl_encrypt_create(
-    serf_bucket_t *stream,
-    serf_ssl_context_t *ssl_context,
-    serf_bucket_alloc_t *allocator);
-
-serf_ssl_context_t *serf_bucket_ssl_encrypt_context_get(
-    serf_bucket_t *bucket);
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_ssl_decrypt;
-#define SERF_BUCKET_IS_SSL_DECRYPT(b) SERF_BUCKET_CHECK((b), ssl_decrypt)
-
-serf_bucket_t *serf_bucket_ssl_decrypt_create(
-    serf_bucket_t *stream,
-    serf_ssl_context_t *ssl_context,
-    serf_bucket_alloc_t *allocator);
-
-serf_ssl_context_t *serf_bucket_ssl_decrypt_context_get(
-    serf_bucket_t *bucket);
-
-
-/* ==================================================================== */
-
-
-extern const serf_bucket_type_t serf_bucket_type_barrier;
-#define SERF_BUCKET_IS_BARRIER(b) SERF_BUCKET_CHECK((b), barrier)
-
-serf_bucket_t *serf_bucket_barrier_create(
-    serf_bucket_t *stream,
-    serf_bucket_alloc_t *allocator);
-
-
-/* ==================================================================== */
-
-extern const serf_bucket_type_t serf_bucket_type_iovec;
-#define SERF_BUCKET_IS_IOVEC(b) SERF_BUCKET_CHECK((b), iovec)
-
-serf_bucket_t *serf_bucket_iovec_create(
-    struct iovec vecs[],
-    int len,
-    serf_bucket_alloc_t *allocator);
-
-/* ==================================================================== */
-
-extern const serf_bucket_type_t serf_bucket_type_copy;
-#define SERF_BUCKET_IS_COPY(b) SERF_BUCKET_CHECK((b), copy)
-
-serf_bucket_t *serf_bucket_copy_create(
-    serf_bucket_t *wrapped,
-    apr_size_t min_size,
-    serf_bucket_alloc_t *allocator);
-
-/* ==================================================================== */
-
-extern const serf_bucket_type_t serf_bucket_type_http2_unframe;
-#define SERF_BUCKET_IS_HTTP2_UNFRAME(b) SERF_BUCKET_CHECK((b), http2_unframe)
+extern const serf_bucket_type_t serf_bucket_type__http2_unframe;
+#define SERF__BUCKET_IS_HTTP2_UNFRAME(b) SERF_BUCKET_CHECK((b), _http2_unframe)
 
 serf_bucket_t *
-serf_bucket_http2_unframe_create(serf_bucket_t *stream,
-                                 int destroy_stream,
-                                 apr_size_t max_payload_size,
-                                 serf_bucket_alloc_t *allocator);
+serf__bucket_http2_unframe_create(serf_bucket_t *stream,
+                                  int destroy_stream,
+                                  apr_size_t max_payload_size,
+                                  serf_bucket_alloc_t *allocator);
 
 /* Obtains the frame header state, reading from the bucket if necessary.
    If the header was read successfully (or was already read before calling)
@@ -773,31 +52,31 @@ serf_bucket_http2_unframe_create(serf_bu
    returns APR_SUCCESS when the header was already read before calling this,
    function. Otherwise it will return the result of reading. */
 apr_status_t
-serf_bucket_http2_unframe_read_info(serf_bucket_t *bucket,
-                                    apr_int32_t *stream_id,
-                                    unsigned char *frame_type,
-                                    unsigned char *flags);
+serf__bucket_http2_unframe_read_info(serf_bucket_t *bucket,
+                                     apr_int32_t *stream_id,
+                                     unsigned char *frame_type,
+                                     unsigned char *flags);
 
 /* ==================================================================== */
 
-extern const serf_bucket_type_t serf_bucket_type_http2_unpad;
-#define SERF_BUCKET_IS_HTTP2_UNPAD(b) SERF_BUCKET_CHECK((b), http2_unpad)
+extern const serf_bucket_type_t serf_bucket_type__http2_unpad;
+#define SERF__BUCKET_IS_HTTP2_UNPAD(b) SERF_BUCKET_CHECK((b), _http2_unpad)
 
 serf_bucket_t *
-serf_bucket_http2_unpad_create(serf_bucket_t *stream,
-                               int destroy_stream,
-                               serf_bucket_alloc_t *allocator);
+serf__bucket_http2_unpad_create(serf_bucket_t *stream,
+                                int destroy_stream,
+                                serf_bucket_alloc_t *allocator);
 
 /* ==================================================================== */
 
-extern const serf_bucket_type_t serf_bucket_type_hpack;
-#define SERF_BUCKET_IS_HPACK(b) SERF_BUCKET_CHECK((b), hpack)
+extern const serf_bucket_type_t serf_bucket_type__hpack;
+#define SERF_BUCKET_IS_HPACK(b) SERF_BUCKET_CHECK((b), _hpack)
 
 typedef struct serf_hpack_table_t serf_hpack_table_t;
 
 serf_bucket_t *
-serf_bucket_hpack_create(serf_hpack_table_t *hpack_table,
-                         serf_bucket_alloc_t *allocator);
+serf__bucket_hpack_create(serf_hpack_table_t *hpack_table,
+                          serf_bucket_alloc_t *allocator);
 
 /**
  * Set, copies: header and value copied.
@@ -805,9 +84,9 @@ serf_bucket_hpack_create(serf_hpack_tabl
  * Copy the specified @a header and @a value into the bucket, using space
  * from this bucket's allocator.
  */
-void serf_bucket_hpack_setc(serf_bucket_t *hpack_bucket,
-                            const char *key,
-                            const char *value);
+void serf__bucket_hpack_setc(serf_bucket_t *hpack_bucket,
+                             const char *key,
+                             const char *value);
 
 /**
  * Set, extended: fine grained copy control of key and value.
@@ -824,16 +103,18 @@ void serf_bucket_hpack_setc(serf_bucket_
  * case, the new value must be allocated and the header re-used, so
  * behave as if @a value_copy were true and @a header_copy false.
  */
-void serf_bucket_hpack_setx(serf_bucket_t *hpack_bucket,
-                            const char *key,
-                            apr_size_t key_size,
-                            int header_copy,
-                            const char *value,
-                            apr_size_t value_size,
-                            int value_copy);
-
-const char *serf_bucket_hpack_getc(serf_bucket_t *hpack_bucket,
-                                   const char *key);
+void
+serf__bucket_hpack_setx(serf_bucket_t *hpack_bucket,
+                        const char *key,
+                        apr_size_t key_size,
+                        int header_copy,
+                        const char *value,
+                        apr_size_t value_size,
+                        int value_copy);
+
+const char *
+serf__bucket_hpack_getc(serf_bucket_t *hpack_bucket,
+                        const char *key);
 
 /**
  * @param baton opaque baton as passed to @see serf_bucket_hpack_do
@@ -856,17 +137,18 @@ typedef int (serf_bucket_hpack_do_callba
  * @param func callback routine to invoke for every header in the bucket
  * @param baton baton to pass on each invocation to func
  */
-void serf_bucket_hpack_do(serf_bucket_t *hpack_bucket,
-                          serf_bucket_hpack_do_callback_fn_t func,
-                          void *baton);
+void
+serf__bucket_hpack_do(serf_bucket_t *hpack_bucket,
+                     serf_bucket_hpack_do_callback_fn_t func,
+                     void *baton);
 
 serf_hpack_table_t *
-serf_hpack_table_create(int for_http2,
-                        apr_size_t default_max_table_size,
-                        apr_pool_t *result_pool);
+serf__hpack_table_create(int for_http2,
+                         apr_size_t default_max_table_size,
+                         apr_pool_t *result_pool);
 
 /* ==================================================================== */
-extern const serf_bucket_type_t serf_bucket_type_hpack_decode;
+extern const serf_bucket_type_t serf_bucket_type__hpack_decode;
 #define SERF_BUCKET_IS_HPACK_DECODE(b) SERF_BUCKET_CHECK((b), hpack_decode)
 
 /* If ITEM_CALLBACK is not null calls it for every item while reading, and
@@ -877,52 +159,50 @@ extern const serf_bucket_type_t serf_buc
    the result as the start of the result for a response_bucket.
  */
 serf_bucket_t *
-serf_bucket_hpack_decode_create(serf_bucket_t *stream,
-                                apr_status_t(*item_callback)(
+serf__bucket_hpack_decode_create(serf_bucket_t *stream,
+                                 apr_status_t(*item_callback)(
                                                   void *baton,
                                                   const char *key,
                                                   apr_size_t key_size,
                                                   const char *value,
                                                   apr_size_t value_size),
-                                void *item_baton,
-                                apr_size_t max_entry_size,
-                                serf_hpack_table_t *hpack_table,
-                                serf_bucket_alloc_t *alloc);
+                                 void *item_baton,
+                                 apr_size_t max_entry_size,
+                                 serf_hpack_table_t *hpack_table,
+                                 serf_bucket_alloc_t *alloc);
 
 /* ==================================================================== */
-extern const serf_bucket_type_t serf_bucket_type_http2_frame;
+extern const serf_bucket_type_t serf_bucket_type__http2_frame;
 
-#define SERF_BUCKET_IS_HTTP2_FRAME(b) SERF_BUCKET_CHECK((b), http2_frame)
+#define SERF__BUCKET_IS_HTTP2_FRAME(b) SERF_BUCKET_CHECK((b), _http2_frame)
 
 serf_bucket_t *
-serf_bucket_http2_frame_create(serf_bucket_t *stream,
-                               unsigned char frame_type,
-                               unsigned char flags,
-                               apr_int32_t *stream_id,
-                               void(*stream_id_alloc)(
-                                 void *baton,
-                                 apr_int32_t *stream_id),
-                               void *stream_id_baton,
-                               apr_size_t max_payload_size,
-                               apr_int32_t(*alloc_window)(
-                                 void *baton,
-                                 unsigned char frametype,
-                                 apr_int32_t stream_id,
-                                 apr_size_t requested,
-                                 int peek),
-                               void *alloc_window_baton,
-                               serf_bucket_alloc_t *alloc);
+serf__bucket_http2_frame_create(serf_bucket_t *stream,
+                                unsigned char frame_type,
+                                unsigned char flags,
+                                apr_int32_t *stream_id,
+                                void(*stream_id_alloc)(
+                                      void *baton,
+                                      apr_int32_t *stream_id),
+                                void *stream_id_baton,
+                                apr_size_t max_payload_size,
+                                apr_int32_t(*alloc_window)(
+                                      void *baton,
+                                      unsigned char frametype,
+                                      apr_int32_t stream_id,
+                                      apr_size_t requested,
+                                      int peek),
+                                void *alloc_window_baton,
+                                serf_bucket_alloc_t *alloc);
 
 int
-serf_bucket_http2_frame_within_frame(serf_bucket_t *bucket);
+serf__bucket_http2_frame_within_frame(serf_bucket_t *bucket);
 
 /* ==================================================================== */
 
-/* ### do we need a PIPE bucket type? they are simple apr_file_t objects */
-
-
 #ifdef __cplusplus
 }
 #endif
 
-#endif	/* !SERF_BUCKET_TYPES_H */
+#endif /* !SERF_PROTOCOL_HTTP2_BUCKETS_H */
+

Modified: serf/trunk/serf_bucket_types.h
URL: http://svn.apache.org/viewvc/serf/trunk/serf_bucket_types.h?rev=1710686&r1=1710685&r2=1710686&view=diff
==============================================================================
--- serf/trunk/serf_bucket_types.h (original)
+++ serf/trunk/serf_bucket_types.h Mon Oct 26 20:15:02 2015
@@ -756,168 +756,6 @@ serf_bucket_t *serf_bucket_copy_create(
 
 /* ==================================================================== */
 
-extern const serf_bucket_type_t serf_bucket_type_http2_unframe;
-#define SERF_BUCKET_IS_HTTP2_UNFRAME(b) SERF_BUCKET_CHECK((b), http2_unframe)
-
-serf_bucket_t *
-serf_bucket_http2_unframe_create(serf_bucket_t *stream,
-                                 int destroy_stream,
-                                 apr_size_t max_payload_size,
-                                 serf_bucket_alloc_t *allocator);
-
-/* Obtains the frame header state, reading from the bucket if necessary.
-   If the header was read successfully (or was already read before calling)
-   the *stream_id, * frame_type and *flags values (when not pointing to NULL)
-   will be set to the requested values.
-
-   returns APR_SUCCESS when the header was already read before calling this,
-   function. Otherwise it will return the result of reading. */
-apr_status_t
-serf_bucket_http2_unframe_read_info(serf_bucket_t *bucket,
-                                    apr_int32_t *stream_id,
-                                    unsigned char *frame_type,
-                                    unsigned char *flags);
-
-/* ==================================================================== */
-
-extern const serf_bucket_type_t serf_bucket_type_http2_unpad;
-#define SERF_BUCKET_IS_HTTP2_UNPAD(b) SERF_BUCKET_CHECK((b), http2_unpad)
-
-serf_bucket_t *
-serf_bucket_http2_unpad_create(serf_bucket_t *stream,
-                               int destroy_stream,
-                               serf_bucket_alloc_t *allocator);
-
-/* ==================================================================== */
-
-extern const serf_bucket_type_t serf_bucket_type_hpack;
-#define SERF_BUCKET_IS_HPACK(b) SERF_BUCKET_CHECK((b), hpack)
-
-typedef struct serf_hpack_table_t serf_hpack_table_t;
-
-serf_bucket_t *
-serf_bucket_hpack_create(serf_hpack_table_t *hpack_table,
-                         serf_bucket_alloc_t *allocator);
-
-/**
- * Set, copies: header and value copied.
- *
- * Copy the specified @a header and @a value into the bucket, using space
- * from this bucket's allocator.
- */
-void serf_bucket_hpack_setc(serf_bucket_t *hpack_bucket,
-                            const char *key,
-                            const char *value);
-
-/**
- * Set, extended: fine grained copy control of key and value.
- *
- * Set the specified @a key, with length @a key_size with the
- * @a value, and length @a value_size, into the bucket. The header will
- * be copied if @a header_copy is set, and the value is copied if
- * @a value_copy is set. If the values are not copied, then they should
- * remain in scope at least as long as the bucket.
- *
- * If @a headers_bucket already contains a header with the same name
- * as @a header, then append @a value to the existing value,
- * separating with a comma (as per RFC 2616, section 4.2).  In this
- * case, the new value must be allocated and the header re-used, so
- * behave as if @a value_copy were true and @a header_copy false.
- */
-void serf_bucket_hpack_setx(serf_bucket_t *hpack_bucket,
-                            const char *key,
-                            apr_size_t key_size,
-                            int header_copy,
-                            const char *value,
-                            apr_size_t value_size,
-                            int value_copy);
-
-const char *serf_bucket_hpack_getc(serf_bucket_t *hpack_bucket,
-                                   const char *key);
-
-/**
- * @param baton opaque baton as passed to @see serf_bucket_hpack_do
- * @param key The header key from this iteration through the table
- * @param value The header value from this iteration through the table
- */
-typedef int (serf_bucket_hpack_do_callback_fn_t)(void *baton,
-                                                 const char *key,
-                                                 apr_size_t keylen,
-                                                 const char *value,
-                                                 apr_size_t value_len);
-
-/**
- * Iterates over all headers of the message and invokes the callback 
- * function with header key and value. Stop iterating when no more
- * headers are available or when the callback function returned a 
- * non-0 value.
- *
- * @param headers_bucket headers to iterate over
- * @param func callback routine to invoke for every header in the bucket
- * @param baton baton to pass on each invocation to func
- */
-void serf_bucket_hpack_do(serf_bucket_t *hpack_bucket,
-                          serf_bucket_hpack_do_callback_fn_t func,
-                          void *baton);
-
-serf_hpack_table_t *
-serf_hpack_table_create(int for_http2,
-                        apr_size_t default_max_table_size,
-                        apr_pool_t *result_pool);
-
-/* ==================================================================== */
-extern const serf_bucket_type_t serf_bucket_type_hpack_decode;
-#define SERF_BUCKET_IS_HPACK_DECODE(b) SERF_BUCKET_CHECK((b), hpack_decode)
-
-/* If ITEM_CALLBACK is not null calls it for every item while reading, and
-   the bucket will just return no data and APR_EAGAIN until done.
-
-   If ITEM_CALLBACK is NULL, the bucket will read as a HTTP/1 like header block,
-   starting with a status line and ending with "\r\n\r\n", which allows using
-   the result as the start of the result for a response_bucket.
- */
-serf_bucket_t *
-serf_bucket_hpack_decode_create(serf_bucket_t *stream,
-                                apr_status_t(*item_callback)(
-                                                  void *baton,
-                                                  const char *key,
-                                                  apr_size_t key_size,
-                                                  const char *value,
-                                                  apr_size_t value_size),
-                                void *item_baton,
-                                apr_size_t max_entry_size,
-                                serf_hpack_table_t *hpack_table,
-                                serf_bucket_alloc_t *alloc);
-
-/* ==================================================================== */
-extern const serf_bucket_type_t serf_bucket_type_http2_frame;
-
-#define SERF_BUCKET_IS_HTTP2_FRAME(b) SERF_BUCKET_CHECK((b), http2_frame)
-
-serf_bucket_t *
-serf_bucket_http2_frame_create(serf_bucket_t *stream,
-                               unsigned char frame_type,
-                               unsigned char flags,
-                               apr_int32_t *stream_id,
-                               void(*stream_id_alloc)(
-                                 void *baton,
-                                 apr_int32_t *stream_id),
-                               void *stream_id_baton,
-                               apr_size_t max_payload_size,
-                               apr_int32_t(*alloc_window)(
-                                 void *baton,
-                                 unsigned char frametype,
-                                 apr_int32_t stream_id,
-                                 apr_size_t requested,
-                                 int peek),
-                               void *alloc_window_baton,
-                               serf_bucket_alloc_t *alloc);
-
-int
-serf_bucket_http2_frame_within_frame(serf_bucket_t *bucket);
-
-/* ==================================================================== */
-
 /* ### do we need a PIPE bucket type? they are simple apr_file_t objects */
 
 

Modified: serf/trunk/serf_private.h
URL: http://svn.apache.org/viewvc/serf/trunk/serf_private.h?rev=1710686&r1=1710685&r2=1710686&view=diff
==============================================================================
--- serf/trunk/serf_private.h (original)
+++ serf/trunk/serf_private.h Mon Oct 26 20:15:02 2015
@@ -543,6 +543,8 @@ serf_bucket_t *serf__bucket_log_wrapper_
 /* From http2_protocol.c: Initializes http2 state on connection */
 void serf__http2_protocol_init(serf_connection_t *conn);
 
+typedef struct serf_hpack_table_t serf_hpack_table_t;
+
 /* From http2_hpack_buckets.c */
 apr_status_t serf__hpack_huffman_decode(const unsigned char *encoded,
                                         apr_size_t encoded_len,

Modified: serf/trunk/test/test_buckets.c
URL: http://svn.apache.org/viewvc/serf/trunk/test/test_buckets.c?rev=1710686&r1=1710685&r2=1710686&view=diff
==============================================================================
--- serf/trunk/test/test_buckets.c (original)
+++ serf/trunk/test/test_buckets.c Mon Oct 26 20:15:02 2015
@@ -33,6 +33,8 @@
 #include "serf_private.h"
 #include "serf_bucket_util.h"
 
+#include "protocols/http2_buckets.h"
+
 static apr_status_t read_all(serf_bucket_t *bkt,
                              char *buf,
                              apr_size_t buf_len,
@@ -1779,10 +1781,10 @@ static void test_http2_unframe_buckets(C
   raw = serf_bucket_simple_create(raw_frame1, sizeof(raw_frame1),
                                   NULL, NULL, alloc);
 
-  unframe = serf_bucket_http2_unframe_create(raw, TRUE, SERF_READ_ALL_AVAIL,
-                                             alloc);
+  unframe = serf__bucket_http2_unframe_create(raw, TRUE, SERF_READ_ALL_AVAIL,
+                                              alloc);
 
-  CuAssertTrue(tc, SERF_BUCKET_IS_HTTP2_UNFRAME(unframe));
+  CuAssertTrue(tc, SERF__BUCKET_IS_HTTP2_UNFRAME(unframe));
 
   status = read_all(unframe, result1, sizeof(result1), &read_len);
   CuAssertIntEquals(tc, APR_EOF, status);
@@ -1796,10 +1798,10 @@ static void test_http2_unframe_buckets(C
     unsigned char frame_type, flags;
 
     CuAssertIntEquals(tc, 0,
-                      serf_bucket_http2_unframe_read_info(unframe,
-                                                          &stream_id,
-                                                          &frame_type,
-                                                          &flags));
+                      serf__bucket_http2_unframe_read_info(unframe,
+                                                           &stream_id,
+                                                           &frame_type,
+                                                           &flags));
     CuAssertIntEquals(tc, 0, stream_id);
     CuAssertIntEquals(tc, 4, frame_type);
     CuAssertIntEquals(tc, 0, flags);
@@ -1808,8 +1810,8 @@ static void test_http2_unframe_buckets(C
   raw = serf_bucket_simple_create(raw_frame2, sizeof(raw_frame2),
                                   NULL, NULL, alloc);
 
-  unframe = serf_bucket_http2_unframe_create(raw, TRUE, SERF_READ_ALL_AVAIL,
-                                             alloc);
+  unframe = serf__bucket_http2_unframe_create(raw, TRUE, SERF_READ_ALL_AVAIL,
+                                              alloc);
 
   status = read_all(unframe, result2, sizeof(result2), &read_len);
   CuAssertIntEquals(tc, APR_EOF, status);
@@ -1823,10 +1825,10 @@ static void test_http2_unframe_buckets(C
     unsigned char frame_type, flags;
 
     CuAssertIntEquals(tc, 0,
-                      serf_bucket_http2_unframe_read_info(unframe,
-                                                          &stream_id,
-                                                          &frame_type,
-                                                          &flags));
+                      serf__bucket_http2_unframe_read_info(unframe,
+                                                           &stream_id,
+                                                           &frame_type,
+                                                           &flags));
     CuAssertIntEquals(tc, 0x03040506, stream_id);
     CuAssertIntEquals(tc, 0x01, frame_type);
     CuAssertIntEquals(tc, 0x02, flags);
@@ -1836,7 +1838,7 @@ static void test_http2_unframe_buckets(C
   raw = serf_bucket_simple_create(raw_frame2, sizeof(raw_frame2),
                                   NULL, NULL, alloc);
 
-  unframe = serf_bucket_http2_unframe_create(raw, TRUE, 5, alloc);
+  unframe = serf__bucket_http2_unframe_create(raw, TRUE, 5, alloc);
 
   status = read_all(unframe, result2, sizeof(result2), &read_len);
   CuAssertIntEquals(tc, SERF_ERROR_HTTP2_FRAME_SIZE_ERROR, status);
@@ -1872,15 +1874,15 @@ static void test_http2_unpad_buckets(CuT
   raw = serf_bucket_simple_create(raw_frame, sizeof(raw_frame)-1,
                                   NULL, NULL, alloc);
 
-  unframe = serf_bucket_http2_unframe_create(raw, FALSE, SERF_READ_ALL_AVAIL,
-                                             alloc);
+  unframe = serf__bucket_http2_unframe_create(raw, FALSE, SERF_READ_ALL_AVAIL,
+                                              alloc);
 
   {
     apr_int32_t streamid;
     unsigned char frame_type, flags;
 
-    status = serf_bucket_http2_unframe_read_info(unframe, &streamid,
-                                                 &frame_type, &flags);
+    status = serf__bucket_http2_unframe_read_info(unframe, &streamid,
+                                                  &frame_type, &flags);
 
     CuAssertIntEquals(tc, APR_SUCCESS, status);
     CuAssertIntEquals(tc, 7, streamid);
@@ -1888,9 +1890,9 @@ static void test_http2_unpad_buckets(CuT
     CuAssertIntEquals(tc, 8, flags);
   }
 
-  unpad = serf_bucket_http2_unpad_create(unframe, TRUE, alloc);
+  unpad = serf__bucket_http2_unpad_create(unframe, TRUE, alloc);
 
-  CuAssertTrue(tc, SERF_BUCKET_IS_HTTP2_UNPAD(unpad));
+  CuAssertTrue(tc, SERF__BUCKET_IS_HTTP2_UNPAD(unpad));
 
   status = read_all(unpad, result1, sizeof(result1), &read_len);
   CuAssertIntEquals(tc, APR_EOF, status);
@@ -1899,11 +1901,11 @@ static void test_http2_unpad_buckets(CuT
   read_and_check_bucket(tc, raw, "Extra");
 
   raw = serf_bucket_simple_create("\0a", 2, NULL, NULL, alloc);
-  unpad = serf_bucket_http2_unpad_create(raw, TRUE, alloc);
+  unpad = serf__bucket_http2_unpad_create(raw, TRUE, alloc);
   read_and_check_bucket(tc, unpad, "a");
 
   raw = serf_bucket_simple_create("\5a", 2, NULL, NULL, alloc);
-  unpad = serf_bucket_http2_unpad_create(raw, TRUE, alloc);
+  unpad = serf__bucket_http2_unpad_create(raw, TRUE, alloc);
 
   {
     const char *data;
@@ -2135,14 +2137,14 @@ static void test_hpack_header_encode(CuT
 
   alloc = serf_bucket_allocator_create(tb->pool, NULL, NULL);
 
-  hpack = serf_bucket_hpack_create(NULL, alloc);
+  hpack = serf__bucket_hpack_create(NULL, alloc);
 
   CuAssertTrue(tc, SERF_BUCKET_IS_HPACK(hpack));
 
-  serf_bucket_hpack_setc(hpack, ":method", "PUT");
-  serf_bucket_hpack_setc(hpack, ":scheme", "https");
-  serf_bucket_hpack_setc(hpack, ":path", "/");
-  serf_bucket_hpack_setc(hpack, ":authority", "localhost");
+  serf__bucket_hpack_setc(hpack, ":method", "PUT");
+  serf__bucket_hpack_setc(hpack, ":scheme", "https");
+  serf__bucket_hpack_setc(hpack, ":path", "/");
+  serf__bucket_hpack_setc(hpack, ":authority", "localhost");
 
   CuAssertIntEquals(tc, APR_EOF,
                     read_all(hpack, resultbuffer, sizeof(resultbuffer), &sz));
@@ -2166,10 +2168,10 @@ static void test_http2_frame_bucket_basi
   alloc = serf_bucket_allocator_create(tb->pool, NULL, NULL);
 
   body_in = SERF_BUCKET_SIMPLE_STRING("This is no config!", alloc);
-  frame_in = serf_bucket_http2_frame_create(body_in, 99, 7, &exp_streamid,
-                                            NULL, NULL,
-                                            16384, NULL, NULL, alloc);
-  frame_out = serf_bucket_http2_unframe_create(frame_in, FALSE, 16384, alloc);
+  frame_in = serf__bucket_http2_frame_create(body_in, 99, 7, &exp_streamid,
+                                             NULL, NULL,
+                                             16384, NULL, NULL, alloc);
+  frame_out = serf__bucket_http2_unframe_create(frame_in, FALSE, 16384, alloc);
 
   read_and_check_bucket(tc, frame_out, "This is no config!");
 
@@ -2181,8 +2183,8 @@ static void test_http2_frame_bucket_basi
     apr_size_t sz;
 
     CuAssertIntEquals(tc, 0,
-                      serf_bucket_http2_unframe_read_info(frame_out, &streamid,
-                                                          &frametype, &flags));
+                      serf__bucket_http2_unframe_read_info(frame_out, &streamid,
+                                                           &frametype, &flags));
     CuAssertIntEquals(tc, 0x01020304, streamid);
     CuAssertIntEquals(tc, 99, frametype);
     CuAssertIntEquals(tc, 7, flags);



Mime
View raw message