160ec4130SDag-Erling Smørgrav /*- 2546d7890SDag-Erling Smørgrav * Copyright (c) 2000-2008 Poul-Henning Kamp 3546d7890SDag-Erling Smørgrav * Copyright (c) 2000-2008 Dag-Erling Coïdan Smørgrav 460ec4130SDag-Erling Smørgrav * All rights reserved. 560ec4130SDag-Erling Smørgrav * 660ec4130SDag-Erling Smørgrav * Redistribution and use in source and binary forms, with or without 760ec4130SDag-Erling Smørgrav * modification, are permitted provided that the following conditions 860ec4130SDag-Erling Smørgrav * are met: 960ec4130SDag-Erling Smørgrav * 1. Redistributions of source code must retain the above copyright 1060ec4130SDag-Erling Smørgrav * notice, this list of conditions and the following disclaimer 1160ec4130SDag-Erling Smørgrav * in this position and unchanged. 1260ec4130SDag-Erling Smørgrav * 2. Redistributions in binary form must reproduce the above copyright 1360ec4130SDag-Erling Smørgrav * notice, this list of conditions and the following disclaimer in the 1460ec4130SDag-Erling Smørgrav * documentation and/or other materials provided with the distribution. 1560ec4130SDag-Erling Smørgrav * 16546d7890SDag-Erling Smørgrav * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17546d7890SDag-Erling Smørgrav * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18546d7890SDag-Erling Smørgrav * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19546d7890SDag-Erling Smørgrav * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20546d7890SDag-Erling Smørgrav * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21546d7890SDag-Erling Smørgrav * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22546d7890SDag-Erling Smørgrav * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23546d7890SDag-Erling Smørgrav * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24546d7890SDag-Erling Smørgrav * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25546d7890SDag-Erling Smørgrav * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26546d7890SDag-Erling Smørgrav * SUCH DAMAGE. 2760ec4130SDag-Erling Smørgrav */ 2860ec4130SDag-Erling Smørgrav 29677b542eSDavid E. O'Brien #include <sys/cdefs.h> 30677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$"); 31677b542eSDavid E. O'Brien 3260ec4130SDag-Erling Smørgrav #include <sys/param.h> 333393f8daSKenneth D. Merry 343393f8daSKenneth D. Merry #ifdef _KERNEL 355b6db477SDag-Erling Smørgrav #include <sys/ctype.h> 3660ec4130SDag-Erling Smørgrav #include <sys/kernel.h> 3760ec4130SDag-Erling Smørgrav #include <sys/malloc.h> 3860ec4130SDag-Erling Smørgrav #include <sys/systm.h> 395b6db477SDag-Erling Smørgrav #include <sys/uio.h> 4060ec4130SDag-Erling Smørgrav #include <machine/stdarg.h> 413393f8daSKenneth D. Merry #else /* _KERNEL */ 425b6db477SDag-Erling Smørgrav #include <ctype.h> 433393f8daSKenneth D. Merry #include <stdarg.h> 447195eb40SKelly Yancey #include <stdio.h> 459fa416caSJonathan Lemon #include <stdlib.h> 467195eb40SKelly Yancey #include <string.h> 473393f8daSKenneth D. Merry #endif /* _KERNEL */ 4860ec4130SDag-Erling Smørgrav 495b6db477SDag-Erling Smørgrav #include <sys/sbuf.h> 505b6db477SDag-Erling Smørgrav 513393f8daSKenneth D. Merry #ifdef _KERNEL 52c711aea6SPoul-Henning Kamp static MALLOC_DEFINE(M_SBUF, "sbuf", "string buffers"); 53a163d034SWarner Losh #define SBMALLOC(size) malloc(size, M_SBUF, M_WAITOK) 543393f8daSKenneth D. Merry #define SBFREE(buf) free(buf, M_SBUF) 553393f8daSKenneth D. Merry #else /* _KERNEL */ 563393f8daSKenneth D. Merry #define KASSERT(e, m) 573393f8daSKenneth D. Merry #define SBMALLOC(size) malloc(size) 583393f8daSKenneth D. Merry #define SBFREE(buf) free(buf) 593393f8daSKenneth D. Merry #define min(x,y) MIN(x,y) 603393f8daSKenneth D. Merry #endif /* _KERNEL */ 6160ec4130SDag-Erling Smørgrav 624dc14139SDag-Erling Smørgrav /* 634dc14139SDag-Erling Smørgrav * Predicates 644dc14139SDag-Erling Smørgrav */ 654dc14139SDag-Erling Smørgrav #define SBUF_ISDYNAMIC(s) ((s)->s_flags & SBUF_DYNAMIC) 66d6479358SDag-Erling Smørgrav #define SBUF_ISDYNSTRUCT(s) ((s)->s_flags & SBUF_DYNSTRUCT) 674dc14139SDag-Erling Smørgrav #define SBUF_ISFINISHED(s) ((s)->s_flags & SBUF_FINISHED) 684dc14139SDag-Erling Smørgrav #define SBUF_HASOVERFLOWED(s) ((s)->s_flags & SBUF_OVERFLOWED) 694dc14139SDag-Erling Smørgrav #define SBUF_HASROOM(s) ((s)->s_len < (s)->s_size - 1) 707195eb40SKelly Yancey #define SBUF_FREESPACE(s) ((s)->s_size - (s)->s_len - 1) 717195eb40SKelly Yancey #define SBUF_CANEXTEND(s) ((s)->s_flags & SBUF_AUTOEXTEND) 724dc14139SDag-Erling Smørgrav 734dc14139SDag-Erling Smørgrav /* 744dc14139SDag-Erling Smørgrav * Set / clear flags 754dc14139SDag-Erling Smørgrav */ 764dc14139SDag-Erling Smørgrav #define SBUF_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) 774dc14139SDag-Erling Smørgrav #define SBUF_CLEARFLAG(s, f) do { (s)->s_flags &= ~(f); } while (0) 784dc14139SDag-Erling Smørgrav 797195eb40SKelly Yancey #define SBUF_MINEXTENDSIZE 16 /* Should be power of 2. */ 807195eb40SKelly Yancey #define SBUF_MAXEXTENDSIZE PAGE_SIZE 817195eb40SKelly Yancey #define SBUF_MAXEXTENDINCR PAGE_SIZE 827195eb40SKelly Yancey 834dc14139SDag-Erling Smørgrav /* 844dc14139SDag-Erling Smørgrav * Debugging support 854dc14139SDag-Erling Smørgrav */ 863393f8daSKenneth D. Merry #if defined(_KERNEL) && defined(INVARIANTS) 87546d7890SDag-Erling Smørgrav 8860ec4130SDag-Erling Smørgrav static void 89a5e7c7daSPeter Wemm _assert_sbuf_integrity(const char *fun, struct sbuf *s) 9060ec4130SDag-Erling Smørgrav { 91546d7890SDag-Erling Smørgrav 9260ec4130SDag-Erling Smørgrav KASSERT(s != NULL, 93cab5b963SDag-Erling Smørgrav ("%s called with a NULL sbuf pointer", fun)); 9460ec4130SDag-Erling Smørgrav KASSERT(s->s_buf != NULL, 957195eb40SKelly Yancey ("%s called with uninitialized or corrupt sbuf", fun)); 9660ec4130SDag-Erling Smørgrav KASSERT(s->s_len < s->s_size, 9760ec4130SDag-Erling Smørgrav ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size)); 9860ec4130SDag-Erling Smørgrav } 9960ec4130SDag-Erling Smørgrav 10060ec4130SDag-Erling Smørgrav static void 101a5e7c7daSPeter Wemm _assert_sbuf_state(const char *fun, struct sbuf *s, int state) 10260ec4130SDag-Erling Smørgrav { 103546d7890SDag-Erling Smørgrav 10460ec4130SDag-Erling Smørgrav KASSERT((s->s_flags & SBUF_FINISHED) == state, 105cab5b963SDag-Erling Smørgrav ("%s called with %sfinished or corrupt sbuf", fun, 10660ec4130SDag-Erling Smørgrav (state ? "un" : ""))); 10760ec4130SDag-Erling Smørgrav } 108546d7890SDag-Erling Smørgrav 109a48740b6SDavid E. O'Brien #define assert_sbuf_integrity(s) _assert_sbuf_integrity(__func__, (s)) 110a48740b6SDavid E. O'Brien #define assert_sbuf_state(s, i) _assert_sbuf_state(__func__, (s), (i)) 111546d7890SDag-Erling Smørgrav 1123393f8daSKenneth D. Merry #else /* _KERNEL && INVARIANTS */ 113546d7890SDag-Erling Smørgrav 11460ec4130SDag-Erling Smørgrav #define assert_sbuf_integrity(s) do { } while (0) 11560ec4130SDag-Erling Smørgrav #define assert_sbuf_state(s, i) do { } while (0) 116546d7890SDag-Erling Smørgrav 1173393f8daSKenneth D. Merry #endif /* _KERNEL && INVARIANTS */ 11860ec4130SDag-Erling Smørgrav 119*969292fbSMatthew D Fleming #ifdef _KERNEL 120f4bafab8SMatthew D Fleming CTASSERT(powerof2(SBUF_MAXEXTENDSIZE)); 121f4bafab8SMatthew D Fleming CTASSERT(powerof2(SBUF_MAXEXTENDINCR)); 122*969292fbSMatthew D Fleming #endif 123f4bafab8SMatthew D Fleming 1247195eb40SKelly Yancey static int 1257195eb40SKelly Yancey sbuf_extendsize(int size) 1267195eb40SKelly Yancey { 1277195eb40SKelly Yancey int newsize; 1287195eb40SKelly Yancey 129f4bafab8SMatthew D Fleming if (size < (int)SBUF_MAXEXTENDSIZE) { 1307195eb40SKelly Yancey newsize = SBUF_MINEXTENDSIZE; 131f4bafab8SMatthew D Fleming while (newsize < size) 1327195eb40SKelly Yancey newsize *= 2; 133f4bafab8SMatthew D Fleming } else { 134f4bafab8SMatthew D Fleming newsize = roundup2(size, SBUF_MAXEXTENDINCR); 1357195eb40SKelly Yancey } 136f5a5dc5dSMatthew D Fleming KASSERT(newsize >= size, ("%s: %d < %d\n", __func__, newsize, size)); 1377195eb40SKelly Yancey return (newsize); 1387195eb40SKelly Yancey } 1397195eb40SKelly Yancey 1407195eb40SKelly Yancey 1417195eb40SKelly Yancey /* 1427195eb40SKelly Yancey * Extend an sbuf. 1437195eb40SKelly Yancey */ 1447195eb40SKelly Yancey static int 1457195eb40SKelly Yancey sbuf_extend(struct sbuf *s, int addlen) 1467195eb40SKelly Yancey { 1477195eb40SKelly Yancey char *newbuf; 1487195eb40SKelly Yancey int newsize; 1497195eb40SKelly Yancey 1507195eb40SKelly Yancey if (!SBUF_CANEXTEND(s)) 1517195eb40SKelly Yancey return (-1); 1527195eb40SKelly Yancey newsize = sbuf_extendsize(s->s_size + addlen); 153546d7890SDag-Erling Smørgrav newbuf = SBMALLOC(newsize); 1547195eb40SKelly Yancey if (newbuf == NULL) 1557195eb40SKelly Yancey return (-1); 1567195eb40SKelly Yancey bcopy(s->s_buf, newbuf, s->s_size); 1577195eb40SKelly Yancey if (SBUF_ISDYNAMIC(s)) 1587195eb40SKelly Yancey SBFREE(s->s_buf); 1597195eb40SKelly Yancey else 1607195eb40SKelly Yancey SBUF_SETFLAG(s, SBUF_DYNAMIC); 1617195eb40SKelly Yancey s->s_buf = newbuf; 1627195eb40SKelly Yancey s->s_size = newsize; 1637195eb40SKelly Yancey return (0); 1647195eb40SKelly Yancey } 1657195eb40SKelly Yancey 16660ec4130SDag-Erling Smørgrav /* 16760ec4130SDag-Erling Smørgrav * Initialize an sbuf. 16860ec4130SDag-Erling Smørgrav * If buf is non-NULL, it points to a static or already-allocated string 16960ec4130SDag-Erling Smørgrav * big enough to hold at least length characters. 17060ec4130SDag-Erling Smørgrav */ 171d6479358SDag-Erling Smørgrav struct sbuf * 1724dc14139SDag-Erling Smørgrav sbuf_new(struct sbuf *s, char *buf, int length, int flags) 17360ec4130SDag-Erling Smørgrav { 174546d7890SDag-Erling Smørgrav 1754dc14139SDag-Erling Smørgrav KASSERT(length >= 0, 1764dc14139SDag-Erling Smørgrav ("attempt to create an sbuf of negative length (%d)", length)); 1777195eb40SKelly Yancey KASSERT((flags & ~SBUF_USRFLAGMSK) == 0, 1787195eb40SKelly Yancey ("%s called with invalid flags", __func__)); 17960ec4130SDag-Erling Smørgrav 1807195eb40SKelly Yancey flags &= SBUF_USRFLAGMSK; 181d6479358SDag-Erling Smørgrav if (s == NULL) { 182546d7890SDag-Erling Smørgrav s = SBMALLOC(sizeof(*s)); 183d6479358SDag-Erling Smørgrav if (s == NULL) 184d6479358SDag-Erling Smørgrav return (NULL); 185546d7890SDag-Erling Smørgrav bzero(s, sizeof(*s)); 1867195eb40SKelly Yancey s->s_flags = flags; 187d6479358SDag-Erling Smørgrav SBUF_SETFLAG(s, SBUF_DYNSTRUCT); 188d6479358SDag-Erling Smørgrav } else { 189546d7890SDag-Erling Smørgrav bzero(s, sizeof(*s)); 1907195eb40SKelly Yancey s->s_flags = flags; 191d6479358SDag-Erling Smørgrav } 19260ec4130SDag-Erling Smørgrav s->s_size = length; 19360ec4130SDag-Erling Smørgrav if (buf) { 19460ec4130SDag-Erling Smørgrav s->s_buf = buf; 195d6479358SDag-Erling Smørgrav return (s); 19660ec4130SDag-Erling Smørgrav } 1977195eb40SKelly Yancey if (flags & SBUF_AUTOEXTEND) 1987195eb40SKelly Yancey s->s_size = sbuf_extendsize(s->s_size); 199546d7890SDag-Erling Smørgrav s->s_buf = SBMALLOC(s->s_size); 200d6479358SDag-Erling Smørgrav if (s->s_buf == NULL) { 201d6479358SDag-Erling Smørgrav if (SBUF_ISDYNSTRUCT(s)) 202d6479358SDag-Erling Smørgrav SBFREE(s); 203d6479358SDag-Erling Smørgrav return (NULL); 204d6479358SDag-Erling Smørgrav } 20560ec4130SDag-Erling Smørgrav SBUF_SETFLAG(s, SBUF_DYNAMIC); 206d6479358SDag-Erling Smørgrav return (s); 20760ec4130SDag-Erling Smørgrav } 20860ec4130SDag-Erling Smørgrav 2095b6db477SDag-Erling Smørgrav #ifdef _KERNEL 2105b6db477SDag-Erling Smørgrav /* 2115b6db477SDag-Erling Smørgrav * Create an sbuf with uio data 2125b6db477SDag-Erling Smørgrav */ 2135b6db477SDag-Erling Smørgrav struct sbuf * 2145b6db477SDag-Erling Smørgrav sbuf_uionew(struct sbuf *s, struct uio *uio, int *error) 2155b6db477SDag-Erling Smørgrav { 216546d7890SDag-Erling Smørgrav 2175b6db477SDag-Erling Smørgrav KASSERT(uio != NULL, 218a48740b6SDavid E. O'Brien ("%s called with NULL uio pointer", __func__)); 2195b6db477SDag-Erling Smørgrav KASSERT(error != NULL, 220a48740b6SDavid E. O'Brien ("%s called with NULL error pointer", __func__)); 2215b6db477SDag-Erling Smørgrav 2225b6db477SDag-Erling Smørgrav s = sbuf_new(s, NULL, uio->uio_resid + 1, 0); 2235b6db477SDag-Erling Smørgrav if (s == NULL) { 2245b6db477SDag-Erling Smørgrav *error = ENOMEM; 2255b6db477SDag-Erling Smørgrav return (NULL); 2265b6db477SDag-Erling Smørgrav } 2275b6db477SDag-Erling Smørgrav *error = uiomove(s->s_buf, uio->uio_resid, uio); 2285b6db477SDag-Erling Smørgrav if (*error != 0) { 2295b6db477SDag-Erling Smørgrav sbuf_delete(s); 2305b6db477SDag-Erling Smørgrav return (NULL); 2315b6db477SDag-Erling Smørgrav } 2325b6db477SDag-Erling Smørgrav s->s_len = s->s_size - 1; 2335b6db477SDag-Erling Smørgrav *error = 0; 2345b6db477SDag-Erling Smørgrav return (s); 2355b6db477SDag-Erling Smørgrav } 2365b6db477SDag-Erling Smørgrav #endif 2375b6db477SDag-Erling Smørgrav 23860ec4130SDag-Erling Smørgrav /* 2397195eb40SKelly Yancey * Clear an sbuf and reset its position. 2404dc14139SDag-Erling Smørgrav */ 2414dc14139SDag-Erling Smørgrav void 2424dc14139SDag-Erling Smørgrav sbuf_clear(struct sbuf *s) 2434dc14139SDag-Erling Smørgrav { 244546d7890SDag-Erling Smørgrav 2454dc14139SDag-Erling Smørgrav assert_sbuf_integrity(s); 2469fa2ef3dSDag-Erling Smørgrav /* don't care if it's finished or not */ 2474dc14139SDag-Erling Smørgrav 2484dc14139SDag-Erling Smørgrav SBUF_CLEARFLAG(s, SBUF_FINISHED); 2494dc14139SDag-Erling Smørgrav SBUF_CLEARFLAG(s, SBUF_OVERFLOWED); 2504dc14139SDag-Erling Smørgrav s->s_len = 0; 2514dc14139SDag-Erling Smørgrav } 2524dc14139SDag-Erling Smørgrav 2534dc14139SDag-Erling Smørgrav /* 2547195eb40SKelly Yancey * Set the sbuf's end position to an arbitrary value. 2557195eb40SKelly Yancey * Effectively truncates the sbuf at the new position. 25660ec4130SDag-Erling Smørgrav */ 25760ec4130SDag-Erling Smørgrav int 2584dc14139SDag-Erling Smørgrav sbuf_setpos(struct sbuf *s, int pos) 25960ec4130SDag-Erling Smørgrav { 260546d7890SDag-Erling Smørgrav 26160ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 26260ec4130SDag-Erling Smørgrav assert_sbuf_state(s, 0); 26360ec4130SDag-Erling Smørgrav 26460ec4130SDag-Erling Smørgrav KASSERT(pos >= 0, 26560ec4130SDag-Erling Smørgrav ("attempt to seek to a negative position (%d)", pos)); 26660ec4130SDag-Erling Smørgrav KASSERT(pos < s->s_size, 26760ec4130SDag-Erling Smørgrav ("attempt to seek past end of sbuf (%d >= %d)", pos, s->s_size)); 26860ec4130SDag-Erling Smørgrav 26960ec4130SDag-Erling Smørgrav if (pos < 0 || pos > s->s_len) 27060ec4130SDag-Erling Smørgrav return (-1); 27160ec4130SDag-Erling Smørgrav s->s_len = pos; 27260ec4130SDag-Erling Smørgrav return (0); 27360ec4130SDag-Erling Smørgrav } 27460ec4130SDag-Erling Smørgrav 27560ec4130SDag-Erling Smørgrav /* 276b0def2b5SDag-Erling Smørgrav * Append a byte string to an sbuf. 277b0def2b5SDag-Erling Smørgrav */ 278b0def2b5SDag-Erling Smørgrav int 279520df276SDag-Erling Smørgrav sbuf_bcat(struct sbuf *s, const void *buf, size_t len) 280b0def2b5SDag-Erling Smørgrav { 281520df276SDag-Erling Smørgrav const char *str = buf; 282d751f0a9SDag-Erling Smørgrav 283b0def2b5SDag-Erling Smørgrav assert_sbuf_integrity(s); 284b0def2b5SDag-Erling Smørgrav assert_sbuf_state(s, 0); 285b0def2b5SDag-Erling Smørgrav 286b0def2b5SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 287b0def2b5SDag-Erling Smørgrav return (-1); 2889118ec5aSPoul-Henning Kamp for (; len; len--) { 2897195eb40SKelly Yancey if (!SBUF_HASROOM(s) && sbuf_extend(s, len) < 0) 2907195eb40SKelly Yancey break; 291b0def2b5SDag-Erling Smørgrav s->s_buf[s->s_len++] = *str++; 2927195eb40SKelly Yancey } 293b0def2b5SDag-Erling Smørgrav if (len) { 294b0def2b5SDag-Erling Smørgrav SBUF_SETFLAG(s, SBUF_OVERFLOWED); 295b0def2b5SDag-Erling Smørgrav return (-1); 296b0def2b5SDag-Erling Smørgrav } 297b0def2b5SDag-Erling Smørgrav return (0); 298b0def2b5SDag-Erling Smørgrav } 299b0def2b5SDag-Erling Smørgrav 300b0def2b5SDag-Erling Smørgrav #ifdef _KERNEL 301b0def2b5SDag-Erling Smørgrav /* 302b0def2b5SDag-Erling Smørgrav * Copy a byte string from userland into an sbuf. 303b0def2b5SDag-Erling Smørgrav */ 304b0def2b5SDag-Erling Smørgrav int 305b0def2b5SDag-Erling Smørgrav sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len) 306b0def2b5SDag-Erling Smørgrav { 307546d7890SDag-Erling Smørgrav 308b0def2b5SDag-Erling Smørgrav assert_sbuf_integrity(s); 309b0def2b5SDag-Erling Smørgrav assert_sbuf_state(s, 0); 310b0def2b5SDag-Erling Smørgrav 311b0def2b5SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 312b0def2b5SDag-Erling Smørgrav return (-1); 313b0def2b5SDag-Erling Smørgrav if (len == 0) 314b0def2b5SDag-Erling Smørgrav return (0); 3157195eb40SKelly Yancey if (len > SBUF_FREESPACE(s)) { 3167195eb40SKelly Yancey sbuf_extend(s, len - SBUF_FREESPACE(s)); 3177195eb40SKelly Yancey len = min(len, SBUF_FREESPACE(s)); 3187195eb40SKelly Yancey } 319e3b37322SDag-Erling Smørgrav if (copyin(uaddr, s->s_buf + s->s_len, len) != 0) 320e3b37322SDag-Erling Smørgrav return (-1); 321fe463496SDag-Erling Smørgrav s->s_len += len; 322b0def2b5SDag-Erling Smørgrav 323b0def2b5SDag-Erling Smørgrav return (0); 324b0def2b5SDag-Erling Smørgrav } 325b0def2b5SDag-Erling Smørgrav #endif 326b0def2b5SDag-Erling Smørgrav 327b0def2b5SDag-Erling Smørgrav /* 328b0def2b5SDag-Erling Smørgrav * Copy a byte string into an sbuf. 329b0def2b5SDag-Erling Smørgrav */ 330b0def2b5SDag-Erling Smørgrav int 331520df276SDag-Erling Smørgrav sbuf_bcpy(struct sbuf *s, const void *buf, size_t len) 332b0def2b5SDag-Erling Smørgrav { 333546d7890SDag-Erling Smørgrav 334b0def2b5SDag-Erling Smørgrav assert_sbuf_integrity(s); 335b0def2b5SDag-Erling Smørgrav assert_sbuf_state(s, 0); 336b0def2b5SDag-Erling Smørgrav 337b0def2b5SDag-Erling Smørgrav sbuf_clear(s); 338520df276SDag-Erling Smørgrav return (sbuf_bcat(s, buf, len)); 339b0def2b5SDag-Erling Smørgrav } 340b0def2b5SDag-Erling Smørgrav 341b0def2b5SDag-Erling Smørgrav /* 34260ec4130SDag-Erling Smørgrav * Append a string to an sbuf. 34360ec4130SDag-Erling Smørgrav */ 34460ec4130SDag-Erling Smørgrav int 3453393f8daSKenneth D. Merry sbuf_cat(struct sbuf *s, const char *str) 34660ec4130SDag-Erling Smørgrav { 347546d7890SDag-Erling Smørgrav 34860ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 34960ec4130SDag-Erling Smørgrav assert_sbuf_state(s, 0); 35060ec4130SDag-Erling Smørgrav 35160ec4130SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 35260ec4130SDag-Erling Smørgrav return (-1); 35360ec4130SDag-Erling Smørgrav 3547195eb40SKelly Yancey while (*str) { 3557195eb40SKelly Yancey if (!SBUF_HASROOM(s) && sbuf_extend(s, strlen(str)) < 0) 3567195eb40SKelly Yancey break; 35760ec4130SDag-Erling Smørgrav s->s_buf[s->s_len++] = *str++; 3587195eb40SKelly Yancey } 35960ec4130SDag-Erling Smørgrav if (*str) { 36060ec4130SDag-Erling Smørgrav SBUF_SETFLAG(s, SBUF_OVERFLOWED); 36160ec4130SDag-Erling Smørgrav return (-1); 36260ec4130SDag-Erling Smørgrav } 36360ec4130SDag-Erling Smørgrav return (0); 36460ec4130SDag-Erling Smørgrav } 36560ec4130SDag-Erling Smørgrav 366b0def2b5SDag-Erling Smørgrav #ifdef _KERNEL 367b0def2b5SDag-Erling Smørgrav /* 3687195eb40SKelly Yancey * Append a string from userland to an sbuf. 369b0def2b5SDag-Erling Smørgrav */ 370b0def2b5SDag-Erling Smørgrav int 371b0def2b5SDag-Erling Smørgrav sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len) 372b0def2b5SDag-Erling Smørgrav { 373b0def2b5SDag-Erling Smørgrav size_t done; 374b0def2b5SDag-Erling Smørgrav 375b0def2b5SDag-Erling Smørgrav assert_sbuf_integrity(s); 376b0def2b5SDag-Erling Smørgrav assert_sbuf_state(s, 0); 377b0def2b5SDag-Erling Smørgrav 378b0def2b5SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 379b0def2b5SDag-Erling Smørgrav return (-1); 380b0def2b5SDag-Erling Smørgrav 3817195eb40SKelly Yancey if (len == 0) 3827195eb40SKelly Yancey len = SBUF_FREESPACE(s); /* XXX return 0? */ 3837195eb40SKelly Yancey if (len > SBUF_FREESPACE(s)) { 3847195eb40SKelly Yancey sbuf_extend(s, len); 3857195eb40SKelly Yancey len = min(len, SBUF_FREESPACE(s)); 3867195eb40SKelly Yancey } 387b0def2b5SDag-Erling Smørgrav switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) { 388b0def2b5SDag-Erling Smørgrav case ENAMETOOLONG: 389b0def2b5SDag-Erling Smørgrav SBUF_SETFLAG(s, SBUF_OVERFLOWED); 390b0def2b5SDag-Erling Smørgrav /* fall through */ 391b0def2b5SDag-Erling Smørgrav case 0: 392b0def2b5SDag-Erling Smørgrav s->s_len += done - 1; 393b0def2b5SDag-Erling Smørgrav break; 394b0def2b5SDag-Erling Smørgrav default: 395b0def2b5SDag-Erling Smørgrav return (-1); /* XXX */ 396b0def2b5SDag-Erling Smørgrav } 397b0def2b5SDag-Erling Smørgrav 39849091c48SPoul-Henning Kamp return (done); 399b0def2b5SDag-Erling Smørgrav } 400b0def2b5SDag-Erling Smørgrav #endif 401b0def2b5SDag-Erling Smørgrav 40260ec4130SDag-Erling Smørgrav /* 40360ec4130SDag-Erling Smørgrav * Copy a string into an sbuf. 40460ec4130SDag-Erling Smørgrav */ 40560ec4130SDag-Erling Smørgrav int 4063393f8daSKenneth D. Merry sbuf_cpy(struct sbuf *s, const char *str) 40760ec4130SDag-Erling Smørgrav { 408546d7890SDag-Erling Smørgrav 40960ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 41060ec4130SDag-Erling Smørgrav assert_sbuf_state(s, 0); 41160ec4130SDag-Erling Smørgrav 4124dc14139SDag-Erling Smørgrav sbuf_clear(s); 41360ec4130SDag-Erling Smørgrav return (sbuf_cat(s, str)); 41460ec4130SDag-Erling Smørgrav } 41560ec4130SDag-Erling Smørgrav 41660ec4130SDag-Erling Smørgrav /* 4177195eb40SKelly Yancey * Format the given argument list and append the resulting string to an sbuf. 41860ec4130SDag-Erling Smørgrav */ 41960ec4130SDag-Erling Smørgrav int 4207195eb40SKelly Yancey sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap) 42160ec4130SDag-Erling Smørgrav { 422a9a0bbadSPeter Wemm va_list ap_copy; 4234dc14139SDag-Erling Smørgrav int len; 42460ec4130SDag-Erling Smørgrav 42560ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 42660ec4130SDag-Erling Smørgrav assert_sbuf_state(s, 0); 42760ec4130SDag-Erling Smørgrav 42860ec4130SDag-Erling Smørgrav KASSERT(fmt != NULL, 429a48740b6SDavid E. O'Brien ("%s called with a NULL format string", __func__)); 43060ec4130SDag-Erling Smørgrav 43160ec4130SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 43260ec4130SDag-Erling Smørgrav return (-1); 43360ec4130SDag-Erling Smørgrav 4347195eb40SKelly Yancey do { 435a9a0bbadSPeter Wemm va_copy(ap_copy, ap); 4367195eb40SKelly Yancey len = vsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1, 437a9a0bbadSPeter Wemm fmt, ap_copy); 438a9a0bbadSPeter Wemm va_end(ap_copy); 4397195eb40SKelly Yancey } while (len > SBUF_FREESPACE(s) && 4407195eb40SKelly Yancey sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0); 44160ec4130SDag-Erling Smørgrav 4423393f8daSKenneth D. Merry /* 4433393f8daSKenneth D. Merry * s->s_len is the length of the string, without the terminating nul. 4443393f8daSKenneth D. Merry * When updating s->s_len, we must subtract 1 from the length that 4453393f8daSKenneth D. Merry * we passed into vsnprintf() because that length includes the 4463393f8daSKenneth D. Merry * terminating nul. 4473393f8daSKenneth D. Merry * 4483393f8daSKenneth D. Merry * vsnprintf() returns the amount that would have been copied, 4493393f8daSKenneth D. Merry * given sufficient space, hence the min() calculation below. 4503393f8daSKenneth D. Merry */ 4517195eb40SKelly Yancey s->s_len += min(len, SBUF_FREESPACE(s)); 4521a25c86bSPoul-Henning Kamp if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s)) 4533393f8daSKenneth D. Merry SBUF_SETFLAG(s, SBUF_OVERFLOWED); 4543393f8daSKenneth D. Merry 45560ec4130SDag-Erling Smørgrav KASSERT(s->s_len < s->s_size, 45660ec4130SDag-Erling Smørgrav ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size)); 45760ec4130SDag-Erling Smørgrav 45860ec4130SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 45960ec4130SDag-Erling Smørgrav return (-1); 46060ec4130SDag-Erling Smørgrav return (0); 46160ec4130SDag-Erling Smørgrav } 46260ec4130SDag-Erling Smørgrav 46360ec4130SDag-Erling Smørgrav /* 4647195eb40SKelly Yancey * Format the given arguments and append the resulting string to an sbuf. 4657195eb40SKelly Yancey */ 4667195eb40SKelly Yancey int 4677195eb40SKelly Yancey sbuf_printf(struct sbuf *s, const char *fmt, ...) 4687195eb40SKelly Yancey { 4697195eb40SKelly Yancey va_list ap; 4707195eb40SKelly Yancey int result; 4717195eb40SKelly Yancey 4727195eb40SKelly Yancey va_start(ap, fmt); 4737195eb40SKelly Yancey result = sbuf_vprintf(s, fmt, ap); 4747195eb40SKelly Yancey va_end(ap); 4757195eb40SKelly Yancey return (result); 4767195eb40SKelly Yancey } 4777195eb40SKelly Yancey 4787195eb40SKelly Yancey /* 47960ec4130SDag-Erling Smørgrav * Append a character to an sbuf. 48060ec4130SDag-Erling Smørgrav */ 48160ec4130SDag-Erling Smørgrav int 48260ec4130SDag-Erling Smørgrav sbuf_putc(struct sbuf *s, int c) 48360ec4130SDag-Erling Smørgrav { 484546d7890SDag-Erling Smørgrav 48560ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 48660ec4130SDag-Erling Smørgrav assert_sbuf_state(s, 0); 48760ec4130SDag-Erling Smørgrav 48860ec4130SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 48960ec4130SDag-Erling Smørgrav return (-1); 4907195eb40SKelly Yancey if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) { 49160ec4130SDag-Erling Smørgrav SBUF_SETFLAG(s, SBUF_OVERFLOWED); 49260ec4130SDag-Erling Smørgrav return (-1); 49360ec4130SDag-Erling Smørgrav } 494cab5b963SDag-Erling Smørgrav if (c != '\0') 49560ec4130SDag-Erling Smørgrav s->s_buf[s->s_len++] = c; 49660ec4130SDag-Erling Smørgrav return (0); 49760ec4130SDag-Erling Smørgrav } 49860ec4130SDag-Erling Smørgrav 49960ec4130SDag-Erling Smørgrav /* 5007195eb40SKelly Yancey * Trim whitespace characters from end of an sbuf. 5015b6db477SDag-Erling Smørgrav */ 5025b6db477SDag-Erling Smørgrav int 5035b6db477SDag-Erling Smørgrav sbuf_trim(struct sbuf *s) 5045b6db477SDag-Erling Smørgrav { 505546d7890SDag-Erling Smørgrav 5065b6db477SDag-Erling Smørgrav assert_sbuf_integrity(s); 5075b6db477SDag-Erling Smørgrav assert_sbuf_state(s, 0); 5085b6db477SDag-Erling Smørgrav 5095b6db477SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 5105b6db477SDag-Erling Smørgrav return (-1); 5115b6db477SDag-Erling Smørgrav 5125b6db477SDag-Erling Smørgrav while (s->s_len && isspace(s->s_buf[s->s_len-1])) 5135b6db477SDag-Erling Smørgrav --s->s_len; 5145b6db477SDag-Erling Smørgrav 5155b6db477SDag-Erling Smørgrav return (0); 5165b6db477SDag-Erling Smørgrav } 5175b6db477SDag-Erling Smørgrav 5185b6db477SDag-Erling Smørgrav /* 5194dc14139SDag-Erling Smørgrav * Check if an sbuf overflowed 52060ec4130SDag-Erling Smørgrav */ 52160ec4130SDag-Erling Smørgrav int 5224dc14139SDag-Erling Smørgrav sbuf_overflowed(struct sbuf *s) 5234dc14139SDag-Erling Smørgrav { 524546d7890SDag-Erling Smørgrav 525546d7890SDag-Erling Smørgrav return (SBUF_HASOVERFLOWED(s)); 5264dc14139SDag-Erling Smørgrav } 5274dc14139SDag-Erling Smørgrav 5284dc14139SDag-Erling Smørgrav /* 5294dc14139SDag-Erling Smørgrav * Finish off an sbuf. 5304dc14139SDag-Erling Smørgrav */ 5314dc14139SDag-Erling Smørgrav void 53260ec4130SDag-Erling Smørgrav sbuf_finish(struct sbuf *s) 53360ec4130SDag-Erling Smørgrav { 534546d7890SDag-Erling Smørgrav 53560ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 53660ec4130SDag-Erling Smørgrav assert_sbuf_state(s, 0); 53760ec4130SDag-Erling Smørgrav 538cab5b963SDag-Erling Smørgrav s->s_buf[s->s_len] = '\0'; 5394dc14139SDag-Erling Smørgrav SBUF_CLEARFLAG(s, SBUF_OVERFLOWED); 54060ec4130SDag-Erling Smørgrav SBUF_SETFLAG(s, SBUF_FINISHED); 54160ec4130SDag-Erling Smørgrav } 54260ec4130SDag-Erling Smørgrav 54360ec4130SDag-Erling Smørgrav /* 54460ec4130SDag-Erling Smørgrav * Return a pointer to the sbuf data. 54560ec4130SDag-Erling Smørgrav */ 54660ec4130SDag-Erling Smørgrav char * 54760ec4130SDag-Erling Smørgrav sbuf_data(struct sbuf *s) 54860ec4130SDag-Erling Smørgrav { 549546d7890SDag-Erling Smørgrav 55060ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 55160ec4130SDag-Erling Smørgrav assert_sbuf_state(s, SBUF_FINISHED); 55260ec4130SDag-Erling Smørgrav 553546d7890SDag-Erling Smørgrav return (s->s_buf); 55460ec4130SDag-Erling Smørgrav } 55560ec4130SDag-Erling Smørgrav 55660ec4130SDag-Erling Smørgrav /* 55760ec4130SDag-Erling Smørgrav * Return the length of the sbuf data. 55860ec4130SDag-Erling Smørgrav */ 5594dc14139SDag-Erling Smørgrav int 56060ec4130SDag-Erling Smørgrav sbuf_len(struct sbuf *s) 56160ec4130SDag-Erling Smørgrav { 562546d7890SDag-Erling Smørgrav 56360ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 5649fa2ef3dSDag-Erling Smørgrav /* don't care if it's finished or not */ 56560ec4130SDag-Erling Smørgrav 56660ec4130SDag-Erling Smørgrav if (SBUF_HASOVERFLOWED(s)) 5674dc14139SDag-Erling Smørgrav return (-1); 568546d7890SDag-Erling Smørgrav return (s->s_len); 56960ec4130SDag-Erling Smørgrav } 57060ec4130SDag-Erling Smørgrav 57160ec4130SDag-Erling Smørgrav /* 57260ec4130SDag-Erling Smørgrav * Clear an sbuf, free its buffer if necessary. 57360ec4130SDag-Erling Smørgrav */ 57460ec4130SDag-Erling Smørgrav void 57560ec4130SDag-Erling Smørgrav sbuf_delete(struct sbuf *s) 57660ec4130SDag-Erling Smørgrav { 577a57094a0SMatthew Dillon int isdyn; 578a57094a0SMatthew Dillon 57960ec4130SDag-Erling Smørgrav assert_sbuf_integrity(s); 58060ec4130SDag-Erling Smørgrav /* don't care if it's finished or not */ 58160ec4130SDag-Erling Smørgrav 58260ec4130SDag-Erling Smørgrav if (SBUF_ISDYNAMIC(s)) 5833393f8daSKenneth D. Merry SBFREE(s->s_buf); 584a57094a0SMatthew Dillon isdyn = SBUF_ISDYNSTRUCT(s); 585546d7890SDag-Erling Smørgrav bzero(s, sizeof(*s)); 586a57094a0SMatthew Dillon if (isdyn) 587d6479358SDag-Erling Smørgrav SBFREE(s); 58860ec4130SDag-Erling Smørgrav } 589c5f9218bSPoul-Henning Kamp 590c5f9218bSPoul-Henning Kamp /* 591c5f9218bSPoul-Henning Kamp * Check if an sbuf has been finished. 592c5f9218bSPoul-Henning Kamp */ 593c5f9218bSPoul-Henning Kamp int 594c5f9218bSPoul-Henning Kamp sbuf_done(struct sbuf *s) 595c5f9218bSPoul-Henning Kamp { 596c5f9218bSPoul-Henning Kamp 597c5f9218bSPoul-Henning Kamp return (SBUF_ISFINISHED(s)); 598c5f9218bSPoul-Henning Kamp } 599