ofp-util: Avoid use-after-free in ofputil_encode_flow_mod().
[openvswitch] / lib / byteq.c
1 /* Copyright (c) 2008, 2009 Nicira, Inc.
2  *
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15
16 #include <config.h>
17 #include "byteq.h"
18 #include <assert.h>
19 #include <errno.h>
20 #include <string.h>
21 #include <unistd.h>
22 #include "util.h"
23
24 /* The queue size must be a power of 2. */
25 BUILD_ASSERT_DECL(!(BYTEQ_SIZE & (BYTEQ_SIZE - 1)));
26
27 /* Initializes 'q' as empty. */
28 void
29 byteq_init(struct byteq *q)
30 {
31     q->head = q->tail = 0;
32 }
33
34 /* Returns the number of bytes current queued in 'q'. */
35 int
36 byteq_used(const struct byteq *q)
37 {
38     return q->head - q->tail;
39 }
40
41 /* Returns the number of bytes that can be added to 'q' without overflow. */
42 int
43 byteq_avail(const struct byteq *q)
44 {
45     return BYTEQ_SIZE - byteq_used(q);
46 }
47
48 /* Returns true if no bytes are queued in 'q',
49  * false if at least one byte is queued.  */
50 bool
51 byteq_is_empty(const struct byteq *q)
52 {
53     return !byteq_used(q);
54 }
55
56 /* Returns true if 'q' has no room to queue additional bytes,
57  * false if 'q' has room for at least one more byte.  */
58 bool
59 byteq_is_full(const struct byteq *q)
60 {
61     return !byteq_avail(q);
62 }
63
64 /* Adds 'c' at the head of 'q', which must not be full. */
65 void
66 byteq_put(struct byteq *q, uint8_t c)
67 {
68     assert(!byteq_is_full(q));
69     *byteq_head(q) = c;
70     q->head++;
71 }
72
73 /* Adds the 'n' bytes in 'p' at the head of 'q', which must have at least 'n'
74  * bytes of free space. */
75 void
76 byteq_putn(struct byteq *q, const void *p_, size_t n)
77 {
78     const uint8_t *p = p_;
79     assert(byteq_avail(q) >= n);
80     while (n > 0) {
81         size_t chunk = MIN(n, byteq_headroom(q));
82         memcpy(byteq_head(q), p, chunk);
83         byteq_advance_head(q, chunk);
84         p += chunk;
85         n -= chunk;
86     }
87 }
88
89 /* Appends null-terminated string 's' to the head of 'q', which must have
90  * enough space.  The null terminator is not added to 'q'. */
91 void
92 byteq_put_string(struct byteq *q, const char *s)
93 {
94     byteq_putn(q, s, strlen(s));
95 }
96
97 /* Removes a byte from the tail of 'q' and returns it.  'q' must not be
98  * empty. */
99 uint8_t
100 byteq_get(struct byteq *q)
101 {
102     uint8_t c;
103     assert(!byteq_is_empty(q));
104     c = *byteq_tail(q);
105     q->tail++;
106     return c;
107 }
108
109 /* Writes as much of 'q' as possible to 'fd'.  Returns 0 if 'q' is fully
110  * drained by the write, otherwise a positive errno value (e.g. EAGAIN if a
111  * socket or tty buffer filled up). */
112 int
113 byteq_write(struct byteq *q, int fd)
114 {
115     while (!byteq_is_empty(q)) {
116         ssize_t n = write(fd, byteq_tail(q), byteq_tailroom(q));
117         if (n > 0) {
118             byteq_advance_tail(q, n);
119         } else {
120             assert(n < 0);
121             return errno;
122         }
123     }
124     return 0;
125 }
126
127 /* Reads as much possible from 'fd' into 'q'.  Returns 0 if 'q' is completely
128  * filled up by the read, EOF if end-of-file was reached before 'q' was filled,
129  * and otherwise a positive errno value (e.g. EAGAIN if a socket or tty buffer
130  * was drained). */
131 int
132 byteq_read(struct byteq *q, int fd)
133 {
134     while (!byteq_is_full(q)) {
135         ssize_t n = read(fd, byteq_head(q), byteq_headroom(q));
136         if (n > 0) {
137             byteq_advance_head(q, n);
138         } else {
139             return !n ? EOF : errno;
140         }
141     }
142     return 0;
143 }
144
145 /* Returns the number of contiguous bytes of in-use space starting at the tail
146  * of 'q'. */
147 int
148 byteq_tailroom(const struct byteq *q)
149 {
150     int used = byteq_used(q);
151     int tail_to_end = BYTEQ_SIZE - (q->tail & (BYTEQ_SIZE - 1));
152     return MIN(used, tail_to_end);
153 }
154
155 /* Returns the first in-use byte of 'q', the point at which data is removed
156  * from 'q'. */
157 const uint8_t *
158 byteq_tail(const struct byteq *q)
159 {
160     return &q->buffer[q->tail & (BYTEQ_SIZE - 1)];
161 }
162
163 /* Removes 'n' bytes from the tail of 'q', which must have at least 'n' bytes
164  * of tailroom. */
165 void
166 byteq_advance_tail(struct byteq *q, unsigned int n)
167 {
168     assert(byteq_tailroom(q) >= n);
169     q->tail += n;
170 }
171
172 /* Returns the byte after the last in-use byte of 'q', the point at which new
173  * data will be added to 'q'. */
174 uint8_t *
175 byteq_head(struct byteq *q)
176 {
177     return &q->buffer[q->head & (BYTEQ_SIZE - 1)];
178 }
179
180 /* Returns the number of contiguous bytes of free space starting at the head
181  * of 'q'. */
182 int
183 byteq_headroom(const struct byteq *q)
184 {
185     int avail = byteq_avail(q);
186     int head_to_end = BYTEQ_SIZE - (q->head & (BYTEQ_SIZE - 1));
187     return MIN(avail, head_to_end);
188 }
189
190 /* Adds to 'q' the 'n' bytes after the last currently in-use byte of 'q'.  'q'
191  * must have at least 'n' bytes of headroom. */
192 void
193 byteq_advance_head(struct byteq *q, unsigned int n)
194 {
195     assert(byteq_headroom(q) >= n);
196     q->head += n;
197 }