← Back to branch summary

~ubuntu-branches/ubuntu/trusty/serf/trusty-security

« back to all changes in this revision

Viewing changes to buckets/buckets.c

  • Committer: Bazaar Package Importer
  • Author(s): Peter Samuelson
  • Date: 2011-06-03 03:18:07 UTC
  • mfrom: (1.2.4 upstream)
  • mto: (3.3.1 sid)
  • mto: This revision was merged to the branch mainline in revision 11.
  • Revision ID: james.westby@ubuntu.com-20110603031807-3vq82t5lzw692our
Tags: 0.7.2-1
* New upstream release.
  - patches/no-export-vars: delete, now upstream.
* New ABI:
  - patches/abi-0.x: New patch to change upstream SONAME.
  - Rename libserf-0-0 to libserf0.7.
  - Rename libserf-0-0-dev to libserf-dev while we're at it.
* Policy 3.9.1: one instance of s/Conflicts/Breaks/.
* "Upgrade" to source format 1.0.
* Add some Depends: ${misc:Depends}; thanks, Lintian.

Show diffs side-by-side

added added

removed removed

Lines of Context:
buckets/buckets.c
19
19
#include "serf_bucket_util.h"
20
20
 
21
21
 
22
 
SERF_DECLARE(serf_bucket_t *) serf_bucket_create(
 
22
serf_bucket_t *serf_bucket_create(
23
23
    const serf_bucket_type_t *type,
24
24
    serf_bucket_alloc_t *allocator,
25
25
    void *data)
33
33
    return bkt;
34
34
}
35
35
 
36
 
SERF_DECLARE(apr_status_t) serf_default_read_iovec(
 
36
 
 
37
apr_status_t serf_default_read_iovec(
37
38
    serf_bucket_t *bucket,
38
39
    apr_size_t requested,
39
40
    int vecs_size,
69
70
    return status;
70
71
}
71
72
 
72
 
SERF_DECLARE(apr_status_t) serf_default_read_for_sendfile(
 
73
 
 
74
apr_status_t serf_default_read_for_sendfile(
73
75
    serf_bucket_t *bucket,
74
76
    apr_size_t requested,
75
77
    apr_hdtr_t *hdtr,
94
96
    return status;
95
97
}
96
98
 
97
 
SERF_DECLARE(serf_bucket_t *) serf_default_read_bucket(
 
99
 
 
100
serf_bucket_t *serf_default_read_bucket(
98
101
    serf_bucket_t *bucket,
99
102
    const serf_bucket_type_t *type)
100
103
{
101
104
    return NULL;
102
105
}
103
106
 
104
 
SERF_DECLARE(void) serf_default_destroy(serf_bucket_t *bucket)
 
107
 
 
108
void serf_default_destroy(serf_bucket_t *bucket)
105
109
{
106
110
#ifdef SERF_DEBUG_BUCKET_USE
107
111
    serf_debug__bucket_destroy(bucket);
110
114
    serf_bucket_mem_free(bucket->allocator, bucket);
111
115
}
112
116
 
113
 
SERF_DECLARE(void) serf_default_destroy_and_data(serf_bucket_t *bucket)
 
117
 
 
118
void serf_default_destroy_and_data(serf_bucket_t *bucket)
114
119
{
115
120
    serf_bucket_mem_free(bucket->allocator, bucket->data);
116
121
    serf_default_destroy(bucket);
117
122
}
118
123
 
119
 
SERF_DECLARE(apr_status_t) serf_default_snapshot(serf_bucket_t *bucket)
120
 
{
121
 
    /* Not implemented. */
122
 
    return APR_ENOTIMPL;
123
 
}
124
 
 
125
 
SERF_DECLARE(apr_status_t) serf_default_restore_snapshot(serf_bucket_t *bucket)
126
 
{
127
 
    /* Not implemented. */
128
 
    return APR_ENOTIMPL;
129
 
}
130
 
 
131
 
SERF_DECLARE(int) serf_default_is_snapshot_set(serf_bucket_t *bucket)
 
124
 
 
125
apr_status_t serf_default_snapshot(serf_bucket_t *bucket)
 
126
{
 
127
    /* Not implemented. */
 
128
    return APR_ENOTIMPL;
 
129
}
 
130
 
 
131
 
 
132
apr_status_t serf_default_restore_snapshot(serf_bucket_t *bucket)
 
133
{
 
134
    /* Not implemented. */
 
135
    return APR_ENOTIMPL;
 
136
}
 
137
 
 
138
 
 
139
int serf_default_is_snapshot_set(serf_bucket_t *bucket)
132
140
{
133
141
    return 0;  
134
142
}
136
144
/* ==================================================================== */
137
145
 
138
146
 
139
 
SERF_DECLARE(char *) serf_bstrmemdup(serf_bucket_alloc_t *allocator,
140
 
                                     const char *str, apr_size_t size)
 
147
char *serf_bstrmemdup(serf_bucket_alloc_t *allocator,
 
148
                      const char *str,
 
149
                      apr_size_t size)
141
150
{
142
151
    char *newstr = serf_bucket_mem_alloc(allocator, size + 1);
143
152
    memcpy(newstr, str, size);
145
154
    return newstr;
146
155
}
147
156
 
148
 
SERF_DECLARE(void *) serf_bmemdup(serf_bucket_alloc_t *allocator,
149
 
                                  const void *mem,
150
 
                                  apr_size_t size)
 
157
 
 
158
void *serf_bmemdup(serf_bucket_alloc_t *allocator,
 
159
                   const void *mem,
 
160
                   apr_size_t size)
151
161
{
152
162
    void *newmem = serf_bucket_mem_alloc(allocator, size);
153
163
    memcpy(newmem, mem, size);
154
164
    return newmem;
155
165
}
156
166
 
157
 
SERF_DECLARE(char *) serf_bstrdup(serf_bucket_alloc_t *allocator,
158
 
                                  const char *str)
 
167
 
 
168
char *serf_bstrdup(serf_bucket_alloc_t *allocator,
 
169
                   const char *str)
159
170
{
160
171
    apr_size_t size = strlen(str) + 1;
161
172
    char *newstr = serf_bucket_mem_alloc(allocator, size);
203
214
    *found = SERF_NEWLINE_NONE;
204
215
}
205
216
 
206
 
SERF_DECLARE(void) serf_util_readline(const char **data, apr_size_t *len,
207
 
                                      int acceptable, int *found)
 
217
 
 
218
void serf_util_readline(
 
219
    const char **data,
 
220
    apr_size_t *len,
 
221
    int acceptable,
 
222
    int *found)
208
223
{
209
224
    const char *start;
210
225
    const char *cr;
284
299
/* ==================================================================== */
285
300
 
286
301
 
287
 
SERF_DECLARE(void) serf_databuf_init(serf_databuf_t *databuf)
 
302
void serf_databuf_init(serf_databuf_t *databuf)
288
303
{
289
304
    /* nothing is sitting in the buffer */
290
305
    databuf->remaining = 0;
326
341
    return APR_SUCCESS;
327
342
}
328
343
 
329
 
SERF_DECLARE(apr_status_t) serf_databuf_read(serf_databuf_t *databuf,
330
 
                                             apr_size_t requested,
331
 
                                             const char **data,
332
 
                                             apr_size_t *len)
 
344
 
 
345
apr_status_t serf_databuf_read(
 
346
    serf_databuf_t *databuf,
 
347
    apr_size_t requested,
 
348
    const char **data,
 
349
    apr_size_t *len)
333
350
{
334
351
    apr_status_t status = common_databuf_prep(databuf, len);
335
352
    if (status)
355
372
    return databuf->remaining ? APR_SUCCESS : databuf->status;
356
373
}
357
374
 
358
 
SERF_DECLARE(apr_status_t) serf_databuf_readline(serf_databuf_t *databuf,
359
 
                                                 int acceptable, int *found,
360
 
                                                 const char **data,
361
 
                                                 apr_size_t *len)
 
375
 
 
376
apr_status_t serf_databuf_readline(
 
377
    serf_databuf_t *databuf,
 
378
    int acceptable,
 
379
    int *found,
 
380
    const char **data,
 
381
    apr_size_t *len)
362
382
{
363
383
    apr_status_t status = common_databuf_prep(databuf, len);
364
384
    if (status)
378
398
    return databuf->remaining ? APR_SUCCESS : databuf->status;
379
399
}
380
400
 
381
 
SERF_DECLARE(apr_status_t) serf_databuf_peek(serf_databuf_t *databuf,
382
 
                                             const char **data,
383
 
                                             apr_size_t *len)
 
401
 
 
402
apr_status_t serf_databuf_peek(
 
403
    serf_databuf_t *databuf,
 
404
    const char **data,
 
405
    apr_size_t *len)
384
406
{
385
407
    apr_status_t status = common_databuf_prep(databuf, len);
386
408
    if (status)
403
425
/* ==================================================================== */
404
426
 
405
427
 
406
 
SERF_DECLARE(void) serf_linebuf_init(serf_linebuf_t *linebuf)
 
428
void serf_linebuf_init(serf_linebuf_t *linebuf)
407
429
{
408
430
    linebuf->state = SERF_LINEBUF_EMPTY;
409
431
    linebuf->used = 0;
410
432
}
411
433
 
412
 
SERF_DECLARE(apr_status_t) serf_linebuf_fetch(
 
434
 
 
435
apr_status_t serf_linebuf_fetch(
413
436
    serf_linebuf_t *linebuf,
414
437
    serf_bucket_t *bucket,
415
438
    int acceptable)