FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_sbuf.c
1 /*-
2 * Copyright (c) 2000 Poul-Henning Kamp and Dag-Erling Coïdan Smørgrav
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD$
29 */
30
31 #include <sys/param.h>
32
33 #ifdef _KERNEL
34 #include <sys/ctype.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <sys/systm.h>
38 #include <sys/uio.h>
39 #include <machine/stdarg.h>
40 #else /* _KERNEL */
41 #include <ctype.h>
42 #include <stdarg.h>
43 #include <stdio.h>
44 #include <stdlib.h>
45 #include <string.h>
46 #endif /* _KERNEL */
47
48 #include <sys/sbuf.h>
49
50 #ifdef _KERNEL
51 MALLOC_DEFINE(M_SBUF, "sbuf", "string buffers");
52 #define SBMALLOC(size) malloc(size, M_SBUF, M_WAITOK)
53 #define SBFREE(buf) free(buf, M_SBUF)
54 #else /* _KERNEL */
55 #define KASSERT(e, m)
56 #define SBMALLOC(size) malloc(size)
57 #define SBFREE(buf) free(buf)
58 #define min(x,y) MIN(x,y)
59 #endif /* _KERNEL */
60
61 /*
62 * Predicates
63 */
64 #define SBUF_ISDYNAMIC(s) ((s)->s_flags & SBUF_DYNAMIC)
65 #define SBUF_ISDYNSTRUCT(s) ((s)->s_flags & SBUF_DYNSTRUCT)
66 #define SBUF_ISFINISHED(s) ((s)->s_flags & SBUF_FINISHED)
67 #define SBUF_HASOVERFLOWED(s) ((s)->s_flags & SBUF_OVERFLOWED)
68 #define SBUF_HASROOM(s) ((s)->s_len < (s)->s_size - 1)
69 #define SBUF_FREESPACE(s) ((s)->s_size - (s)->s_len - 1)
70 #define SBUF_CANEXTEND(s) ((s)->s_flags & SBUF_AUTOEXTEND)
71
72 /*
73 * Set / clear flags
74 */
75 #define SBUF_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0)
76 #define SBUF_CLEARFLAG(s, f) do { (s)->s_flags &= ~(f); } while (0)
77
78 #define SBUF_MINEXTENDSIZE 16 /* Should be power of 2. */
79 #define SBUF_MAXEXTENDSIZE PAGE_SIZE
80 #define SBUF_MAXEXTENDINCR PAGE_SIZE
81
82 /*
83 * Debugging support
84 */
85 #if defined(_KERNEL) && defined(INVARIANTS)
86 static void
87 _assert_sbuf_integrity(char *fun, struct sbuf *s)
88 {
89 KASSERT(s != NULL,
90 ("%s called with a NULL sbuf pointer", fun));
91 KASSERT(s->s_buf != NULL,
92 ("%s called with uninitialized or corrupt sbuf", fun));
93 KASSERT(s->s_len < s->s_size,
94 ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
95 }
96
97 static void
98 _assert_sbuf_state(char *fun, struct sbuf *s, int state)
99 {
100 KASSERT((s->s_flags & SBUF_FINISHED) == state,
101 ("%s called with %sfinished or corrupt sbuf", fun,
102 (state ? "un" : "")));
103 }
104 #define assert_sbuf_integrity(s) _assert_sbuf_integrity(__FUNCTION__, (s))
105 #define assert_sbuf_state(s, i) _assert_sbuf_state(__FUNCTION__, (s), (i))
106 #else /* _KERNEL && INVARIANTS */
107 #define assert_sbuf_integrity(s) do { } while (0)
108 #define assert_sbuf_state(s, i) do { } while (0)
109 #endif /* _KERNEL && INVARIANTS */
110
111 static int
112 sbuf_extendsize(int size)
113 {
114 int newsize;
115
116 newsize = SBUF_MINEXTENDSIZE;
117 while (newsize < size) {
118 if (newsize < SBUF_MAXEXTENDSIZE)
119 newsize *= 2;
120 else
121 newsize += SBUF_MAXEXTENDINCR;
122 }
123
124 return (newsize);
125 }
126
127
128 /*
129 * Extend an sbuf.
130 */
131 static int
132 sbuf_extend(struct sbuf *s, int addlen)
133 {
134 char *newbuf;
135 int newsize;
136
137 if (!SBUF_CANEXTEND(s))
138 return (-1);
139
140 newsize = sbuf_extendsize(s->s_size + addlen);
141 newbuf = (char *)SBMALLOC(newsize);
142 if (newbuf == NULL)
143 return (-1);
144 bcopy(s->s_buf, newbuf, s->s_size);
145 if (SBUF_ISDYNAMIC(s))
146 SBFREE(s->s_buf);
147 else
148 SBUF_SETFLAG(s, SBUF_DYNAMIC);
149 s->s_buf = newbuf;
150 s->s_size = newsize;
151 return (0);
152 }
153
154 /*
155 * Initialize an sbuf.
156 * If buf is non-NULL, it points to a static or already-allocated string
157 * big enough to hold at least length characters.
158 */
159 struct sbuf *
160 sbuf_new(struct sbuf *s, char *buf, int length, int flags)
161 {
162 KASSERT(length >= 0,
163 ("attempt to create an sbuf of negative length (%d)", length));
164 KASSERT((flags & ~SBUF_USRFLAGMSK) == 0,
165 ("%s called with invalid flags", __FUNCTION__));
166
167 flags &= SBUF_USRFLAGMSK;
168 if (s == NULL) {
169 s = (struct sbuf *)SBMALLOC(sizeof *s);
170 if (s == NULL)
171 return (NULL);
172 bzero(s, sizeof *s);
173 s->s_flags = flags;
174 SBUF_SETFLAG(s, SBUF_DYNSTRUCT);
175 } else {
176 bzero(s, sizeof *s);
177 s->s_flags = flags;
178 }
179 s->s_size = length;
180 if (buf) {
181 s->s_buf = buf;
182 return (s);
183 }
184 if (flags & SBUF_AUTOEXTEND)
185 s->s_size = sbuf_extendsize(s->s_size);
186 s->s_buf = (char *)SBMALLOC(s->s_size);
187 if (s->s_buf == NULL) {
188 if (SBUF_ISDYNSTRUCT(s))
189 SBFREE(s);
190 return (NULL);
191 }
192 SBUF_SETFLAG(s, SBUF_DYNAMIC);
193 return (s);
194 }
195
196 #ifdef _KERNEL
197 /*
198 * Create an sbuf with uio data
199 */
200 struct sbuf *
201 sbuf_uionew(struct sbuf *s, struct uio *uio, int *error)
202 {
203 KASSERT(uio != NULL,
204 ("%s called with NULL uio pointer", __FUNCTION__));
205 KASSERT(error != NULL,
206 ("%s called with NULL error pointer", __FUNCTION__));
207
208 s = sbuf_new(s, NULL, uio->uio_resid + 1, 0);
209 if (s == NULL) {
210 *error = ENOMEM;
211 return (NULL);
212 }
213 *error = uiomove(s->s_buf, uio->uio_resid, uio);
214 if (*error != 0) {
215 sbuf_delete(s);
216 return (NULL);
217 }
218 s->s_len = s->s_size - 1;
219 *error = 0;
220 return (s);
221 }
222 #endif
223
224 /*
225 * Clear an sbuf and reset its position.
226 */
227 void
228 sbuf_clear(struct sbuf *s)
229 {
230 assert_sbuf_integrity(s);
231 /* don't care if it's finished or not */
232
233 SBUF_CLEARFLAG(s, SBUF_FINISHED);
234 SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
235 s->s_len = 0;
236 }
237
238 /*
239 * Set the sbuf's end position to an arbitrary value.
240 * Effectively truncates the sbuf at the new position.
241 */
242 int
243 sbuf_setpos(struct sbuf *s, int pos)
244 {
245 assert_sbuf_integrity(s);
246 assert_sbuf_state(s, 0);
247
248 KASSERT(pos >= 0,
249 ("attempt to seek to a negative position (%d)", pos));
250 KASSERT(pos < s->s_size,
251 ("attempt to seek past end of sbuf (%d >= %d)", pos, s->s_size));
252
253 if (pos < 0 || pos > s->s_len)
254 return (-1);
255 s->s_len = pos;
256 return (0);
257 }
258
259 /*
260 * Append a byte string to an sbuf.
261 */
262 int
263 sbuf_bcat(struct sbuf *s, const char *str, size_t len)
264 {
265 assert_sbuf_integrity(s);
266 assert_sbuf_state(s, 0);
267
268 if (SBUF_HASOVERFLOWED(s))
269 return (-1);
270
271 for (; len; len--) {
272 if (!SBUF_HASROOM(s) && sbuf_extend(s, len) < 0)
273 break;
274 s->s_buf[s->s_len++] = *str++;
275 }
276 if (len) {
277 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
278 return (-1);
279 }
280 return (0);
281 }
282
283 #ifdef _KERNEL
284 /*
285 * Copy a byte string from userland into an sbuf.
286 */
287 int
288 sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len)
289 {
290 assert_sbuf_integrity(s);
291 assert_sbuf_state(s, 0);
292
293 if (SBUF_HASOVERFLOWED(s))
294 return (-1);
295
296 if (len == 0)
297 return (0);
298 if (len > SBUF_FREESPACE(s)) {
299 sbuf_extend(s, len - SBUF_FREESPACE(s));
300 len = min(len, SBUF_FREESPACE(s));
301 }
302 if (copyin(uaddr, s->s_buf + s->s_len, len) != 0)
303 return (-1);
304 s->s_len += len;
305
306 return (0);
307 }
308 #endif
309
310 /*
311 * Copy a byte string into an sbuf.
312 */
313 int
314 sbuf_bcpy(struct sbuf *s, const char *str, size_t len)
315 {
316 assert_sbuf_integrity(s);
317 assert_sbuf_state(s, 0);
318
319 sbuf_clear(s);
320 return (sbuf_bcat(s, str, len));
321 }
322
323 /*
324 * Append a string to an sbuf.
325 */
326 int
327 sbuf_cat(struct sbuf *s, const char *str)
328 {
329 assert_sbuf_integrity(s);
330 assert_sbuf_state(s, 0);
331
332 if (SBUF_HASOVERFLOWED(s))
333 return (-1);
334
335 while (*str) {
336 if (!SBUF_HASROOM(s) && sbuf_extend(s, strlen(str)) < 0)
337 break;
338 s->s_buf[s->s_len++] = *str++;
339 }
340 if (*str) {
341 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
342 return (-1);
343 }
344 return (0);
345 }
346
347 #ifdef _KERNEL
348 /*
349 * Append a string from userland to an sbuf.
350 */
351 int
352 sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len)
353 {
354 size_t done;
355
356 assert_sbuf_integrity(s);
357 assert_sbuf_state(s, 0);
358
359 if (SBUF_HASOVERFLOWED(s))
360 return (-1);
361
362 if (len == 0)
363 len = SBUF_FREESPACE(s); /* XXX return 0? */
364 if (len > SBUF_FREESPACE(s)) {
365 sbuf_extend(s, len);
366 len = min(len, SBUF_FREESPACE(s));
367 }
368 switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) {
369 case ENAMETOOLONG:
370 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
371 /* fall through */
372 case 0:
373 s->s_len += done - 1;
374 break;
375 default:
376 return (-1); /* XXX */
377 }
378
379 return (0);
380 }
381 #endif
382
383 /*
384 * Copy a string into an sbuf.
385 */
386 int
387 sbuf_cpy(struct sbuf *s, const char *str)
388 {
389 assert_sbuf_integrity(s);
390 assert_sbuf_state(s, 0);
391
392 sbuf_clear(s);
393 return (sbuf_cat(s, str));
394 }
395
396 /*
397 * Format the given argument list and append the resulting string to an sbuf.
398 */
399 int
400 sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap)
401 {
402 int len;
403
404 assert_sbuf_integrity(s);
405 assert_sbuf_state(s, 0);
406
407 KASSERT(fmt != NULL,
408 ("%s called with a NULL format string", __FUNCTION__));
409
410 if (SBUF_HASOVERFLOWED(s))
411 return (-1);
412
413 do {
414 len = vsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1,
415 fmt, ap);
416 } while (len > SBUF_FREESPACE(s) &&
417 sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0);
418
419 /*
420 * s->s_len is the length of the string, without the terminating nul.
421 * When updating s->s_len, we must subtract 1 from the length that
422 * we passed into vsnprintf() because that length includes the
423 * terminating nul.
424 *
425 * vsnprintf() returns the amount that would have been copied,
426 * given sufficient space, hence the min() calculation below.
427 */
428 s->s_len += min(len, SBUF_FREESPACE(s));
429 if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s))
430 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
431
432 KASSERT(s->s_len < s->s_size,
433 ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
434
435 if (SBUF_HASOVERFLOWED(s))
436 return (-1);
437 return (0);
438 }
439
440 /*
441 * Format the given arguments and append the resulting string to an sbuf.
442 */
443 int
444 sbuf_printf(struct sbuf *s, const char *fmt, ...)
445 {
446 va_list ap;
447 int result;
448
449 va_start(ap, fmt);
450 result = sbuf_vprintf(s, fmt, ap);
451 va_end(ap);
452 return(result);
453 }
454
455 /*
456 * Append a character to an sbuf.
457 */
458 int
459 sbuf_putc(struct sbuf *s, int c)
460 {
461 assert_sbuf_integrity(s);
462 assert_sbuf_state(s, 0);
463
464 if (SBUF_HASOVERFLOWED(s))
465 return (-1);
466
467 if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) {
468 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
469 return (-1);
470 }
471 if (c != '\0')
472 s->s_buf[s->s_len++] = c;
473 return (0);
474 }
475
476 /*
477 * Trim whitespace characters from end of an sbuf.
478 */
479 int
480 sbuf_trim(struct sbuf *s)
481 {
482 assert_sbuf_integrity(s);
483 assert_sbuf_state(s, 0);
484
485 if (SBUF_HASOVERFLOWED(s))
486 return (-1);
487
488 while (s->s_len && isspace(s->s_buf[s->s_len-1]))
489 --s->s_len;
490
491 return (0);
492 }
493
494 /*
495 * Check if an sbuf overflowed
496 */
497 int
498 sbuf_overflowed(struct sbuf *s)
499 {
500 return SBUF_HASOVERFLOWED(s);
501 }
502
503 /*
504 * Finish off an sbuf.
505 */
506 void
507 sbuf_finish(struct sbuf *s)
508 {
509 assert_sbuf_integrity(s);
510 assert_sbuf_state(s, 0);
511
512 s->s_buf[s->s_len] = '\0';
513 SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
514 SBUF_SETFLAG(s, SBUF_FINISHED);
515 }
516
517 /*
518 * Return a pointer to the sbuf data.
519 */
520 char *
521 sbuf_data(struct sbuf *s)
522 {
523 assert_sbuf_integrity(s);
524 assert_sbuf_state(s, SBUF_FINISHED);
525
526 return s->s_buf;
527 }
528
529 /*
530 * Return the length of the sbuf data.
531 */
532 int
533 sbuf_len(struct sbuf *s)
534 {
535 assert_sbuf_integrity(s);
536 /* don't care if it's finished or not */
537
538 if (SBUF_HASOVERFLOWED(s))
539 return (-1);
540 return s->s_len;
541 }
542
543 /*
544 * Clear an sbuf, free its buffer if necessary.
545 */
546 void
547 sbuf_delete(struct sbuf *s)
548 {
549 int isdyn;
550
551 assert_sbuf_integrity(s);
552 /* don't care if it's finished or not */
553
554 if (SBUF_ISDYNAMIC(s))
555 SBFREE(s->s_buf);
556 isdyn = SBUF_ISDYNSTRUCT(s);
557 bzero(s, sizeof *s);
558 if (isdyn)
559 SBFREE(s);
560 }
Cache object: 2da43a50570da497c9869f2df38e2ae8
|