1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
4 * We are making the OpenFlow specification and associated documentation
5 * (Software) available for public use and benefit with the expectation
6 * that others will use, modify and enhance the Software and contribute
7 * those enhancements back to the community. However, since we would
8 * like to make the Software available for broadest use, with as few
9 * restrictions as possible permission is hereby granted, free of
10 * charge, to any person obtaining a copy of this Software to deal in
11 * the Software under the copyrights without restriction, including
12 * without limitation the rights to use, copy, modify, merge, publish,
13 * distribute, sublicense, and/or sell copies of the Software, and to
14 * permit persons to whom the Software is furnished to do so, subject to
15 * the following conditions:
17 * The above copyright notice and this permission notice shall be
18 * included in all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
21 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
22 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
23 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
24 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
25 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
26 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
29 * The name and trademarks of copyright holder(s) may NOT be used in
30 * advertising or publicity pertaining to the Software or any
31 * derivatives without specific, written prior permission.
41 /* Initializes 'b' as an empty ofpbuf that contains the 'allocated' bytes of
42 * memory starting at 'base'.
44 * 'base' should ordinarily be the first byte of a region obtained from
45 * malloc(), but in circumstances where it can be guaranteed that 'b' will
46 * never need to be expanded or freed, it can be a pointer into arbitrary
49 ofpbuf_use(struct ofpbuf *b, void *base, size_t allocated)
51 b->base = b->data = base;
52 b->allocated = allocated;
54 b->l2 = b->l3 = b->l4 = b->l7 = NULL;
59 /* Initializes 'b' as an empty ofpbuf with an initial capacity of 'size'
62 ofpbuf_init(struct ofpbuf *b, size_t size)
64 ofpbuf_use(b, size ? xmalloc(size) : NULL, size);
67 /* Frees memory that 'b' points to. */
69 ofpbuf_uninit(struct ofpbuf *b)
76 /* Frees memory that 'b' points to and allocates a new ofpbuf */
78 ofpbuf_reinit(struct ofpbuf *b, size_t size)
84 /* Creates and returns a new ofpbuf with an initial capacity of 'size'
87 ofpbuf_new(size_t size)
89 struct ofpbuf *b = xmalloc(sizeof *b);
95 ofpbuf_clone(const struct ofpbuf *buffer)
97 /* FIXME: reference counting. */
98 struct ofpbuf *b = ofpbuf_new(buffer->size);
99 ofpbuf_put(b, buffer->data, buffer->size);
103 /* Frees memory that 'b' points to, as well as 'b' itself. */
105 ofpbuf_delete(struct ofpbuf *b)
113 /* Returns the number of bytes of headroom in 'b', that is, the number of bytes
114 * of unused space in ofpbuf 'b' before the data that is in use. (Most
115 * commonly, the data in a ofpbuf is at its beginning, and thus the ofpbuf's
118 ofpbuf_headroom(struct ofpbuf *b)
120 return b->data - b->base;
123 /* Returns the number of bytes that may be appended to the tail end of ofpbuf
124 * 'b' before the ofpbuf must be reallocated. */
126 ofpbuf_tailroom(struct ofpbuf *b)
128 return ofpbuf_end(b) - ofpbuf_tail(b);
131 /* Ensures that 'b' has room for at least 'size' bytes at its tail end,
132 * reallocating and copying its data if necessary. */
134 ofpbuf_prealloc_tailroom(struct ofpbuf *b, size_t size)
136 if (size > ofpbuf_tailroom(b)) {
137 size_t new_allocated = b->allocated + MAX(size, 64);
138 void *new_base = xmalloc(new_allocated);
139 uintptr_t base_delta = new_base - b->base;
140 memcpy(new_base, b->base, b->allocated);
143 b->allocated = new_allocated;
144 b->data += base_delta;
161 ofpbuf_prealloc_headroom(struct ofpbuf *b, size_t size)
163 assert(size <= ofpbuf_headroom(b));
166 /* Appends 'size' bytes of data to the tail end of 'b', reallocating and
167 * copying its data if necessary. Returns a pointer to the first byte of the
168 * new data, which is left uninitialized. */
170 ofpbuf_put_uninit(struct ofpbuf *b, size_t size)
173 ofpbuf_prealloc_tailroom(b, size);
179 /* Appends the 'size' bytes of data in 'p' to the tail end of 'b'. Data in 'b'
180 * is reallocated and copied if necessary. Returns a pointer to the first
181 * byte of the data's location in the ofpbuf. */
183 ofpbuf_put(struct ofpbuf *b, const void *p, size_t size)
185 void *dst = ofpbuf_put_uninit(b, size);
186 memcpy(dst, p, size);
190 /* Reserves 'size' bytes of headroom so that they can be later allocated with
191 * ofpbuf_push_uninit() without reallocating the ofpbuf. */
193 ofpbuf_reserve(struct ofpbuf *b, size_t size)
196 ofpbuf_prealloc_tailroom(b, size);
201 ofpbuf_push_uninit(struct ofpbuf *b, size_t size)
203 ofpbuf_prealloc_headroom(b, size);
210 ofpbuf_push(struct ofpbuf *b, const void *p, size_t size)
212 void *dst = ofpbuf_push_uninit(b, size);
213 memcpy(dst, p, size);
217 /* If 'b' contains at least 'offset + size' bytes of data, returns a pointer to
218 * byte 'offset'. Otherwise, returns a null pointer. */
220 ofpbuf_at(const struct ofpbuf *b, size_t offset, size_t size)
222 return offset + size <= b->size ? (char *) b->data + offset : NULL;
225 /* Returns a pointer to byte 'offset' in 'b', which must contain at least
226 * 'offset + size' bytes of data. */
228 ofpbuf_at_assert(const struct ofpbuf *b, size_t offset, size_t size)
230 assert(offset + size <= b->size);
231 return ((char *) b->data) + offset;
234 /* Returns the byte following the last byte of data in use in 'b'. */
236 ofpbuf_tail(const struct ofpbuf *b)
238 return (char *) b->data + b->size;
241 /* Returns the byte following the last byte allocated for use (but not
242 * necessarily in use) by 'b'. */
244 ofpbuf_end(const struct ofpbuf *b)
246 return (char *) b->base + b->allocated;
249 /* Clears any data from 'b'. */
251 ofpbuf_clear(struct ofpbuf *b)
257 /* Removes 'size' bytes from the head end of 'b', which must contain at least
258 * 'size' bytes of data. Returns the first byte of data removed. */
260 ofpbuf_pull(struct ofpbuf *b, size_t size)
262 void *data = b->data;
263 assert(b->size >= size);
269 /* If 'b' has at least 'size' bytes of data, removes that many bytes from the
270 * head end of 'b' and returns the first byte removed. Otherwise, returns a
271 * null pointer without modifying 'b'. */
273 ofpbuf_try_pull(struct ofpbuf *b, size_t size)
275 return b->size >= size ? ofpbuf_pull(b, size) : NULL;