request_buckets.c revision 362181
1/* ==================================================================== 2 * Licensed to the Apache Software Foundation (ASF) under one 3 * or more contributor license agreements. See the NOTICE file 4 * distributed with this work for additional information 5 * regarding copyright ownership. The ASF licenses this file 6 * to you under the Apache License, Version 2.0 (the 7 * "License"); you may not use this file except in compliance 8 * with the License. You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, 13 * software distributed under the License is distributed on an 14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 15 * KIND, either express or implied. See the License for the 16 * specific language governing permissions and limitations 17 * under the License. 18 * ==================================================================== 19 */ 20 21#include <apr_pools.h> 22#include <apr_strings.h> 23 24#include "serf.h" 25#include "serf_bucket_util.h" 26 27 28typedef struct { 29 const char *method; 30 const char *uri; 31 serf_bucket_t *headers; 32 serf_bucket_t *body; 33 apr_int64_t len; 34} request_context_t; 35 36#define LENGTH_UNKNOWN ((apr_int64_t)-1) 37 38 39serf_bucket_t *serf_bucket_request_create( 40 const char *method, 41 const char *URI, 42 serf_bucket_t *body, 43 serf_bucket_alloc_t *allocator) 44{ 45 request_context_t *ctx; 46 47 ctx = serf_bucket_mem_alloc(allocator, sizeof(*ctx)); 48 ctx->method = method; 49 ctx->uri = URI; 50 ctx->headers = serf_bucket_headers_create(allocator); 51 ctx->body = body; 52 ctx->len = LENGTH_UNKNOWN; 53 54 return serf_bucket_create(&serf_bucket_type_request, allocator, ctx); 55} 56 57void serf_bucket_request_set_CL( 58 serf_bucket_t *bucket, 59 apr_int64_t len) 60{ 61 request_context_t *ctx = (request_context_t *)bucket->data; 62 63 ctx->len = len; 64} 65 66serf_bucket_t *serf_bucket_request_get_headers( 67 serf_bucket_t *bucket) 68{ 69 return ((request_context_t *)bucket->data)->headers; 70} 71 72void serf_bucket_request_set_root( 73 serf_bucket_t *bucket, 74 const char *root_url) 75{ 76 request_context_t *ctx = (request_context_t *)bucket->data; 77 78 /* If uri is already absolute, don't change it. */ 79 if (ctx->uri[0] != '/') 80 return; 81 82 /* If uri is '/' replace it with root_url. */ 83 if (ctx->uri[1] == '\0') 84 ctx->uri = root_url; 85 else 86 ctx->uri = 87 apr_pstrcat(serf_bucket_allocator_get_pool(bucket->allocator), 88 root_url, 89 ctx->uri, 90 NULL); 91} 92 93static void serialize_data(serf_bucket_t *bucket) 94{ 95 request_context_t *ctx = bucket->data; 96 serf_bucket_t *new_bucket; 97 const char *new_data; 98 struct iovec iov[4]; 99 apr_size_t nbytes; 100 101 /* Serialize the request-line and headers into one mother string, 102 * and wrap a bucket around it. 103 */ 104 iov[0].iov_base = (char*)ctx->method; 105 iov[0].iov_len = strlen(ctx->method); 106 iov[1].iov_base = " "; 107 iov[1].iov_len = sizeof(" ") - 1; 108 iov[2].iov_base = (char*)ctx->uri; 109 iov[2].iov_len = strlen(ctx->uri); 110 iov[3].iov_base = " HTTP/1.1\r\n"; 111 iov[3].iov_len = sizeof(" HTTP/1.1\r\n") - 1; 112 113 /* Create a new bucket for this string with a flat string. */ 114 new_data = serf_bstrcatv(bucket->allocator, iov, 4, &nbytes); 115 new_bucket = serf_bucket_simple_own_create(new_data, nbytes, 116 bucket->allocator); 117 118 /* Build up the new bucket structure. 119 * 120 * Note that self needs to become an aggregate bucket so that a 121 * pointer to self still represents the "right" data. 122 */ 123 serf_bucket_aggregate_become(bucket); 124 125 /* Insert the two buckets. */ 126 serf_bucket_aggregate_append(bucket, new_bucket); 127 serf_bucket_aggregate_append(bucket, ctx->headers); 128 129 /* If we know the length, then use C-L and the raw body. Otherwise, 130 use chunked encoding for the request. */ 131 if (ctx->len != LENGTH_UNKNOWN) { 132 char buf[30]; 133 sprintf(buf, "%" APR_INT64_T_FMT, ctx->len); 134 serf_bucket_headers_set(ctx->headers, "Content-Length", buf); 135 if (ctx->body != NULL) 136 serf_bucket_aggregate_append(bucket, ctx->body); 137 } 138 else if (ctx->body != NULL) { 139 /* Morph the body bucket to a chunked encoding bucket for now. */ 140 serf_bucket_headers_setn(ctx->headers, "Transfer-Encoding", "chunked"); 141 ctx->body = serf_bucket_chunk_create(ctx->body, bucket->allocator); 142 serf_bucket_aggregate_append(bucket, ctx->body); 143 } 144 145 /* Our private context is no longer needed, and is not referred to by 146 * any existing bucket. Toss it. 147 */ 148 serf_bucket_mem_free(bucket->allocator, ctx); 149} 150 151static apr_status_t serf_request_read(serf_bucket_t *bucket, 152 apr_size_t requested, 153 const char **data, apr_size_t *len) 154{ 155 /* Seralize our private data into a new aggregate bucket. */ 156 serialize_data(bucket); 157 158 /* Delegate to the "new" aggregate bucket to do the read. */ 159 return serf_bucket_read(bucket, requested, data, len); 160} 161 162static apr_status_t serf_request_readline(serf_bucket_t *bucket, 163 int acceptable, int *found, 164 const char **data, apr_size_t *len) 165{ 166 /* Seralize our private data into a new aggregate bucket. */ 167 serialize_data(bucket); 168 169 /* Delegate to the "new" aggregate bucket to do the readline. */ 170 return serf_bucket_readline(bucket, acceptable, found, data, len); 171} 172 173static apr_status_t serf_request_read_iovec(serf_bucket_t *bucket, 174 apr_size_t requested, 175 int vecs_size, 176 struct iovec *vecs, 177 int *vecs_used) 178{ 179 /* Seralize our private data into a new aggregate bucket. */ 180 serialize_data(bucket); 181 182 /* Delegate to the "new" aggregate bucket to do the read. */ 183 return serf_bucket_read_iovec(bucket, requested, 184 vecs_size, vecs, vecs_used); 185} 186 187static apr_status_t serf_request_peek(serf_bucket_t *bucket, 188 const char **data, 189 apr_size_t *len) 190{ 191 /* Seralize our private data into a new aggregate bucket. */ 192 serialize_data(bucket); 193 194 /* Delegate to the "new" aggregate bucket to do the peek. */ 195 return serf_bucket_peek(bucket, data, len); 196} 197 198/* Note that this function is only called when serialize_data() 199 hasn't been called on the bucket */ 200static void serf_request_destroy(serf_bucket_t *bucket) 201{ 202 request_context_t *ctx = bucket->data; 203 204 serf_bucket_destroy(ctx->headers); 205 206 if (ctx->body) 207 serf_bucket_destroy(ctx->body); 208 209 serf_default_destroy_and_data(bucket); 210} 211 212void serf_bucket_request_become( 213 serf_bucket_t *bucket, 214 const char *method, 215 const char *uri, 216 serf_bucket_t *body) 217{ 218 request_context_t *ctx; 219 220 ctx = serf_bucket_mem_alloc(bucket->allocator, sizeof(*ctx)); 221 ctx->method = method; 222 ctx->uri = uri; 223 ctx->headers = serf_bucket_headers_create(bucket->allocator); 224 ctx->body = body; 225 226 bucket->type = &serf_bucket_type_request; 227 bucket->data = ctx; 228 229 /* The allocator remains the same. */ 230} 231 232const serf_bucket_type_t serf_bucket_type_request = { 233 "REQUEST", 234 serf_request_read, 235 serf_request_readline, 236 serf_request_read_iovec, 237 serf_default_read_for_sendfile, 238 serf_default_read_bucket, 239 serf_request_peek, 240 serf_request_destroy, 241}; 242 243