]>
Commit | Line | Data |
---|---|---|
064af421 | 1 | /* |
27aa8793 | 2 | * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2016 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> | |
64c96779 | 18 | #include "openvswitch/ofpbuf.h" |
064af421 BP |
19 | #include <stdlib.h> |
20 | #include <string.h> | |
3e8a2ad1 | 21 | #include "openvswitch/dynamic-string.h" |
064af421 BP |
22 | #include "util.h" |
23 | ||
d8a59e89 PS |
24 | static void |
25 | ofpbuf_init__(struct ofpbuf *b, size_t allocated, enum ofpbuf_source source) | |
26 | { | |
27 | b->allocated = allocated; | |
28 | b->source = source; | |
6fd6ed71 PS |
29 | b->header = NULL; |
30 | b->msg = NULL; | |
417e7e66 | 31 | ovs_list_poison(&b->list_node); |
d8a59e89 PS |
32 | } |
33 | ||
31ac1e59 | 34 | static void |
4ac6dbe6 | 35 | ofpbuf_use__(struct ofpbuf *b, void *base, size_t allocated, size_t size, |
31ac1e59 | 36 | enum ofpbuf_source source) |
064af421 | 37 | { |
6fd6ed71 PS |
38 | b->base = base; |
39 | b->data = base; | |
4ac6dbe6 | 40 | b->size = size; |
1f317cb5 | 41 | |
d8a59e89 | 42 | ofpbuf_init__(b, allocated, source); |
064af421 BP |
43 | } |
44 | ||
31ac1e59 BP |
45 | /* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of |
46 | * memory starting at 'base'. 'base' should be the first byte of a region | |
47 | * obtained from malloc(). It will be freed (with free()) if 'b' is resized or | |
48 | * freed. */ | |
662eba3a | 49 | static void |
31ac1e59 BP |
50 | ofpbuf_use(struct ofpbuf *b, void *base, size_t allocated) |
51 | { | |
4ac6dbe6 | 52 | ofpbuf_use__(b, base, allocated, 0, OFPBUF_MALLOC); |
31ac1e59 BP |
53 | } |
54 | ||
37e23720 AZ |
55 | /* Converts ds into ofpbuf 'b'. 'b' contains the 'ds->allocated' bytes of |
56 | * memory starting at 'ds->string'. 'ds' should not be modified any more. | |
57 | * The memory allocated for 'ds' will be freed (with free()) if 'b' is | |
58 | * resized or freed. */ | |
59 | void | |
60 | ofpbuf_use_ds(struct ofpbuf *b, const struct ds *ds) | |
61 | { | |
62 | ofpbuf_use__(b, ds->string, ds->allocated + 1, ds->length, OFPBUF_MALLOC); | |
63 | } | |
64 | ||
31ac1e59 BP |
65 | /* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of |
66 | * memory starting at 'base'. 'base' should point to a buffer on the stack. | |
cca408da BP |
67 | * (Nothing actually relies on 'base' being allocated on the stack. It could |
68 | * be static or malloc()'d memory. But stack space is the most common use | |
69 | * case.) | |
31ac1e59 BP |
70 | * |
71 | * 'base' should be appropriately aligned. Using an array of uint32_t or | |
72 | * uint64_t for the buffer is a reasonable way to ensure appropriate alignment | |
125638eb | 73 | * for 32- or 64-bit data. |
31ac1e59 | 74 | * |
cca408da BP |
75 | * An ofpbuf operation that requires reallocating data will assert-fail if this |
76 | * function was used to initialize it. Thus, one need not call ofpbuf_uninit() | |
77 | * on an ofpbuf initialized by this function (though doing so is harmless), | |
78 | * because it is guaranteed that 'b' does not own any heap-allocated memory. */ | |
31ac1e59 BP |
79 | void |
80 | ofpbuf_use_stack(struct ofpbuf *b, void *base, size_t allocated) | |
81 | { | |
4ac6dbe6 | 82 | ofpbuf_use__(b, base, allocated, 0, OFPBUF_STACK); |
31ac1e59 BP |
83 | } |
84 | ||
cca408da BP |
85 | /* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of |
86 | * memory starting at 'base'. 'base' should point to a buffer on the stack. | |
87 | * (Nothing actually relies on 'base' being allocated on the stack. It could | |
be9fa766 | 88 | * be static or malloc()'d memory. But stack space is the most common use |
cca408da BP |
89 | * case.) |
90 | * | |
91 | * 'base' should be appropriately aligned. Using an array of uint32_t or | |
92 | * uint64_t for the buffer is a reasonable way to ensure appropriate alignment | |
125638eb | 93 | * for 32- or 64-bit data. |
cca408da BP |
94 | * |
95 | * An ofpbuf operation that requires reallocating data will copy the provided | |
96 | * buffer into a malloc()'d buffer. Thus, it is wise to call ofpbuf_uninit() | |
97 | * on an ofpbuf initialized by this function, so that if it expanded into the | |
98 | * heap, that memory is freed. */ | |
99 | void | |
100 | ofpbuf_use_stub(struct ofpbuf *b, void *base, size_t allocated) | |
101 | { | |
4ac6dbe6 | 102 | ofpbuf_use__(b, base, allocated, 0, OFPBUF_STUB); |
cca408da BP |
103 | } |
104 | ||
0bc9407d BP |
105 | /* Initializes 'b' as an ofpbuf whose data starts at 'data' and continues for |
106 | * 'size' bytes. This is appropriate for an ofpbuf that will be used to | |
107 | * inspect existing data, without moving it around or reallocating it, and | |
31ac1e59 BP |
108 | * generally without modifying it at all. |
109 | * | |
110 | * An ofpbuf operation that requires reallocating data will assert-fail if this | |
111 | * function was used to initialize it. */ | |
0bc9407d BP |
112 | void |
113 | ofpbuf_use_const(struct ofpbuf *b, const void *data, size_t size) | |
114 | { | |
4ac6dbe6 | 115 | ofpbuf_use__(b, CONST_CAST(void *, data), size, size, OFPBUF_STACK); |
d8a59e89 PS |
116 | } |
117 | ||
064af421 BP |
118 | /* Initializes 'b' as an empty ofpbuf with an initial capacity of 'size' |
119 | * bytes. */ | |
120 | void | |
121 | ofpbuf_init(struct ofpbuf *b, size_t size) | |
122 | { | |
123 | ofpbuf_use(b, size ? xmalloc(size) : NULL, size); | |
124 | } | |
125 | ||
126 | /* Frees memory that 'b' points to. */ | |
127 | void | |
d295e8e9 | 128 | ofpbuf_uninit(struct ofpbuf *b) |
064af421 | 129 | { |
8a9562d2 PS |
130 | if (b) { |
131 | if (b->source == OFPBUF_MALLOC) { | |
6fd6ed71 | 132 | free(b->base); |
8a9562d2 | 133 | } |
064af421 BP |
134 | } |
135 | } | |
136 | ||
137 | /* Frees memory that 'b' points to and allocates a new ofpbuf */ | |
138 | void | |
139 | ofpbuf_reinit(struct ofpbuf *b, size_t size) | |
140 | { | |
141 | ofpbuf_uninit(b); | |
142 | ofpbuf_init(b, size); | |
143 | } | |
144 | ||
145 | /* Creates and returns a new ofpbuf with an initial capacity of 'size' | |
146 | * bytes. */ | |
147 | struct ofpbuf * | |
148 | ofpbuf_new(size_t size) | |
149 | { | |
150 | struct ofpbuf *b = xmalloc(sizeof *b); | |
151 | ofpbuf_init(b, size); | |
152 | return b; | |
153 | } | |
154 | ||
68efcbec BP |
155 | /* Creates and returns a new ofpbuf with an initial capacity of 'size + |
156 | * headroom' bytes, reserving the first 'headroom' bytes as headroom. */ | |
157 | struct ofpbuf * | |
158 | ofpbuf_new_with_headroom(size_t size, size_t headroom) | |
159 | { | |
160 | struct ofpbuf *b = ofpbuf_new(size + headroom); | |
161 | ofpbuf_reserve(b, headroom); | |
162 | return b; | |
163 | } | |
164 | ||
a46c577a | 165 | /* Creates and returns a new ofpbuf that initially contains a copy of the |
6fd6ed71 | 166 | * 'buffer->size' bytes of data starting at 'buffer->data' with no headroom or |
a46c577a | 167 | * tailroom. */ |
064af421 BP |
168 | struct ofpbuf * |
169 | ofpbuf_clone(const struct ofpbuf *buffer) | |
170 | { | |
6aa728e0 | 171 | return ofpbuf_clone_with_headroom(buffer, 0); |
064af421 BP |
172 | } |
173 | ||
68efcbec BP |
174 | /* Creates and returns a new ofpbuf whose data are copied from 'buffer'. The |
175 | * returned ofpbuf will additionally have 'headroom' bytes of headroom. */ | |
176 | struct ofpbuf * | |
742c06cc | 177 | ofpbuf_clone_with_headroom(const struct ofpbuf *b, size_t headroom) |
68efcbec | 178 | { |
6aa728e0 | 179 | struct ofpbuf *new_buffer; |
6aa728e0 | 180 | |
742c06cc JR |
181 | new_buffer = ofpbuf_clone_data_with_headroom(b->data, b->size, headroom); |
182 | if (b->header) { | |
183 | ptrdiff_t header_offset = (char *) b->header - (char *) b->data; | |
437d0d22 | 184 | |
742c06cc | 185 | new_buffer->header = (char *) new_buffer->data + header_offset; |
6aa728e0 | 186 | } |
aacaeb37 JR |
187 | if (b->msg) { |
188 | ptrdiff_t msg_offset = (char *) b->msg - (char *) b->data; | |
189 | ||
190 | new_buffer->msg = (char *) new_buffer->data + msg_offset; | |
191 | } | |
6aa728e0 EJ |
192 | |
193 | return new_buffer; | |
68efcbec BP |
194 | } |
195 | ||
a46c577a BP |
196 | /* Creates and returns a new ofpbuf that initially contains a copy of the |
197 | * 'size' bytes of data starting at 'data' with no headroom or tailroom. */ | |
064af421 BP |
198 | struct ofpbuf * |
199 | ofpbuf_clone_data(const void *data, size_t size) | |
200 | { | |
a46c577a BP |
201 | return ofpbuf_clone_data_with_headroom(data, size, 0); |
202 | } | |
203 | ||
204 | /* Creates and returns a new ofpbuf that initially contains 'headroom' bytes of | |
205 | * headroom followed by a copy of the 'size' bytes of data starting at | |
206 | * 'data'. */ | |
207 | struct ofpbuf * | |
208 | ofpbuf_clone_data_with_headroom(const void *data, size_t size, size_t headroom) | |
209 | { | |
210 | struct ofpbuf *b = ofpbuf_new_with_headroom(size, headroom); | |
064af421 BP |
211 | ofpbuf_put(b, data, size); |
212 | return b; | |
213 | } | |
214 | ||
1f5cbaa3 | 215 | static void |
0dce369b BP |
216 | ofpbuf_copy__(struct ofpbuf *b, uint8_t *new_base, |
217 | size_t new_headroom, size_t new_tailroom) | |
064af421 | 218 | { |
6fd6ed71 | 219 | const uint8_t *old_base = b->base; |
0dce369b BP |
220 | size_t old_headroom = ofpbuf_headroom(b); |
221 | size_t old_tailroom = ofpbuf_tailroom(b); | |
222 | size_t copy_headroom = MIN(old_headroom, new_headroom); | |
223 | size_t copy_tailroom = MIN(old_tailroom, new_tailroom); | |
224 | ||
225 | memcpy(&new_base[new_headroom - copy_headroom], | |
226 | &old_base[old_headroom - copy_headroom], | |
6fd6ed71 | 227 | copy_headroom + b->size + copy_tailroom); |
064af421 BP |
228 | } |
229 | ||
0dce369b BP |
230 | /* Reallocates 'b' so that it has exactly 'new_headroom' and 'new_tailroom' |
231 | * bytes of headroom and tailroom, respectively. */ | |
1f5cbaa3 | 232 | static void |
0dce369b | 233 | ofpbuf_resize__(struct ofpbuf *b, size_t new_headroom, size_t new_tailroom) |
1f5cbaa3 | 234 | { |
0dce369b | 235 | void *new_base, *new_data; |
31ac1e59 | 236 | size_t new_allocated; |
31ac1e59 | 237 | |
6fd6ed71 | 238 | new_allocated = new_headroom + b->size + new_tailroom; |
31ac1e59 BP |
239 | |
240 | switch (b->source) { | |
241 | case OFPBUF_MALLOC: | |
0dce369b | 242 | if (new_headroom == ofpbuf_headroom(b)) { |
6fd6ed71 | 243 | new_base = xrealloc(b->base, new_allocated); |
0dce369b BP |
244 | } else { |
245 | new_base = xmalloc(new_allocated); | |
246 | ofpbuf_copy__(b, new_base, new_headroom, new_tailroom); | |
6fd6ed71 | 247 | free(b->base); |
0dce369b | 248 | } |
31ac1e59 BP |
249 | break; |
250 | ||
251 | case OFPBUF_STACK: | |
428b2edd | 252 | OVS_NOT_REACHED(); |
31ac1e59 | 253 | |
cca408da BP |
254 | case OFPBUF_STUB: |
255 | b->source = OFPBUF_MALLOC; | |
256 | new_base = xmalloc(new_allocated); | |
257 | ofpbuf_copy__(b, new_base, new_headroom, new_tailroom); | |
258 | break; | |
259 | ||
31ac1e59 | 260 | default: |
428b2edd | 261 | OVS_NOT_REACHED(); |
31ac1e59 BP |
262 | } |
263 | ||
264 | b->allocated = new_allocated; | |
6fd6ed71 | 265 | b->base = new_base; |
0dce369b BP |
266 | |
267 | new_data = (char *) new_base + new_headroom; | |
6fd6ed71 PS |
268 | if (b->data != new_data) { |
269 | if (b->header) { | |
742c06cc | 270 | ptrdiff_t header_offset = (char *) b->header - (char *) b->data; |
437d0d22 | 271 | |
742c06cc | 272 | b->header = (char *) new_data + header_offset; |
38876d31 AW |
273 | } |
274 | if (b->msg) { | |
742c06cc | 275 | ptrdiff_t msg_offset = (char *) b->msg - (char *) b->data; |
38876d31 | 276 | |
742c06cc | 277 | b->msg = (char *) new_data + msg_offset; |
0dce369b | 278 | } |
6fd6ed71 | 279 | b->data = new_data; |
0dce369b | 280 | } |
1f5cbaa3 BP |
281 | } |
282 | ||
283 | /* Ensures that 'b' has room for at least 'size' bytes at its tail end, | |
284 | * reallocating and copying its data if necessary. Its headroom, if any, is | |
285 | * preserved. */ | |
286 | void | |
d295e8e9 | 287 | ofpbuf_prealloc_tailroom(struct ofpbuf *b, size_t size) |
1f5cbaa3 BP |
288 | { |
289 | if (size > ofpbuf_tailroom(b)) { | |
0dce369b | 290 | ofpbuf_resize__(b, ofpbuf_headroom(b), MAX(size, 64)); |
1f5cbaa3 BP |
291 | } |
292 | } | |
293 | ||
0dce369b BP |
294 | /* Ensures that 'b' has room for at least 'size' bytes at its head, |
295 | * reallocating and copying its data if necessary. Its tailroom, if any, is | |
296 | * preserved. */ | |
064af421 | 297 | void |
d295e8e9 | 298 | ofpbuf_prealloc_headroom(struct ofpbuf *b, size_t size) |
064af421 | 299 | { |
0dce369b BP |
300 | if (size > ofpbuf_headroom(b)) { |
301 | ofpbuf_resize__(b, MAX(size, 64), ofpbuf_tailroom(b)); | |
302 | } | |
064af421 BP |
303 | } |
304 | ||
8b6c2c88 WSH |
305 | /* Trims the size of 'b' to fit its actual content, reducing its headroom and |
306 | * tailroom to 0, if any. | |
31ac1e59 BP |
307 | * |
308 | * Buffers not obtained from malloc() are not resized, since that wouldn't save | |
38876d31 AW |
309 | * any memory. |
310 | * | |
311 | * Caller needs to updates 'b->header' and 'b->msg' so that they point to the | |
312 | * same locations in the data. (If they pointed into the tailroom or headroom | |
313 | * then they become invalid.) | |
314 | * | |
315 | */ | |
064af421 BP |
316 | void |
317 | ofpbuf_trim(struct ofpbuf *b) | |
318 | { | |
0dce369b BP |
319 | if (b->source == OFPBUF_MALLOC |
320 | && (ofpbuf_headroom(b) || ofpbuf_tailroom(b))) { | |
321 | ofpbuf_resize__(b, 0, 0); | |
064af421 BP |
322 | } |
323 | } | |
324 | ||
63f2140a BP |
325 | /* If 'b' is shorter than 'length' bytes, pads its tail out with zeros to that |
326 | * length. */ | |
327 | void | |
328 | ofpbuf_padto(struct ofpbuf *b, size_t length) | |
329 | { | |
6fd6ed71 PS |
330 | if (b->size < length) { |
331 | ofpbuf_put_zeros(b, length - b->size); | |
63f2140a BP |
332 | } |
333 | } | |
334 | ||
b2348f6d BP |
335 | /* Shifts all of the data within the allocated space in 'b' by 'delta' bytes. |
336 | * For example, a 'delta' of 1 would cause each byte of data to move one byte | |
337 | * forward (from address 'p' to 'p+1'), and a 'delta' of -1 would cause each | |
38876d31 AW |
338 | * byte to move one byte backward (from 'p' to 'p-1'). |
339 | * | |
340 | * If used, user must make sure the 'header' and 'msg' pointers are updated | |
341 | * after shifting. | |
342 | */ | |
b2348f6d BP |
343 | void |
344 | ofpbuf_shift(struct ofpbuf *b, int delta) | |
345 | { | |
346 | ovs_assert(delta > 0 ? delta <= ofpbuf_tailroom(b) | |
347 | : delta < 0 ? -delta <= ofpbuf_headroom(b) | |
348 | : true); | |
349 | ||
350 | if (delta != 0) { | |
6fd6ed71 PS |
351 | char *dst = (char *) b->data + delta; |
352 | memmove(dst, b->data, b->size); | |
353 | b->data = dst; | |
b2348f6d BP |
354 | } |
355 | } | |
356 | ||
064af421 BP |
357 | /* Appends 'size' bytes of data to the tail end of 'b', reallocating and |
358 | * copying its data if necessary. Returns a pointer to the first byte of the | |
359 | * new data, which is left uninitialized. */ | |
360 | void * | |
d295e8e9 | 361 | ofpbuf_put_uninit(struct ofpbuf *b, size_t size) |
064af421 BP |
362 | { |
363 | void *p; | |
364 | ofpbuf_prealloc_tailroom(b, size); | |
365 | p = ofpbuf_tail(b); | |
6fd6ed71 | 366 | b->size += size; |
064af421 BP |
367 | return p; |
368 | } | |
369 | ||
370 | /* Appends 'size' zeroed bytes to the tail end of 'b'. Data in 'b' is | |
371 | * reallocated and copied if necessary. Returns a pointer to the first byte of | |
372 | * the data's location in the ofpbuf. */ | |
373 | void * | |
374 | ofpbuf_put_zeros(struct ofpbuf *b, size_t size) | |
375 | { | |
376 | void *dst = ofpbuf_put_uninit(b, size); | |
316d0932 | 377 | nullable_memset(dst, 0, size); |
064af421 BP |
378 | return dst; |
379 | } | |
380 | ||
381 | /* Appends the 'size' bytes of data in 'p' to the tail end of 'b'. Data in 'b' | |
382 | * is reallocated and copied if necessary. Returns a pointer to the first | |
383 | * byte of the data's location in the ofpbuf. */ | |
384 | void * | |
d295e8e9 | 385 | ofpbuf_put(struct ofpbuf *b, const void *p, size_t size) |
064af421 BP |
386 | { |
387 | void *dst = ofpbuf_put_uninit(b, size); | |
388 | memcpy(dst, p, size); | |
389 | return dst; | |
390 | } | |
391 | ||
27aa8793 BP |
392 | /* Parses as many pairs of hex digits as possible (possibly separated by spaces |
393 | * or periods) from the beginning of 's', appending bytes for their values to | |
394 | * 'b'. Returns the first character of 's' that is not the first of a pair of | |
395 | * hex digits. If 'n' is nonnull, stores the number of bytes added to 'b' in | |
78090f63 BP |
396 | * '*n'. */ |
397 | char * | |
398 | ofpbuf_put_hex(struct ofpbuf *b, const char *s, size_t *n) | |
399 | { | |
6fd6ed71 | 400 | size_t initial_size = b->size; |
78090f63 BP |
401 | for (;;) { |
402 | uint8_t byte; | |
403 | bool ok; | |
404 | ||
27aa8793 | 405 | s += strspn(s, " .\t\r\n"); |
78090f63 BP |
406 | byte = hexits_value(s, 2, &ok); |
407 | if (!ok) { | |
408 | if (n) { | |
6fd6ed71 | 409 | *n = b->size - initial_size; |
78090f63 | 410 | } |
ebc56baa | 411 | return CONST_CAST(char *, s); |
78090f63 BP |
412 | } |
413 | ||
414 | ofpbuf_put(b, &byte, 1); | |
415 | s += 2; | |
416 | } | |
417 | } | |
418 | ||
064af421 BP |
419 | /* Reserves 'size' bytes of headroom so that they can be later allocated with |
420 | * ofpbuf_push_uninit() without reallocating the ofpbuf. */ | |
421 | void | |
d295e8e9 | 422 | ofpbuf_reserve(struct ofpbuf *b, size_t size) |
064af421 | 423 | { |
6fd6ed71 | 424 | ovs_assert(!b->size); |
064af421 | 425 | ofpbuf_prealloc_tailroom(b, size); |
6fd6ed71 | 426 | b->data = (char*)b->data + size; |
da546e07 JR |
427 | } |
428 | ||
0dce369b BP |
429 | /* Prefixes 'size' bytes to the head end of 'b', reallocating and copying its |
430 | * data if necessary. Returns a pointer to the first byte of the data's | |
431 | * location in the ofpbuf. The new data is left uninitialized. */ | |
064af421 | 432 | void * |
d295e8e9 | 433 | ofpbuf_push_uninit(struct ofpbuf *b, size_t size) |
064af421 BP |
434 | { |
435 | ofpbuf_prealloc_headroom(b, size); | |
6fd6ed71 PS |
436 | b->data = (char*)b->data - size; |
437 | b->size += size; | |
438 | return b->data; | |
064af421 BP |
439 | } |
440 | ||
0dce369b BP |
441 | /* Prefixes 'size' zeroed bytes to the head end of 'b', reallocating and |
442 | * copying its data if necessary. Returns a pointer to the first byte of the | |
443 | * data's location in the ofpbuf. */ | |
30f07f1a BP |
444 | void * |
445 | ofpbuf_push_zeros(struct ofpbuf *b, size_t size) | |
446 | { | |
447 | void *dst = ofpbuf_push_uninit(b, size); | |
448 | memset(dst, 0, size); | |
449 | return dst; | |
450 | } | |
451 | ||
0dce369b BP |
452 | /* Copies the 'size' bytes starting at 'p' to the head end of 'b', reallocating |
453 | * and copying its data if necessary. Returns a pointer to the first byte of | |
454 | * the data's location in the ofpbuf. */ | |
064af421 | 455 | void * |
d295e8e9 | 456 | ofpbuf_push(struct ofpbuf *b, const void *p, size_t size) |
064af421 BP |
457 | { |
458 | void *dst = ofpbuf_push_uninit(b, size); | |
459 | memcpy(dst, p, size); | |
460 | return dst; | |
461 | } | |
462 | ||
07e73e08 BP |
463 | /* Inserts the 'n' bytes of 'data' into 'b' starting at the given 'offset', |
464 | * moving data forward as necessary to make room. | |
465 | * | |
466 | * 'data' must not point inside 'b'. */ | |
467 | void | |
468 | ofpbuf_insert(struct ofpbuf *b, size_t offset, const void *data, size_t n) | |
469 | { | |
470 | if (offset < b->size) { | |
39976b99 | 471 | ofpbuf_put_uninit(b, n); /* b->size gets increased. */ |
07e73e08 | 472 | memmove((char *) b->data + offset + n, (char *) b->data + offset, |
39976b99 | 473 | b->size - offset - n); |
07e73e08 BP |
474 | memcpy((char *) b->data + offset, data, n); |
475 | } else { | |
476 | ovs_assert(offset == b->size); | |
477 | ofpbuf_put(b, data, n); | |
478 | } | |
479 | } | |
480 | ||
933369b1 BP |
481 | /* Returns the data in 'b' as a block of malloc()'d memory and frees the buffer |
482 | * within 'b'. (If 'b' itself was dynamically allocated, e.g. with | |
483 | * ofpbuf_new(), then it should still be freed with, e.g., ofpbuf_delete().) */ | |
484 | void * | |
485 | ofpbuf_steal_data(struct ofpbuf *b) | |
486 | { | |
487 | void *p; | |
20ebd771 | 488 | |
6fd6ed71 PS |
489 | if (b->source == OFPBUF_MALLOC && b->data == b->base) { |
490 | p = b->data; | |
933369b1 | 491 | } else { |
6fd6ed71 | 492 | p = xmemdup(b->data, b->size); |
933369b1 | 493 | if (b->source == OFPBUF_MALLOC) { |
6fd6ed71 | 494 | free(b->base); |
933369b1 BP |
495 | } |
496 | } | |
6fd6ed71 PS |
497 | b->base = NULL; |
498 | b->data = NULL; | |
38876d31 AW |
499 | b->header = NULL; |
500 | b->msg = NULL; | |
933369b1 BP |
501 | return p; |
502 | } | |
503 | ||
0ab8e15f BP |
504 | /* Returns a string that describes some of 'b''s metadata plus a hex dump of up |
505 | * to 'maxbytes' from the start of the buffer. */ | |
506 | char * | |
507 | ofpbuf_to_string(const struct ofpbuf *b, size_t maxbytes) | |
508 | { | |
509 | struct ds s; | |
510 | ||
511 | ds_init(&s); | |
437d0d22 | 512 | ds_put_format(&s, "size=%"PRIu32", allocated=%"PRIu32", head=%"PRIuSIZE", tail=%"PRIuSIZE"\n", |
6fd6ed71 | 513 | b->size, b->allocated, |
0ab8e15f | 514 | ofpbuf_headroom(b), ofpbuf_tailroom(b)); |
6fd6ed71 | 515 | ds_put_hex_dump(&s, b->data, MIN(b->size, maxbytes), 0, false); |
0ab8e15f BP |
516 | return ds_cstr(&s); |
517 | } | |
b3907fbc BP |
518 | |
519 | /* Removes each of the "struct ofpbuf"s on 'list' from the list and frees | |
520 | * them. */ | |
521 | void | |
ca6ba700 | 522 | ofpbuf_list_delete(struct ovs_list *list) |
b3907fbc | 523 | { |
5f03c983 | 524 | struct ofpbuf *b; |
b3907fbc | 525 | |
5f03c983 | 526 | LIST_FOR_EACH_POP (b, list_node, list) { |
b3907fbc BP |
527 | ofpbuf_delete(b); |
528 | } | |
529 | } |