serf/buckets/response_body_buckets.c

/* ====================================================================
 *    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 <apr_pools.h>

#include "serf.h"
#include "serf_bucket_util.h"

/* Older versions of APR do not have this macro.  */
#ifdef APR_SIZE_MAX
#define REQUESTED_MAX APR_SIZE_MAX
#else
#define REQUESTED_MAX (~((apr_size_t)0))
#endif


typedef struct {
    serf_bucket_t *stream;
    apr_uint64_t remaining;
} body_context_t;

serf_bucket_t *serf_bucket_response_body_create(
    serf_bucket_t *stream, apr_uint64_t len, serf_bucket_alloc_t *allocator)
{
    body_context_t *ctx;

    ctx = serf_bucket_mem_alloc(allocator, sizeof(*ctx));
    ctx->stream = stream;
    ctx->remaining = len;

    return serf_bucket_create(&serf_bucket_type_response_body, allocator, ctx);
}

static apr_status_t serf_response_body_read(serf_bucket_t *bucket,
                                            apr_size_t requested,
                                            const char **data,
                                            apr_size_t *len)
{
    body_context_t *ctx = bucket->data;
    apr_status_t status;

    if (!ctx->remaining) {
        *len = 0;
        return APR_EOF;
    }

    if (requested == SERF_READ_ALL_AVAIL || requested > ctx->remaining) {
        if (ctx->remaining <= REQUESTED_MAX) {
            requested = (apr_size_t) ctx->remaining;
        } else {
            requested = REQUESTED_MAX;
        }
    }

    status = serf_bucket_read(ctx->stream, requested, data, len);

    if (!SERF_BUCKET_READ_ERROR(status)) {
        ctx->remaining -= *len;
    }

    if (APR_STATUS_IS_EOF(status) && ctx->remaining > 0) {
        /* The server sent less data than expected. */
        status = SERF_ERROR_TRUNCATED_HTTP_RESPONSE;
    }

    return status;
}

static apr_status_t serf_response_body_readline(serf_bucket_t *bucket,
                                                int acceptable, int *found,
                                                const char **data,
                                                apr_size_t *len)
{
    body_context_t *ctx = bucket->data;
    apr_status_t status;

    if (!ctx->remaining) {
        *len = 0;
        return APR_EOF;
    }

    status = serf_bucket_readline(ctx->stream, acceptable, found, data, len);

    if (!SERF_BUCKET_READ_ERROR(status)) {
        ctx->remaining -= *len;
    }

    if (APR_STATUS_IS_EOF(status) && ctx->remaining > 0) {
        /* The server sent less data than expected. */
        status = SERF_ERROR_TRUNCATED_HTTP_RESPONSE;
    }

    return status;
}

static apr_status_t serf_response_body_peek(serf_bucket_t *bucket,
                                            const char **data,
                                            apr_size_t *len)
{
    body_context_t *ctx = bucket->data;

    return serf_bucket_peek(ctx->stream, data, len);
}

static void serf_response_body_destroy(serf_bucket_t *bucket)
{
    body_context_t *ctx = bucket->data;

    serf_bucket_destroy(ctx->stream);

    serf_default_destroy_and_data(bucket);
}

const serf_bucket_type_t serf_bucket_type_response_body = {
    "RESPONSE_BODY",
    serf_response_body_read,
    serf_response_body_readline,
    serf_default_read_iovec,
    serf_default_read_for_sendfile,
    serf_default_read_bucket,
    serf_response_body_peek,
    serf_response_body_destroy,
};
Revision:	9268
Committed:	Mon Feb 20 02:52:22 2017 UTC (7 years, 2 months ago) by laffer1
Content type:	text/plain
File size:	4223 byte(s)
Log Message:	merge in serf 1.3.9
#	Content
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
23	#include "serf.h"
24	#include "serf_bucket_util.h"
25
26	/* Older versions of APR do not have this macro. */
27	#ifdef APR_SIZE_MAX
28	#define REQUESTED_MAX APR_SIZE_MAX
29	#else
30	#define REQUESTED_MAX (~((apr_size_t)0))
31	#endif
32
33
34	typedef struct {
35	serf_bucket_t *stream;
36	apr_uint64_t remaining;
37	} body_context_t;
38
39	serf_bucket_t *serf_bucket_response_body_create(
40	serf_bucket_t stream, apr_uint64_t len, serf_bucket_alloc_t allocator)
41	{
42	body_context_t *ctx;
43
44	ctx = serf_bucket_mem_alloc(allocator, sizeof(*ctx));
45	ctx->stream = stream;
46	ctx->remaining = len;
47
48	return serf_bucket_create(&serf_bucket_type_response_body, allocator, ctx);
49	}
50
51	static apr_status_t serf_response_body_read(serf_bucket_t *bucket,
52	apr_size_t requested,
53	const char **data,
54	apr_size_t *len)
55	{
56	body_context_t *ctx = bucket->data;
57	apr_status_t status;
58
59	if (!ctx->remaining) {
60	*len = 0;
61	return APR_EOF;
62	}
63
64	if (requested == SERF_READ_ALL_AVAIL \|\| requested > ctx->remaining) {
65	if (ctx->remaining <= REQUESTED_MAX) {
66	requested = (apr_size_t) ctx->remaining;
67	} else {
68	requested = REQUESTED_MAX;
69	}
70	}
71
72	status = serf_bucket_read(ctx->stream, requested, data, len);
73
74	if (!SERF_BUCKET_READ_ERROR(status)) {
75	ctx->remaining -= *len;
76	}
77
78	if (APR_STATUS_IS_EOF(status) && ctx->remaining > 0) {
79	/* The server sent less data than expected. */
80	status = SERF_ERROR_TRUNCATED_HTTP_RESPONSE;
81	}
82
83	return status;
84	}
85
86	static apr_status_t serf_response_body_readline(serf_bucket_t *bucket,
87	int acceptable, int *found,
88	const char **data,
89	apr_size_t *len)
90	{
91	body_context_t *ctx = bucket->data;
92	apr_status_t status;
93
94	if (!ctx->remaining) {
95	*len = 0;
96	return APR_EOF;
97	}
98
99	status = serf_bucket_readline(ctx->stream, acceptable, found, data, len);
100
101	if (!SERF_BUCKET_READ_ERROR(status)) {
102	ctx->remaining -= *len;
103	}
104
105	if (APR_STATUS_IS_EOF(status) && ctx->remaining > 0) {
106	/* The server sent less data than expected. */
107	status = SERF_ERROR_TRUNCATED_HTTP_RESPONSE;
108	}
109
110	return status;
111	}
112
113	static apr_status_t serf_response_body_peek(serf_bucket_t *bucket,
114	const char **data,
115	apr_size_t *len)
116	{
117	body_context_t *ctx = bucket->data;
118
119	return serf_bucket_peek(ctx->stream, data, len);
120	}
121
122	static void serf_response_body_destroy(serf_bucket_t *bucket)
123	{
124	body_context_t *ctx = bucket->data;
125
126	serf_bucket_destroy(ctx->stream);
127
128	serf_default_destroy_and_data(bucket);
129	}
130
131	const serf_bucket_type_t serf_bucket_type_response_body = {
132	"RESPONSE_BODY",
133	serf_response_body_read,
134	serf_response_body_readline,
135	serf_default_read_iovec,
136	serf_default_read_for_sendfile,
137	serf_default_read_bucket,
138	serf_response_body_peek,
139	serf_response_body_destroy,
140	};