Mercurial > dovecot > core-2.2

comparison src/lib/buffer.c @ 903:fd8888f6f037 HEAD

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Naming style changes, finally got tired of most of the typedefs. Also the previous enum -> macro change reverted so that we don't use the highest bit anymore, that's incompatible with old indexes so they will be rebuilt.
author Timo Sirainen <tss@iki.fi>
date Sun, 05 Jan 2003 15:09:51 +0200
parents e73389a2324a
children 4d6b69558add
comparison
equal deleted inserted replaced
902:5043e48c022f 903:fd8888f6f037
24 /* @UNSAFE: whole file */ 24 /* @UNSAFE: whole file */
25 25
26 #include "lib.h" 26 #include "lib.h"
27 #include "buffer.h" 27 #include "buffer.h"
28 28
29 struct _Buffer { 29 struct buffer {
30 Pool pool; 30 pool_t pool;
31 31
32 const unsigned char *r_buffer; 32 const unsigned char *r_buffer;
33 unsigned char *w_buffer; 33 unsigned char *w_buffer;
34 34
35 /* buffer_set_start_pos() modifies start_pos, but internally we deal 35 /* buffer_set_start_pos() modifies start_pos, but internally we deal
43 unsigned int alloced:1; 43 unsigned int alloced:1;
44 unsigned int readonly:1; 44 unsigned int readonly:1;
45 unsigned int hard:1; 45 unsigned int hard:1;
46 }; 46 };
47 47
48 static void buffer_alloc(Buffer *buf, size_t size) 48 static void buffer_alloc(buffer_t *buf, size_t size)
49 { 49 {
50 i_assert(buf->w_buffer == NULL || buf->alloced); 50 i_assert(buf->w_buffer == NULL || buf->alloced);
51 51
52 if (size == buf->alloc) 52 if (size == buf->alloc)
53 return; 53 return;
61 buf->w_buffer = p_realloc(buf->pool, buf->w_buffer, buf->alloc); 61 buf->w_buffer = p_realloc(buf->pool, buf->w_buffer, buf->alloc);
62 buf->r_buffer = buf->w_buffer; 62 buf->r_buffer = buf->w_buffer;
63 buf->alloced = TRUE; 63 buf->alloced = TRUE;
64 } 64 }
65 65
66 static int buffer_check_read(const Buffer *buf, size_t *pos, size_t *data_size) 66 static int buffer_check_read(const buffer_t *buf,
67 size_t *pos, size_t *data_size)
67 { 68 {
68 size_t used_size, max_size; 69 size_t used_size, max_size;
69 70
70 used_size = I_MIN(buf->used, buf->limit); 71 used_size = I_MIN(buf->used, buf->limit);
71 if (*pos >= used_size - buf->start_pos) 72 if (*pos >= used_size - buf->start_pos)
76 if (*data_size > max_size) 77 if (*data_size > max_size)
77 *data_size = max_size; 78 *data_size = max_size;
78 return TRUE; 79 return TRUE;
79 } 80 }
80 81
81 static int buffer_check_write(Buffer *buf, size_t *pos, size_t *data_size, 82 static int buffer_check_write(buffer_t *buf, size_t *pos,
82 int accept_partial) 83 size_t *data_size, int accept_partial)
83 { 84 {
84 size_t max_size, new_size, alloc_size; 85 size_t max_size, new_size, alloc_size;
85 86
86 if (buf->readonly) 87 if (buf->readonly)
87 return FALSE; 88 return FALSE;
130 if (new_size > buf->used) 131 if (new_size > buf->used)
131 buf->used = new_size; 132 buf->used = new_size;
132 return TRUE; 133 return TRUE;
133 } 134 }
134 135
135 Buffer *buffer_create_static(Pool pool, size_t size) 136 buffer_t *buffer_create_static(pool_t pool, size_t size)
136 { 137 {
137 Buffer *buf; 138 buffer_t *buf;
138 139
139 buf = p_new(pool, Buffer, 1); 140 buf = p_new(pool, buffer_t, 1);
140 buf->pool = pool; 141 buf->pool = pool;
141 buf->max_alloc = buf->limit = size; 142 buf->max_alloc = buf->limit = size;
142 buffer_alloc(buf, size); 143 buffer_alloc(buf, size);
143 return buf; 144 return buf;
144 } 145 }
145 146
146 Buffer *buffer_create_static_hard(Pool pool, size_t size) 147 buffer_t *buffer_create_static_hard(pool_t pool, size_t size)
147 { 148 {
148 Buffer *buf; 149 buffer_t *buf;
149 150
150 buf = buffer_create_static(pool, size); 151 buf = buffer_create_static(pool, size);
151 buf->hard = TRUE; 152 buf->hard = TRUE;
152 return buf; 153 return buf;
153 } 154 }
154 155
155 Buffer *buffer_create_data(Pool pool, void *data, size_t size) 156 buffer_t *buffer_create_data(pool_t pool, void *data, size_t size)
156 { 157 {
157 Buffer *buf; 158 buffer_t *buf;
158 159
159 buf = p_new(pool, Buffer, 1); 160 buf = p_new(pool, buffer_t, 1);
160 buf->pool = pool; 161 buf->pool = pool;
161 buf->alloc = buf->max_alloc = buf->limit = size; 162 buf->alloc = buf->max_alloc = buf->limit = size;
162 buf->r_buffer = buf->w_buffer = data; 163 buf->r_buffer = buf->w_buffer = data;
163 return buf; 164 return buf;
164 } 165 }
165 166
166 Buffer *buffer_create_const_data(Pool pool, const void *data, size_t size) 167 buffer_t *buffer_create_const_data(pool_t pool, const void *data, size_t size)
167 { 168 {
168 Buffer *buf; 169 buffer_t *buf;
169 170
170 buf = p_new(pool, Buffer, 1); 171 buf = p_new(pool, buffer_t, 1);
171 buf->pool = pool; 172 buf->pool = pool;
172 buf->used = buf->alloc = buf->max_alloc = buf->limit = size; 173 buf->used = buf->alloc = buf->max_alloc = buf->limit = size;
173 buf->r_buffer = data; 174 buf->r_buffer = data;
174 buf->readonly = TRUE; 175 buf->readonly = TRUE;
175 return buf; 176 return buf;
176 } 177 }
177 178
178 Buffer *buffer_create_dynamic(Pool pool, size_t init_size, size_t max_size) 179 buffer_t *buffer_create_dynamic(pool_t pool, size_t init_size, size_t max_size)
179 { 180 {
180 Buffer *buf; 181 buffer_t *buf;
181 182
182 buf = p_new(pool, Buffer, 1); 183 buf = p_new(pool, buffer_t, 1);
183 buf->pool = pool; 184 buf->pool = pool;
184 buf->max_alloc = buf->limit = max_size; 185 buf->max_alloc = buf->limit = max_size;
185 buffer_alloc(buf, init_size); 186 buffer_alloc(buf, init_size);
186 return buf; 187 return buf;
187 } 188 }
188 189
189 void buffer_free(Buffer *buf) 190 void buffer_free(buffer_t *buf)
190 { 191 {
191 if (buf->alloced) 192 if (buf->alloced)
192 p_free(buf->pool, buf->w_buffer); 193 p_free(buf->pool, buf->w_buffer);
193 p_free(buf->pool, buf); 194 p_free(buf->pool, buf);
194 } 195 }
195 196
196 void *buffer_free_without_data(Buffer *buf) 197 void *buffer_free_without_data(buffer_t *buf)
197 { 198 {
198 void *data; 199 void *data;
199 200
200 data = buf->w_buffer; 201 data = buf->w_buffer;
201 p_free(buf->pool, buf); 202 p_free(buf->pool, buf);
202 return data; 203 return data;
203 } 204 }
204 205
205 size_t buffer_write(Buffer *buf, size_t pos, 206 size_t buffer_write(buffer_t *buf, size_t pos,
206 const void *data, size_t data_size) 207 const void *data, size_t data_size)
207 { 208 {
208 if (!buffer_check_write(buf, &pos, &data_size, TRUE)) 209 if (!buffer_check_write(buf, &pos, &data_size, TRUE))
209 return 0; 210 return 0;
210 211
211 memcpy(buf->w_buffer + pos, data, data_size); 212 memcpy(buf->w_buffer + pos, data, data_size);
212 return data_size; 213 return data_size;
213 } 214 }
214 215
215 size_t buffer_append(Buffer *buf, const void *data, size_t data_size) 216 size_t buffer_append(buffer_t *buf, const void *data, size_t data_size)
216 { 217 {
217 return buffer_write(buf, buf->used - buf->start_pos, data, data_size); 218 return buffer_write(buf, buf->used - buf->start_pos, data, data_size);
218 } 219 }
219 220
220 size_t buffer_append_c(Buffer *buf, char chr) 221 size_t buffer_append_c(buffer_t *buf, char chr)
221 { 222 {
222 size_t pos, data_size = 1; 223 size_t pos, data_size = 1;
223 224
224 pos = buf->used - buf->start_pos; 225 pos = buf->used - buf->start_pos;
225 if (!buffer_check_write(buf, &pos, &data_size, TRUE)) 226 if (!buffer_check_write(buf, &pos, &data_size, TRUE))
228 if (data_size == 1) 229 if (data_size == 1)
229 buf->w_buffer[pos] = chr; 230 buf->w_buffer[pos] = chr;
230 return data_size; 231 return data_size;
231 } 232 }
232 233
233 size_t buffer_insert(Buffer *buf, size_t pos, 234 size_t buffer_insert(buffer_t *buf, size_t pos,
234 const void *data, size_t data_size) 235 const void *data, size_t data_size)
235 { 236 {
236 size_t move_size, size; 237 size_t move_size, size;
237 238
238 /* move_size == number of bytes we have to move forward to make space */ 239 /* move_size == number of bytes we have to move forward to make space */
257 memmove(buf->w_buffer + pos + size, buf->w_buffer + pos, move_size); 258 memmove(buf->w_buffer + pos + size, buf->w_buffer + pos, move_size);
258 memcpy(buf->w_buffer + pos, data, size); 259 memcpy(buf->w_buffer + pos, data, size);
259 return size; 260 return size;
260 } 261 }
261 262
262 size_t buffer_delete(Buffer *buf, size_t pos, size_t size) 263 size_t buffer_delete(buffer_t *buf, size_t pos, size_t size)
263 { 264 {
264 size_t end_size; 265 size_t end_size;
265 266
266 if (buf->readonly) 267 if (buf->readonly)
267 return 0; 268 return 0;
284 285
285 buffer_set_used_size(buf, pos + end_size); 286 buffer_set_used_size(buf, pos + end_size);
286 return size; 287 return size;
287 } 288 }
288 289
289 size_t buffer_copy(Buffer *dest, size_t dest_pos, 290 size_t buffer_copy(buffer_t *dest, size_t dest_pos,
290 const Buffer *src, size_t src_pos, size_t copy_size) 291 const buffer_t *src, size_t src_pos, size_t copy_size)
291 { 292 {
292 if (!buffer_check_read(src, &src_pos, &copy_size)) 293 if (!buffer_check_read(src, &src_pos, &copy_size))
293 return 0; 294 return 0;
294 295
295 if (!buffer_check_write(dest, &dest_pos, &copy_size, TRUE)) 296 if (!buffer_check_write(dest, &dest_pos, &copy_size, TRUE))
303 src->r_buffer + src_pos, copy_size); 304 src->r_buffer + src_pos, copy_size);
304 } 305 }
305 return copy_size; 306 return copy_size;
306 } 307 }
307 308
308 size_t buffer_append_buf(Buffer *dest, const Buffer *src, 309 size_t buffer_append_buf(buffer_t *dest, const buffer_t *src,
309 size_t src_pos, size_t copy_size) 310 size_t src_pos, size_t copy_size)
310 { 311 {
311 return buffer_copy(dest, dest->used - dest->start_pos, 312 return buffer_copy(dest, dest->used - dest->start_pos,
312 src, src_pos, copy_size); 313 src, src_pos, copy_size);
313 } 314 }
314 315
315 void *buffer_get_space(Buffer *buf, size_t pos, size_t size) 316 void *buffer_get_space(buffer_t *buf, size_t pos, size_t size)
316 { 317 {
317 if (!buffer_check_write(buf, &pos, &size, FALSE)) 318 if (!buffer_check_write(buf, &pos, &size, FALSE))
318 return NULL; 319 return NULL;
319 320
320 return buf->w_buffer + pos; 321 return buf->w_buffer + pos;
321 } 322 }
322 323
323 void *buffer_append_space(Buffer *buf, size_t size) 324 void *buffer_append_space(buffer_t *buf, size_t size)
324 { 325 {
325 return buffer_get_space(buf, buf->used - buf->start_pos, size); 326 return buffer_get_space(buf, buf->used - buf->start_pos, size);
326 } 327 }
327 328
328 const void *buffer_get_data(const Buffer *buf, size_t *used_size) 329 const void *buffer_get_data(const buffer_t *buf, size_t *used_size)
329 { 330 {
330 if (used_size != NULL) 331 if (used_size != NULL)
331 *used_size = I_MIN(buf->used, buf->limit) - buf->start_pos; 332 *used_size = I_MIN(buf->used, buf->limit) - buf->start_pos;
332 return buf->r_buffer + buf->start_pos; 333 return buf->r_buffer + buf->start_pos;
333 } 334 }
334 335
335 void *buffer_get_modifyable_data(const Buffer *buf, size_t *used_size) 336 void *buffer_get_modifyable_data(const buffer_t *buf, size_t *used_size)
336 { 337 {
337 if (used_size != NULL) 338 if (used_size != NULL)
338 *used_size = I_MIN(buf->used, buf->limit) - buf->start_pos; 339 *used_size = I_MIN(buf->used, buf->limit) - buf->start_pos;
339 return buf->w_buffer + buf->start_pos; 340 return buf->w_buffer + buf->start_pos;
340 } 341 }
341 342
342 void buffer_set_used_size(Buffer *buf, size_t used_size) 343 void buffer_set_used_size(buffer_t *buf, size_t used_size)
343 { 344 {
344 i_assert(used_size <= I_MIN(buf->alloc, buf->limit) - buf->start_pos); 345 i_assert(used_size <= I_MIN(buf->alloc, buf->limit) - buf->start_pos);
345 346
346 buf->used = used_size + buf->start_pos; 347 buf->used = used_size + buf->start_pos;
347 } 348 }
348 349
349 size_t buffer_get_used_size(const Buffer *buf) 350 size_t buffer_get_used_size(const buffer_t *buf)
350 { 351 {
351 return I_MIN(buf->used, buf->limit) - buf->start_pos; 352 return I_MIN(buf->used, buf->limit) - buf->start_pos;
352 } 353 }
353 354
354 size_t buffer_set_start_pos(Buffer *buf, size_t abs_pos) 355 size_t buffer_set_start_pos(buffer_t *buf, size_t abs_pos)
355 { 356 {
356 size_t old = buf->start_pos; 357 size_t old = buf->start_pos;
357 358
358 i_assert(abs_pos <= I_MIN(buf->used, buf->limit)); 359 i_assert(abs_pos <= I_MIN(buf->used, buf->limit));
359 360
360 buf->start_pos = abs_pos; 361 buf->start_pos = abs_pos;
361 return old; 362 return old;
362 } 363 }
363 364
364 size_t buffer_get_start_pos(const Buffer *buf) 365 size_t buffer_get_start_pos(const buffer_t *buf)
365 { 366 {
366 return buf->start_pos; 367 return buf->start_pos;
367 } 368 }
368 369
369 size_t buffer_set_limit(Buffer *buf, size_t limit) 370 size_t buffer_set_limit(buffer_t *buf, size_t limit)
370 { 371 {
371 size_t old = buf->limit; 372 size_t old = buf->limit;
372 373
373 if (limit > (size_t)-1 - buf->start_pos) 374 if (limit > (size_t)-1 - buf->start_pos)
374 limit = (size_t)-1; 375 limit = (size_t)-1;
377 378
378 buf->limit = I_MIN(limit, buf->max_alloc); 379 buf->limit = I_MIN(limit, buf->max_alloc);
379 return old - buf->start_pos; 380 return old - buf->start_pos;
380 } 381 }
381 382
382 size_t buffer_get_limit(const Buffer *buf) 383 size_t buffer_get_limit(const buffer_t *buf)
383 { 384 {
384 return buf->limit - buf->start_pos; 385 return buf->limit - buf->start_pos;
385 } 386 }
386 387
387 size_t buffer_get_size(const Buffer *buf) 388 size_t buffer_get_size(const buffer_t *buf)
388 { 389 {
389 return buf->alloc - buf->start_pos; 390 return buf->alloc - buf->start_pos;
390 } 391 }
391 392
392 #ifdef BUFFER_TEST 393 #ifdef BUFFER_TEST
393 /* gcc buffer.c -o testbuffer liblib.a -Wall -DHAVE_CONFIG_H -DBUFFER_TEST -g */ 394 /* gcc buffer.c -o testbuffer liblib.a -Wall -DHAVE_CONFIG_H -DBUFFER_TEST -g */
394 int main(void) 395 int main(void)
395 { 396 {
396 Buffer *buf; 397 buffer_t *buf;
397 char data[12], *bufdata; 398 char data[12], *bufdata;
398 size_t bufsize; 399 size_t bufsize;
399 400
400 lib_init(); 401 lib_init();
401 402