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.
40 /* Initializes 'b' as an empty buffer that contains the 'allocated' bytes of
41 * memory starting at 'base'.
43 * 'base' should ordinarily be the first byte of a region obtained from
44 * malloc(), but in circumstances where it can be guaranteed that 'b' will
45 * never need to be expanded or freed, it can be a pointer into arbitrary
48 buffer_use(struct buffer *b, void *base, size_t allocated)
50 b->base = b->data = base;
51 b->allocated = allocated;
53 b->l2 = b->l3 = b->l4 = NULL;
57 /* Initializes 'b' as a buffer with an initial capacity of 'size' bytes. */
59 buffer_init(struct buffer *b, size_t size)
61 buffer_use(b, size ? xmalloc(size) : NULL, size);
64 /* Frees memory that 'b' points to. */
66 buffer_uninit(struct buffer *b)
73 /* Frees memory that 'b' points to and allocates a new buffer */
75 buffer_reinit(struct buffer *b, size_t size)
81 /* Creates and returns a new buffer with an initial capacity of 'size'
84 buffer_new(size_t size)
86 struct buffer *b = xmalloc(sizeof *b);
92 buffer_clone(const struct buffer *buffer)
94 /* FIXME: reference counting. */
95 struct buffer *b = buffer_new(buffer->size);
96 buffer_put(b, buffer->data, buffer->size);
100 /* Frees memory that 'b' points to, as well as 'b' itself. */
102 buffer_delete(struct buffer *b)
110 /* Returns the number of bytes of headroom in 'b', that is, the number of bytes
111 * of unused space in buffer 'b' before the data that is in use. (Most
112 * commonly, the data in a buffer is at its beginning, and thus the buffer's
115 buffer_headroom(struct buffer *b)
117 return b->data - b->base;
120 /* Returns the number of bytes that may be appended to the tail end of buffer
121 * 'b' before the buffer must be reallocated. */
123 buffer_tailroom(struct buffer *b)
125 return buffer_end(b) - buffer_tail(b);
128 /* Ensures that 'b' has room for at least 'size' bytes at its tail end,
129 * reallocating and copying its data if necessary. */
131 buffer_prealloc_tailroom(struct buffer *b, size_t size)
133 if (size > buffer_tailroom(b)) {
134 size_t new_allocated = b->allocated + MAX(size, 64);
135 void *new_base = xmalloc(new_allocated);
136 uintptr_t base_delta = new_base - b->base;
137 memcpy(new_base, b->base, b->allocated);
140 b->allocated = new_allocated;
141 b->data += base_delta;
155 buffer_prealloc_headroom(struct buffer *b, size_t size)
157 assert(size <= buffer_headroom(b));
160 /* Appends 'size' bytes of data to the tail end of 'b', reallocating and
161 * copying its data if necessary. Returns a pointer to the first byte of the
162 * new data, which is left uninitialized. */
164 buffer_put_uninit(struct buffer *b, size_t size)
167 buffer_prealloc_tailroom(b, size);
173 /* Appends the 'size' bytes of data in 'p' to the tail end of 'b'. Data in 'b'
174 * is reallocated and copied if necessary. Returns a pointer to the first
175 * byte of the data's location in the buffer. */
177 buffer_put(struct buffer *b, const void *p, size_t size)
179 void *dst = buffer_put_uninit(b, size);
180 memcpy(dst, p, size);
184 /* Reserves 'size' bytes of headroom so that they can be later allocated with
185 * buffer_push_uninit() without reallocating the buffer. */
187 buffer_reserve(struct buffer *b, size_t size)
190 buffer_prealloc_tailroom(b, size);
195 buffer_push_uninit(struct buffer *b, size_t size)
197 buffer_prealloc_headroom(b, size);
204 buffer_push(struct buffer *b, const void *p, size_t size)
206 void *dst = buffer_push_uninit(b, size);
207 memcpy(dst, p, size);
211 /* If 'b' contains at least 'offset + size' bytes of data, returns a pointer to
212 * byte 'offset'. Otherwise, returns a null pointers. */
214 buffer_at(const struct buffer *b, size_t offset, size_t size)
216 return offset + size <= b->size ? (char *) b->data + offset : NULL;
219 /* Returns a pointer to byte 'offset' in 'b', which must contain at least
220 * 'offset + size' bytes of data. */
222 buffer_at_assert(const struct buffer *b, size_t offset, size_t size)
224 assert(offset + size <= b->size);
225 return ((char *) b->data) + offset;
228 /* Returns the byte following the last byte of data in use in 'b'. */
230 buffer_tail(const struct buffer *b)
232 return (char *) b->data + b->size;
235 /* Returns the byte following the last byte allocated for use (but not
236 * necessarily in use) by 'b'. */
238 buffer_end(const struct buffer *b)
240 return (char *) b->base + b->allocated;
243 /* Clears any data from 'b'. */
245 buffer_clear(struct buffer *b)
251 /* Removes 'size' bytes from the head end of 'b', which must contain at least
252 * 'size' bytes of data. Returns the first byte of data removed. */
254 buffer_pull(struct buffer *b, size_t size)
256 void *data = b->data;
257 assert(b->size >= size);
263 /* If 'b' has at least 'size' bytes of data, removes that many bytes from the
264 * head end of 'b' and returns the first byte removed. Otherwise, returns a
265 * null pointer without modifying 'b'. */
267 buffer_try_pull(struct buffer *b, size_t size)
269 return b->size >= size ? buffer_pull(b, size) : NULL;