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