1 /*
2 * Copyright (c) 2004 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Chris Pressey <cpressey@catseye.mine.nu>.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 */
34
35 /*
36 * extbuf.c
37 * $Id: buffer.c,v 1.2 2005/02/06 06:57:30 cpressey Exp $
38 * Routines to manipulate extensible buffers.
39 *
40 * Aura buffers are buffers that attempt to automatically expand
41 * when more data is written to them than they can initially hold.
42 * In addition, each extensible buffer contains a cursor from which
43 * its contents may be incrementally scanned.
44 */
45
46 #include <err.h>
47 #include <stdarg.h>
48 #include <stdio.h>
49 #include <stdlib.h>
50 #include <string.h>
51 #include <sysexits.h>
52
53 #include "buffer.h"
54
55 /*
56 * Create a new extensible buffer with the given initial size.
57 */
58 struct aura_buffer *
aura_buffer_new(size_t size)59 aura_buffer_new(size_t size)
60 {
61 struct aura_buffer *e;
62
63 e = malloc(sizeof(struct aura_buffer));
64
65 e->len = 0;
66 e->size = size;
67 e->pos = 0;
68
69 e->buf = malloc(size);
70 e->buf[0] = '\0';
71
72 return(e);
73 }
74
75 /*
76 * Deallocate the memory used for an extensible buffer.
77 */
78 void
aura_buffer_free(struct aura_buffer * e)79 aura_buffer_free(struct aura_buffer *e)
80 {
81 if (e != NULL) {
82 if (e->buf != NULL)
83 free(e->buf);
84 free(e);
85 }
86 }
87
88 /*
89 * Return the underlying (static) buffer of an extensible buffer.
90 *
91 * NOTE that you should NEVER cache the returned pointer anywhere,
92 * as any further manipulation of the extensible buffer may cause
93 * it to be invalidated.
94 *
95 * ALSO NOTE that the buffer may contain embedded NULs, but will
96 * also be guaranteed to be NUL-terminated.
97 */
98 char *
aura_buffer_buf(struct aura_buffer * e)99 aura_buffer_buf(struct aura_buffer *e)
100 {
101 return(e->buf);
102 }
103
104 /*
105 * Return the current length of the extensible buffer.
106 */
107 size_t
aura_buffer_len(struct aura_buffer * e)108 aura_buffer_len(struct aura_buffer *e)
109 {
110 return(e->len);
111 }
112
113 /*
114 * Return the current size of the extensible buffer. This is how
115 * big it's length may grow to before expanded.
116 */
117 size_t
aura_buffer_size(struct aura_buffer * e)118 aura_buffer_size(struct aura_buffer *e)
119 {
120 return(e->size);
121 }
122
123 /*
124 * Ensure that an extensible buffer's size is at least the given
125 * size. If it is not, it will be internally grown to that size.
126 * This does not affect the contents of the buffer in any way.
127 */
128 void
aura_buffer_ensure_size(struct aura_buffer * e,size_t size)129 aura_buffer_ensure_size(struct aura_buffer *e, size_t size)
130 {
131 if (e->size >= size) return;
132 e->size = size;
133 if ((e->buf = realloc(e->buf, e->size)) == NULL) {
134 err(EX_UNAVAILABLE, "realloc()");
135 }
136 }
137
138 /*
139 * Set the contents of an extensible buffer from a regular (char *)
140 * buffer. The extensible buffer will grow if needed. Any existing
141 * contents of the extensible buffer are destroyed in this operation.
142 * Note that, because this requires that the length of the
143 * regular buffer be specified, it may safely contain NUL bytes.
144 */
145 void
aura_buffer_set(struct aura_buffer * e,const char * buf,size_t length)146 aura_buffer_set(struct aura_buffer *e, const char *buf, size_t length)
147 {
148 while ((length + 1) > e->size) {
149 e->size *= 2;
150 }
151 if ((e->buf = realloc(e->buf, e->size)) == NULL) {
152 err(EX_UNAVAILABLE, "realloc()");
153 }
154 memcpy(e->buf, buf, length);
155 e->len = length;
156 e->buf[e->len] = '\0';
157 }
158
159 /*
160 * Append the contents of a regular buffer to the end of the existing
161 * contents of an extensible buffer. The extensible buffer will grow
162 * if needed. Note that, because this requires that the length of the
163 * regular buffer be specified, it may safely contain NUL bytes.
164 */
165 void
aura_buffer_append(struct aura_buffer * e,const char * buf,size_t length)166 aura_buffer_append(struct aura_buffer *e, const char *buf, size_t length)
167 {
168 while (e->len + (length + 1) > e->size) {
169 e->size *= 2;
170 }
171 if ((e->buf = realloc(e->buf, e->size)) == NULL) {
172 err(EX_UNAVAILABLE, "realloc()");
173 }
174 memcpy(e->buf + e->len, buf, length);
175 e->len += length;
176 e->buf[e->len] = '\0';
177 }
178
179 /*
180 * Set the contents of an extensible buffer from an ASCIIZ string.
181 * This is identical to aura_buffer_set except that the length need not
182 * be specified, and the ASCIIZ string may not contain embedded NUL's.
183 */
184 void
aura_buffer_cpy(struct aura_buffer * e,const char * s)185 aura_buffer_cpy(struct aura_buffer *e, const char *s)
186 {
187 aura_buffer_set(e, s, strlen(s));
188 }
189
190 /*
191 * Append the contents of an ASCIIZ string to an extensible buffer.
192 * This is identical to aura_buffer_append except that the length need not
193 * be specified, and the ASCIIZ string may not contain embedded NUL's.
194 */
195 void
aura_buffer_cat(struct aura_buffer * e,const char * s)196 aura_buffer_cat(struct aura_buffer *e, const char *s)
197 {
198 aura_buffer_append(e, s, strlen(s));
199 }
200
201 /*
202 * Append the entire contents of a text file to an extensible buffer.
203 */
204 int
aura_buffer_cat_file(struct aura_buffer * e,const char * fmt,...)205 aura_buffer_cat_file(struct aura_buffer *e, const char *fmt, ...)
206 {
207 va_list args;
208 char *filename, line[1024];
209 FILE *f;
210
211 va_start(args, fmt);
212 vasprintf(&filename, fmt, args);
213 va_end(args);
214
215 if ((f = fopen(filename, "r")) == NULL)
216 return(0);
217
218 free(filename);
219
220 while (fgets(line, 1023, f) != NULL) {
221 aura_buffer_cat(e, line);
222 }
223
224 fclose(f);
225
226 return(1);
227 }
228
229 /*
230 * Append the entire output of a shell command to an extensible buffer.
231 */
232 int
aura_buffer_cat_pipe(struct aura_buffer * e,const char * fmt,...)233 aura_buffer_cat_pipe(struct aura_buffer *e, const char *fmt, ...)
234 {
235 va_list args;
236 char *command, line[1024];
237 FILE *p;
238
239 va_start(args, fmt);
240 vasprintf(&command, fmt, args);
241 va_end(args);
242
243 if ((p = popen(command, "r")) == NULL)
244 return(0);
245
246 free(command);
247
248 while (fgets(line, 1023, p) != NULL) {
249 aura_buffer_cat(e, line);
250 }
251
252 pclose(p);
253
254 return(1);
255 }
256
257 /*** CURSORED FUNCTIONS ***/
258
259 /*
260 * Note that the cursor can be anywhere from the first character to
261 * one position _beyond_ the last character in the buffer.
262 */
263
264 int
aura_buffer_seek(struct aura_buffer * e,size_t pos)265 aura_buffer_seek(struct aura_buffer *e, size_t pos)
266 {
267 if (pos <= e->size) {
268 e->pos = pos;
269 return(1);
270 } else {
271 return(0);
272 }
273 }
274
275 size_t
aura_buffer_tell(struct aura_buffer * e)276 aura_buffer_tell(struct aura_buffer *e)
277 {
278 return(e->pos);
279 }
280
281 int
aura_buffer_eof(struct aura_buffer * e)282 aura_buffer_eof(struct aura_buffer *e)
283 {
284 return(e->pos >= e->size);
285 }
286
287 char
aura_buffer_peek_char(struct aura_buffer * e)288 aura_buffer_peek_char(struct aura_buffer *e)
289 {
290 return(e->buf[e->pos]);
291 }
292
293 char
aura_buffer_scan_char(struct aura_buffer * e)294 aura_buffer_scan_char(struct aura_buffer *e)
295 {
296 return(e->buf[e->pos++]);
297 }
298
299 int
aura_buffer_compare(struct aura_buffer * e,const char * s)300 aura_buffer_compare(struct aura_buffer *e, const char *s)
301 {
302 size_t i, pos;
303
304 for (i = 0, pos = e->pos; s[i] != '\0' && pos < e->size; i++, pos++) {
305 if (e->buf[pos] != s[i])
306 return(0);
307 }
308
309 if (pos <= e->size) {
310 return(pos);
311 } else {
312 return(0);
313 }
314 }
315
316 int
aura_buffer_expect(struct aura_buffer * e,const char * s)317 aura_buffer_expect(struct aura_buffer *e, const char *s)
318 {
319 int pos;
320
321 if ((pos = aura_buffer_compare(e, s)) > 0) {
322 e->pos = pos;
323 return(1);
324 } else {
325 return(0);
326 }
327 }
328
329 void
aura_buffer_push(struct aura_buffer * e,const void * src,size_t len)330 aura_buffer_push(struct aura_buffer *e, const void *src, size_t len)
331 {
332 aura_buffer_ensure_size(e, e->pos + len);
333 memcpy(e->buf + e->pos, src, len);
334 e->pos += len;
335 }
336
337 int
aura_buffer_pop(struct aura_buffer * e,void * dest,size_t len)338 aura_buffer_pop(struct aura_buffer *e, void *dest, size_t len)
339 {
340 if (e->pos - len > 0) {
341 e->pos -= len;
342 memcpy(dest, e->buf + e->pos, len);
343 return(1);
344 } else {
345 return(0);
346 }
347 }
348