65
65
return serf_bucket_create(&serf_bucket_type_headers, allocator, ctx);
68
SERF_DECLARE(void) serf_bucket_headers_setx(
68
void serf_bucket_headers_setx(
69
69
serf_bucket_t *bkt,
70
70
const char *header, apr_size_t header_size, int header_copy,
71
71
const char *value, apr_size_t value_size, int value_copy)
73
73
headers_context_t *ctx = bkt->data;
74
header_list_t *found = ctx->list;
74
header_list_t *iter = ctx->list;
75
75
header_list_t *hdr;
77
/* Check to see if this header is already present. */
79
if (strncasecmp(found->header, header, header_size) == 0)
86
/* The header is already present. RFC 2616, section 4.2
87
indicates that we should append the new value, separated by
88
a comma. Reasoning: for headers whose values are known to
89
be comma-separated, that is clearly the correct behavior;
90
for others, the correct behavior is undefined anyway. */
92
/* The "+1" is for the comma; serf_bstrmemdup() will also add
93
one slot for the terminating '\0'. */
94
apr_size_t new_size = found->value_size + value_size + 1;
95
char *new_val = serf_bucket_mem_alloc(bkt->allocator, new_size);
96
memcpy(new_val, found->value, found->value_size);
97
new_val[found->value_size] = ',';
98
memcpy(new_val + found->value_size + 1, value, value_size);
99
new_val[new_size] = '\0';
100
found->value = new_val;
101
found->value_size = new_size;
102
found->alloc_flags |= ALLOC_VALUE;
106
/* Else the header is not already present. Add it to the bucket. */
109
78
/* ### include this? */
110
79
if (ctx->cur_read) {
134
104
hdr->value = value;
137
hdr->next = ctx->list;
107
/* Add the new header at the end of the list. */
108
while (iter && iter->next) {
141
SERF_DECLARE(void) serf_bucket_headers_set(
117
void serf_bucket_headers_set(
142
118
serf_bucket_t *headers_bucket,
143
119
const char *header,
144
120
const char *value)
148
124
value, strlen(value), 1);
151
SERF_DECLARE(void) serf_bucket_headers_setc(
127
void serf_bucket_headers_setc(
152
128
serf_bucket_t *headers_bucket,
153
129
const char *header,
154
130
const char *value)
158
134
value, strlen(value), 1);
161
SERF_DECLARE(void) serf_bucket_headers_setn(
137
void serf_bucket_headers_setn(
162
138
serf_bucket_t *headers_bucket,
163
139
const char *header,
164
140
const char *value)
168
144
value, strlen(value), 0);
171
SERF_DECLARE(const char *) serf_bucket_headers_get(
147
const char *serf_bucket_headers_get(
172
148
serf_bucket_t *headers_bucket,
173
149
const char *header)
175
151
headers_context_t *ctx = headers_bucket->data;
176
header_list_t *scan = ctx->list;
179
if (strcasecmp(scan->header, header) == 0)
152
header_list_t *found = ctx->list;
153
const char *val = NULL;
158
if (strcasecmp(found->header, header) == 0) {
160
/* The header is already present. RFC 2616, section 4.2
161
indicates that we should append the new value, separated by
162
a comma. Reasoning: for headers whose values are known to
163
be comma-separated, that is clearly the correct behavior;
164
for others, the correct behavior is undefined anyway. */
166
/* The "+1" is for the comma; serf_bstrmemdup() will also add
167
one slot for the terminating '\0'. */
168
apr_size_t new_size = found->value_size + value_size + 1;
169
char *new_val = serf_bucket_mem_alloc(headers_bucket->allocator,
171
memcpy(new_val, val, value_size);
172
new_val[value_size] = ',';
173
memcpy(new_val + value_size + 1, found->value,
175
new_val[new_size] = '\0';
176
/* Copy the new value over the already existing value. */
178
serf_bucket_mem_free(headers_bucket->allocator, (void*)val);
179
val_alloc |= ALLOC_VALUE;
181
value_size = new_size;
185
value_size = found->value_size;
187
SERF_DECLARE(void) serf_bucket_headers_do(
194
void serf_bucket_headers_do(
188
195
serf_bucket_t *headers_bucket,
189
196
serf_bucket_headers_do_callback_fn_t func,
added
removed
buckets/headers_buckets.c
