]>
Commit | Line | Data |
---|---|---|
064af421 | 1 | /* |
125638eb | 2 | * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. |
064af421 | 3 | * |
a14bc59f BP |
4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
5 | * you may not use this file except in compliance with the License. | |
6 | * You may obtain a copy of the License at: | |
064af421 | 7 | * |
a14bc59f BP |
8 | * http://www.apache.org/licenses/LICENSE-2.0 |
9 | * | |
10 | * Unless required by applicable law or agreed to in writing, software | |
11 | * distributed under the License is distributed on an "AS IS" BASIS, | |
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
13 | * See the License for the specific language governing permissions and | |
14 | * limitations under the License. | |
064af421 BP |
15 | */ |
16 | ||
17 | #include <config.h> | |
18 | #include "ofpbuf.h" | |
064af421 BP |
19 | #include <stdlib.h> |
20 | #include <string.h> | |
0ab8e15f | 21 | #include "dynamic-string.h" |
064af421 BP |
22 | #include "util.h" |
23 | ||
31ac1e59 BP |
24 | static void |
25 | ofpbuf_use__(struct ofpbuf *b, void *base, size_t allocated, | |
26 | enum ofpbuf_source source) | |
064af421 BP |
27 | { |
28 | b->base = b->data = base; | |
29 | b->allocated = allocated; | |
31ac1e59 | 30 | b->source = source; |
064af421 | 31 | b->size = 0; |
b02475c5 | 32 | b->l2 = b->l2_5 = b->l3 = b->l4 = b->l7 = NULL; |
b3907fbc | 33 | list_poison(&b->list_node); |
d45e9c65 | 34 | b->private_p = NULL; |
064af421 BP |
35 | } |
36 | ||
31ac1e59 BP |
37 | /* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of |
38 | * memory starting at 'base'. 'base' should be the first byte of a region | |
39 | * obtained from malloc(). It will be freed (with free()) if 'b' is resized or | |
40 | * freed. */ | |
41 | void | |
42 | ofpbuf_use(struct ofpbuf *b, void *base, size_t allocated) | |
43 | { | |
44 | ofpbuf_use__(b, base, allocated, OFPBUF_MALLOC); | |
45 | } | |
46 | ||
47 | /* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of | |
48 | * memory starting at 'base'. 'base' should point to a buffer on the stack. | |
cca408da BP |
49 | * (Nothing actually relies on 'base' being allocated on the stack. It could |
50 | * be static or malloc()'d memory. But stack space is the most common use | |
51 | * case.) | |
31ac1e59 BP |
52 | * |
53 | * 'base' should be appropriately aligned. Using an array of uint32_t or | |
54 | * uint64_t for the buffer is a reasonable way to ensure appropriate alignment | |
125638eb | 55 | * for 32- or 64-bit data. |
31ac1e59 | 56 | * |
cca408da BP |
57 | * An ofpbuf operation that requires reallocating data will assert-fail if this |
58 | * function was used to initialize it. Thus, one need not call ofpbuf_uninit() | |
59 | * on an ofpbuf initialized by this function (though doing so is harmless), | |
60 | * because it is guaranteed that 'b' does not own any heap-allocated memory. */ | |
31ac1e59 BP |
61 | void |
62 | ofpbuf_use_stack(struct ofpbuf *b, void *base, size_t allocated) | |
63 | { | |
64 | ofpbuf_use__(b, base, allocated, OFPBUF_STACK); | |
65 | } | |
66 | ||
cca408da BP |
67 | /* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of |
68 | * memory starting at 'base'. 'base' should point to a buffer on the stack. | |
69 | * (Nothing actually relies on 'base' being allocated on the stack. It could | |
be9fa766 | 70 | * be static or malloc()'d memory. But stack space is the most common use |
cca408da BP |
71 | * case.) |
72 | * | |
73 | * 'base' should be appropriately aligned. Using an array of uint32_t or | |
74 | * uint64_t for the buffer is a reasonable way to ensure appropriate alignment | |
125638eb | 75 | * for 32- or 64-bit data. |
cca408da BP |
76 | * |
77 | * An ofpbuf operation that requires reallocating data will copy the provided | |
78 | * buffer into a malloc()'d buffer. Thus, it is wise to call ofpbuf_uninit() | |
79 | * on an ofpbuf initialized by this function, so that if it expanded into the | |
80 | * heap, that memory is freed. */ | |
81 | void | |
82 | ofpbuf_use_stub(struct ofpbuf *b, void *base, size_t allocated) | |
83 | { | |
84 | ofpbuf_use__(b, base, allocated, OFPBUF_STUB); | |
85 | } | |
86 | ||
0bc9407d BP |
87 | /* Initializes 'b' as an ofpbuf whose data starts at 'data' and continues for |
88 | * 'size' bytes. This is appropriate for an ofpbuf that will be used to | |
89 | * inspect existing data, without moving it around or reallocating it, and | |
31ac1e59 BP |
90 | * generally without modifying it at all. |
91 | * | |
92 | * An ofpbuf operation that requires reallocating data will assert-fail if this | |
93 | * function was used to initialize it. */ | |
0bc9407d BP |
94 | void |
95 | ofpbuf_use_const(struct ofpbuf *b, const void *data, size_t size) | |
96 | { | |
ebc56baa | 97 | ofpbuf_use__(b, CONST_CAST(void *, data), size, OFPBUF_STACK); |
0bc9407d BP |
98 | b->size = size; |
99 | } | |
100 | ||
064af421 BP |
101 | /* Initializes 'b' as an empty ofpbuf with an initial capacity of 'size' |
102 | * bytes. */ | |
103 | void | |
104 | ofpbuf_init(struct ofpbuf *b, size_t size) | |
105 | { | |
106 | ofpbuf_use(b, size ? xmalloc(size) : NULL, size); | |
107 | } | |
108 | ||
109 | /* Frees memory that 'b' points to. */ | |
110 | void | |
d295e8e9 | 111 | ofpbuf_uninit(struct ofpbuf *b) |
064af421 | 112 | { |
31ac1e59 | 113 | if (b && b->source == OFPBUF_MALLOC) { |
064af421 BP |
114 | free(b->base); |
115 | } | |
116 | } | |
117 | ||
cca408da BP |
118 | /* Returns a pointer that may be passed to free() to accomplish the same thing |
119 | * as ofpbuf_uninit(b). The return value is a null pointer if ofpbuf_uninit() | |
120 | * would not free any memory. */ | |
121 | void * | |
122 | ofpbuf_get_uninit_pointer(struct ofpbuf *b) | |
123 | { | |
124 | return b && b->source == OFPBUF_MALLOC ? b->base : NULL; | |
125 | } | |
126 | ||
064af421 BP |
127 | /* Frees memory that 'b' points to and allocates a new ofpbuf */ |
128 | void | |
129 | ofpbuf_reinit(struct ofpbuf *b, size_t size) | |
130 | { | |
131 | ofpbuf_uninit(b); | |
132 | ofpbuf_init(b, size); | |
133 | } | |
134 | ||
135 | /* Creates and returns a new ofpbuf with an initial capacity of 'size' | |
136 | * bytes. */ | |
137 | struct ofpbuf * | |
138 | ofpbuf_new(size_t size) | |
139 | { | |
140 | struct ofpbuf *b = xmalloc(sizeof *b); | |
141 | ofpbuf_init(b, size); | |
142 | return b; | |
143 | } | |
144 | ||
68efcbec BP |
145 | /* Creates and returns a new ofpbuf with an initial capacity of 'size + |
146 | * headroom' bytes, reserving the first 'headroom' bytes as headroom. */ | |
147 | struct ofpbuf * | |
148 | ofpbuf_new_with_headroom(size_t size, size_t headroom) | |
149 | { | |
150 | struct ofpbuf *b = ofpbuf_new(size + headroom); | |
151 | ofpbuf_reserve(b, headroom); | |
152 | return b; | |
153 | } | |
154 | ||
a46c577a BP |
155 | /* Creates and returns a new ofpbuf that initially contains a copy of the |
156 | * 'buffer->size' bytes of data starting at 'buffer->data' with no headroom or | |
157 | * tailroom. */ | |
064af421 BP |
158 | struct ofpbuf * |
159 | ofpbuf_clone(const struct ofpbuf *buffer) | |
160 | { | |
6aa728e0 | 161 | return ofpbuf_clone_with_headroom(buffer, 0); |
064af421 BP |
162 | } |
163 | ||
68efcbec BP |
164 | /* Creates and returns a new ofpbuf whose data are copied from 'buffer'. The |
165 | * returned ofpbuf will additionally have 'headroom' bytes of headroom. */ | |
166 | struct ofpbuf * | |
167 | ofpbuf_clone_with_headroom(const struct ofpbuf *buffer, size_t headroom) | |
168 | { | |
6aa728e0 EJ |
169 | struct ofpbuf *new_buffer; |
170 | uintptr_t data_delta; | |
171 | ||
172 | new_buffer = ofpbuf_clone_data_with_headroom(buffer->data, buffer->size, | |
173 | headroom); | |
174 | data_delta = (char *) new_buffer->data - (char *) buffer->data; | |
175 | ||
176 | if (buffer->l2) { | |
177 | new_buffer->l2 = (char *) buffer->l2 + data_delta; | |
178 | } | |
b02475c5 SH |
179 | if (buffer->l2_5) { |
180 | new_buffer->l2_5 = (char *) buffer->l2_5 + data_delta; | |
181 | } | |
6aa728e0 EJ |
182 | if (buffer->l3) { |
183 | new_buffer->l3 = (char *) buffer->l3 + data_delta; | |
184 | } | |
185 | if (buffer->l4) { | |
186 | new_buffer->l4 = (char *) buffer->l4 + data_delta; | |
187 | } | |
188 | if (buffer->l7) { | |
189 | new_buffer->l7 = (char *) buffer->l7 + data_delta; | |
190 | } | |
191 | ||
192 | return new_buffer; | |
68efcbec BP |
193 | } |
194 | ||
a46c577a BP |
195 | /* Creates and returns a new ofpbuf that initially contains a copy of the |
196 | * 'size' bytes of data starting at 'data' with no headroom or tailroom. */ | |
064af421 BP |
197 | struct ofpbuf * |
198 | ofpbuf_clone_data(const void *data, size_t size) | |
199 | { | |
a46c577a BP |
200 | return ofpbuf_clone_data_with_headroom(data, size, 0); |
201 | } | |
202 | ||
203 | /* Creates and returns a new ofpbuf that initially contains 'headroom' bytes of | |
204 | * headroom followed by a copy of the 'size' bytes of data starting at | |
205 | * 'data'. */ | |
206 | struct ofpbuf * | |
207 | ofpbuf_clone_data_with_headroom(const void *data, size_t size, size_t headroom) | |
208 | { | |
209 | struct ofpbuf *b = ofpbuf_new_with_headroom(size, headroom); | |
064af421 BP |
210 | ofpbuf_put(b, data, size); |
211 | return b; | |
212 | } | |
213 | ||
214 | /* Frees memory that 'b' points to, as well as 'b' itself. */ | |
215 | void | |
d295e8e9 | 216 | ofpbuf_delete(struct ofpbuf *b) |
064af421 BP |
217 | { |
218 | if (b) { | |
219 | ofpbuf_uninit(b); | |
220 | free(b); | |
221 | } | |
222 | } | |
223 | ||
224 | /* Returns the number of bytes of headroom in 'b', that is, the number of bytes | |
225 | * of unused space in ofpbuf 'b' before the data that is in use. (Most | |
226 | * commonly, the data in a ofpbuf is at its beginning, and thus the ofpbuf's | |
227 | * headroom is 0.) */ | |
228 | size_t | |
5019f688 | 229 | ofpbuf_headroom(const struct ofpbuf *b) |
064af421 BP |
230 | { |
231 | return (char*)b->data - (char*)b->base; | |
232 | } | |
233 | ||
234 | /* Returns the number of bytes that may be appended to the tail end of ofpbuf | |
235 | * 'b' before the ofpbuf must be reallocated. */ | |
236 | size_t | |
5019f688 | 237 | ofpbuf_tailroom(const struct ofpbuf *b) |
064af421 BP |
238 | { |
239 | return (char*)ofpbuf_end(b) - (char*)ofpbuf_tail(b); | |
240 | } | |
241 | ||
1f5cbaa3 | 242 | static void |
0dce369b BP |
243 | ofpbuf_copy__(struct ofpbuf *b, uint8_t *new_base, |
244 | size_t new_headroom, size_t new_tailroom) | |
064af421 | 245 | { |
0dce369b BP |
246 | const uint8_t *old_base = b->base; |
247 | size_t old_headroom = ofpbuf_headroom(b); | |
248 | size_t old_tailroom = ofpbuf_tailroom(b); | |
249 | size_t copy_headroom = MIN(old_headroom, new_headroom); | |
250 | size_t copy_tailroom = MIN(old_tailroom, new_tailroom); | |
251 | ||
252 | memcpy(&new_base[new_headroom - copy_headroom], | |
253 | &old_base[old_headroom - copy_headroom], | |
254 | copy_headroom + b->size + copy_tailroom); | |
064af421 BP |
255 | } |
256 | ||
0dce369b BP |
257 | /* Reallocates 'b' so that it has exactly 'new_headroom' and 'new_tailroom' |
258 | * bytes of headroom and tailroom, respectively. */ | |
1f5cbaa3 | 259 | static void |
0dce369b | 260 | ofpbuf_resize__(struct ofpbuf *b, size_t new_headroom, size_t new_tailroom) |
1f5cbaa3 | 261 | { |
0dce369b | 262 | void *new_base, *new_data; |
31ac1e59 | 263 | size_t new_allocated; |
31ac1e59 | 264 | |
0dce369b | 265 | new_allocated = new_headroom + b->size + new_tailroom; |
31ac1e59 BP |
266 | |
267 | switch (b->source) { | |
268 | case OFPBUF_MALLOC: | |
0dce369b BP |
269 | if (new_headroom == ofpbuf_headroom(b)) { |
270 | new_base = xrealloc(b->base, new_allocated); | |
271 | } else { | |
272 | new_base = xmalloc(new_allocated); | |
273 | ofpbuf_copy__(b, new_base, new_headroom, new_tailroom); | |
274 | free(b->base); | |
275 | } | |
31ac1e59 BP |
276 | break; |
277 | ||
278 | case OFPBUF_STACK: | |
31ac1e59 BP |
279 | NOT_REACHED(); |
280 | ||
cca408da BP |
281 | case OFPBUF_STUB: |
282 | b->source = OFPBUF_MALLOC; | |
283 | new_base = xmalloc(new_allocated); | |
284 | ofpbuf_copy__(b, new_base, new_headroom, new_tailroom); | |
285 | break; | |
286 | ||
31ac1e59 BP |
287 | default: |
288 | NOT_REACHED(); | |
289 | } | |
290 | ||
291 | b->allocated = new_allocated; | |
0dce369b BP |
292 | b->base = new_base; |
293 | ||
294 | new_data = (char *) new_base + new_headroom; | |
295 | if (b->data != new_data) { | |
296 | uintptr_t data_delta = (char *) new_data - (char *) b->data; | |
297 | b->data = new_data; | |
298 | if (b->l2) { | |
299 | b->l2 = (char *) b->l2 + data_delta; | |
300 | } | |
b02475c5 SH |
301 | if (b->l2_5) { |
302 | b->l2_5 = (char *) b->l2_5 + data_delta; | |
303 | } | |
0dce369b BP |
304 | if (b->l3) { |
305 | b->l3 = (char *) b->l3 + data_delta; | |
306 | } | |
307 | if (b->l4) { | |
308 | b->l4 = (char *) b->l4 + data_delta; | |
309 | } | |
310 | if (b->l7) { | |
311 | b->l7 = (char *) b->l7 + data_delta; | |
312 | } | |
313 | } | |
1f5cbaa3 BP |
314 | } |
315 | ||
316 | /* Ensures that 'b' has room for at least 'size' bytes at its tail end, | |
317 | * reallocating and copying its data if necessary. Its headroom, if any, is | |
318 | * preserved. */ | |
319 | void | |
d295e8e9 | 320 | ofpbuf_prealloc_tailroom(struct ofpbuf *b, size_t size) |
1f5cbaa3 BP |
321 | { |
322 | if (size > ofpbuf_tailroom(b)) { | |
0dce369b | 323 | ofpbuf_resize__(b, ofpbuf_headroom(b), MAX(size, 64)); |
1f5cbaa3 BP |
324 | } |
325 | } | |
326 | ||
0dce369b BP |
327 | /* Ensures that 'b' has room for at least 'size' bytes at its head, |
328 | * reallocating and copying its data if necessary. Its tailroom, if any, is | |
329 | * preserved. */ | |
064af421 | 330 | void |
d295e8e9 | 331 | ofpbuf_prealloc_headroom(struct ofpbuf *b, size_t size) |
064af421 | 332 | { |
0dce369b BP |
333 | if (size > ofpbuf_headroom(b)) { |
334 | ofpbuf_resize__(b, MAX(size, 64), ofpbuf_tailroom(b)); | |
335 | } | |
064af421 BP |
336 | } |
337 | ||
1f5cbaa3 | 338 | /* Trims the size of 'b' to fit its actual content, reducing its tailroom to |
31ac1e59 BP |
339 | * 0. Its headroom, if any, is preserved. |
340 | * | |
341 | * Buffers not obtained from malloc() are not resized, since that wouldn't save | |
342 | * any memory. */ | |
064af421 BP |
343 | void |
344 | ofpbuf_trim(struct ofpbuf *b) | |
345 | { | |
0dce369b BP |
346 | if (b->source == OFPBUF_MALLOC |
347 | && (ofpbuf_headroom(b) || ofpbuf_tailroom(b))) { | |
348 | ofpbuf_resize__(b, 0, 0); | |
064af421 BP |
349 | } |
350 | } | |
351 | ||
63f2140a BP |
352 | /* If 'b' is shorter than 'length' bytes, pads its tail out with zeros to that |
353 | * length. */ | |
354 | void | |
355 | ofpbuf_padto(struct ofpbuf *b, size_t length) | |
356 | { | |
357 | if (b->size < length) { | |
358 | ofpbuf_put_zeros(b, length - b->size); | |
359 | } | |
360 | } | |
361 | ||
064af421 BP |
362 | /* Appends 'size' bytes of data to the tail end of 'b', reallocating and |
363 | * copying its data if necessary. Returns a pointer to the first byte of the | |
364 | * new data, which is left uninitialized. */ | |
365 | void * | |
d295e8e9 | 366 | ofpbuf_put_uninit(struct ofpbuf *b, size_t size) |
064af421 BP |
367 | { |
368 | void *p; | |
369 | ofpbuf_prealloc_tailroom(b, size); | |
370 | p = ofpbuf_tail(b); | |
371 | b->size += size; | |
372 | return p; | |
373 | } | |
374 | ||
375 | /* Appends 'size' zeroed bytes to the tail end of 'b'. Data in 'b' is | |
376 | * reallocated and copied if necessary. Returns a pointer to the first byte of | |
377 | * the data's location in the ofpbuf. */ | |
378 | void * | |
379 | ofpbuf_put_zeros(struct ofpbuf *b, size_t size) | |
380 | { | |
381 | void *dst = ofpbuf_put_uninit(b, size); | |
382 | memset(dst, 0, size); | |
383 | return dst; | |
384 | } | |
385 | ||
386 | /* Appends the 'size' bytes of data in 'p' to the tail end of 'b'. Data in 'b' | |
387 | * is reallocated and copied if necessary. Returns a pointer to the first | |
388 | * byte of the data's location in the ofpbuf. */ | |
389 | void * | |
d295e8e9 | 390 | ofpbuf_put(struct ofpbuf *b, const void *p, size_t size) |
064af421 BP |
391 | { |
392 | void *dst = ofpbuf_put_uninit(b, size); | |
393 | memcpy(dst, p, size); | |
394 | return dst; | |
395 | } | |
396 | ||
78090f63 BP |
397 | /* Parses as many pairs of hex digits as possible (possibly separated by |
398 | * spaces) from the beginning of 's', appending bytes for their values to 'b'. | |
399 | * Returns the first character of 's' that is not the first of a pair of hex | |
400 | * digits. If 'n' is nonnull, stores the number of bytes added to 'b' in | |
401 | * '*n'. */ | |
402 | char * | |
403 | ofpbuf_put_hex(struct ofpbuf *b, const char *s, size_t *n) | |
404 | { | |
405 | size_t initial_size = b->size; | |
406 | for (;;) { | |
407 | uint8_t byte; | |
408 | bool ok; | |
409 | ||
1a8def8e | 410 | s += strspn(s, " \t\r\n"); |
78090f63 BP |
411 | byte = hexits_value(s, 2, &ok); |
412 | if (!ok) { | |
413 | if (n) { | |
414 | *n = b->size - initial_size; | |
415 | } | |
ebc56baa | 416 | return CONST_CAST(char *, s); |
78090f63 BP |
417 | } |
418 | ||
419 | ofpbuf_put(b, &byte, 1); | |
420 | s += 2; | |
421 | } | |
422 | } | |
423 | ||
064af421 BP |
424 | /* Reserves 'size' bytes of headroom so that they can be later allocated with |
425 | * ofpbuf_push_uninit() without reallocating the ofpbuf. */ | |
426 | void | |
d295e8e9 | 427 | ofpbuf_reserve(struct ofpbuf *b, size_t size) |
064af421 | 428 | { |
cb22974d | 429 | ovs_assert(!b->size); |
064af421 BP |
430 | ofpbuf_prealloc_tailroom(b, size); |
431 | b->data = (char*)b->data + size; | |
432 | } | |
433 | ||
0dce369b BP |
434 | /* Prefixes 'size' bytes to the head end of 'b', reallocating and copying its |
435 | * data if necessary. Returns a pointer to the first byte of the data's | |
436 | * location in the ofpbuf. The new data is left uninitialized. */ | |
064af421 | 437 | void * |
d295e8e9 | 438 | ofpbuf_push_uninit(struct ofpbuf *b, size_t size) |
064af421 BP |
439 | { |
440 | ofpbuf_prealloc_headroom(b, size); | |
441 | b->data = (char*)b->data - size; | |
442 | b->size += size; | |
443 | return b->data; | |
444 | } | |
445 | ||
0dce369b BP |
446 | /* Prefixes 'size' zeroed bytes to the head end of 'b', reallocating and |
447 | * copying its data if necessary. Returns a pointer to the first byte of the | |
448 | * data's location in the ofpbuf. */ | |
30f07f1a BP |
449 | void * |
450 | ofpbuf_push_zeros(struct ofpbuf *b, size_t size) | |
451 | { | |
452 | void *dst = ofpbuf_push_uninit(b, size); | |
453 | memset(dst, 0, size); | |
454 | return dst; | |
455 | } | |
456 | ||
0dce369b BP |
457 | /* Copies the 'size' bytes starting at 'p' to the head end of 'b', reallocating |
458 | * and copying its data if necessary. Returns a pointer to the first byte of | |
459 | * the data's location in the ofpbuf. */ | |
064af421 | 460 | void * |
d295e8e9 | 461 | ofpbuf_push(struct ofpbuf *b, const void *p, size_t size) |
064af421 BP |
462 | { |
463 | void *dst = ofpbuf_push_uninit(b, size); | |
464 | memcpy(dst, p, size); | |
465 | return dst; | |
466 | } | |
467 | ||
468 | /* If 'b' contains at least 'offset + size' bytes of data, returns a pointer to | |
469 | * byte 'offset'. Otherwise, returns a null pointer. */ | |
470 | void * | |
d295e8e9 | 471 | ofpbuf_at(const struct ofpbuf *b, size_t offset, size_t size) |
064af421 BP |
472 | { |
473 | return offset + size <= b->size ? (char *) b->data + offset : NULL; | |
474 | } | |
475 | ||
476 | /* Returns a pointer to byte 'offset' in 'b', which must contain at least | |
477 | * 'offset + size' bytes of data. */ | |
478 | void * | |
d295e8e9 | 479 | ofpbuf_at_assert(const struct ofpbuf *b, size_t offset, size_t size) |
064af421 | 480 | { |
cb22974d | 481 | ovs_assert(offset + size <= b->size); |
064af421 BP |
482 | return ((char *) b->data) + offset; |
483 | } | |
484 | ||
485 | /* Returns the byte following the last byte of data in use in 'b'. */ | |
486 | void * | |
d295e8e9 | 487 | ofpbuf_tail(const struct ofpbuf *b) |
064af421 BP |
488 | { |
489 | return (char *) b->data + b->size; | |
490 | } | |
491 | ||
492 | /* Returns the byte following the last byte allocated for use (but not | |
493 | * necessarily in use) by 'b'. */ | |
494 | void * | |
d295e8e9 | 495 | ofpbuf_end(const struct ofpbuf *b) |
064af421 BP |
496 | { |
497 | return (char *) b->base + b->allocated; | |
498 | } | |
499 | ||
500 | /* Clears any data from 'b'. */ | |
501 | void | |
d295e8e9 | 502 | ofpbuf_clear(struct ofpbuf *b) |
064af421 BP |
503 | { |
504 | b->data = b->base; | |
505 | b->size = 0; | |
506 | } | |
507 | ||
508 | /* Removes 'size' bytes from the head end of 'b', which must contain at least | |
509 | * 'size' bytes of data. Returns the first byte of data removed. */ | |
510 | void * | |
d295e8e9 | 511 | ofpbuf_pull(struct ofpbuf *b, size_t size) |
064af421 BP |
512 | { |
513 | void *data = b->data; | |
cb22974d | 514 | ovs_assert(b->size >= size); |
064af421 BP |
515 | b->data = (char*)b->data + size; |
516 | b->size -= size; | |
517 | return data; | |
518 | } | |
519 | ||
520 | /* If 'b' has at least 'size' bytes of data, removes that many bytes from the | |
521 | * head end of 'b' and returns the first byte removed. Otherwise, returns a | |
522 | * null pointer without modifying 'b'. */ | |
523 | void * | |
d295e8e9 | 524 | ofpbuf_try_pull(struct ofpbuf *b, size_t size) |
064af421 BP |
525 | { |
526 | return b->size >= size ? ofpbuf_pull(b, size) : NULL; | |
527 | } | |
0ab8e15f | 528 | |
933369b1 BP |
529 | /* Returns the data in 'b' as a block of malloc()'d memory and frees the buffer |
530 | * within 'b'. (If 'b' itself was dynamically allocated, e.g. with | |
531 | * ofpbuf_new(), then it should still be freed with, e.g., ofpbuf_delete().) */ | |
532 | void * | |
533 | ofpbuf_steal_data(struct ofpbuf *b) | |
534 | { | |
535 | void *p; | |
536 | if (b->source == OFPBUF_MALLOC && b->data == b->base) { | |
537 | p = b->data; | |
538 | } else { | |
539 | p = xmemdup(b->data, b->size); | |
540 | if (b->source == OFPBUF_MALLOC) { | |
541 | free(b->base); | |
542 | } | |
543 | } | |
544 | b->base = b->data = NULL; | |
545 | return p; | |
546 | } | |
547 | ||
0ab8e15f BP |
548 | /* Returns a string that describes some of 'b''s metadata plus a hex dump of up |
549 | * to 'maxbytes' from the start of the buffer. */ | |
550 | char * | |
551 | ofpbuf_to_string(const struct ofpbuf *b, size_t maxbytes) | |
552 | { | |
553 | struct ds s; | |
554 | ||
555 | ds_init(&s); | |
34582733 | 556 | ds_put_format(&s, "size=%"PRIuSIZE", allocated=%"PRIuSIZE", head=%"PRIuSIZE", tail=%"PRIuSIZE"\n", |
0ab8e15f BP |
557 | b->size, b->allocated, |
558 | ofpbuf_headroom(b), ofpbuf_tailroom(b)); | |
559 | ds_put_hex_dump(&s, b->data, MIN(b->size, maxbytes), 0, false); | |
560 | return ds_cstr(&s); | |
561 | } | |
b3907fbc BP |
562 | |
563 | /* Removes each of the "struct ofpbuf"s on 'list' from the list and frees | |
564 | * them. */ | |
565 | void | |
566 | ofpbuf_list_delete(struct list *list) | |
567 | { | |
568 | struct ofpbuf *b, *next; | |
569 | ||
570 | LIST_FOR_EACH_SAFE (b, next, list_node, list) { | |
571 | list_remove(&b->list_node); | |
572 | ofpbuf_delete(b); | |
573 | } | |
574 | } |