subr_sbuf.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 
   29 #include <sys/cdefs.h>
   30 __FBSDID("$FreeBSD: releng/6.1/sys/kern/subr_sbuf.c 158179 2006-04-30 16:44:43Z cvs2svn $");
   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 static 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(const 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(const 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(__func__, (s))
  106 #define assert_sbuf_state(s, i)  _assert_sbuf_state(__func__, (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 < (int)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", __func__));
  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", __func__));
  206         KASSERT(error != NULL,
  207             ("%s called with NULL error pointer", __func__));
  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 void *buf, size_t len)
  265 {
  266         const char *str = buf;
  267 
  268         assert_sbuf_integrity(s);
  269         assert_sbuf_state(s, 0);
  270 
  271         if (SBUF_HASOVERFLOWED(s))
  272                 return (-1);
  273 
  274         for (; len; len--) {
  275                 if (!SBUF_HASROOM(s) && sbuf_extend(s, len) < 0)
  276                         break;
  277                 s->s_buf[s->s_len++] = *str++;
  278         }
  279         if (len) {
  280                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
  281                 return (-1);
  282         }
  283         return (0);
  284 }
  285 
  286 #ifdef _KERNEL
  287 /*
  288  * Copy a byte string from userland into an sbuf.
  289  */
  290 int
  291 sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len)
  292 {
  293         assert_sbuf_integrity(s);
  294         assert_sbuf_state(s, 0);
  295 
  296         if (SBUF_HASOVERFLOWED(s))
  297                 return (-1);
  298 
  299         if (len == 0)
  300                 return (0);
  301         if (len > SBUF_FREESPACE(s)) {
  302                 sbuf_extend(s, len - SBUF_FREESPACE(s));
  303                 len = min(len, SBUF_FREESPACE(s));
  304         }
  305         if (copyin(uaddr, s->s_buf + s->s_len, len) != 0)
  306                 return (-1);
  307         s->s_len += len;
  308 
  309         return (0);
  310 }
  311 #endif
  312 
  313 /*
  314  * Copy a byte string into an sbuf.
  315  */
  316 int
  317 sbuf_bcpy(struct sbuf *s, const void *buf, size_t len)
  318 {
  319         assert_sbuf_integrity(s);
  320         assert_sbuf_state(s, 0);
  321 
  322         sbuf_clear(s);
  323         return (sbuf_bcat(s, buf, len));
  324 }
  325 
  326 /*
  327  * Append a string to an sbuf.
  328  */
  329 int
  330 sbuf_cat(struct sbuf *s, const char *str)
  331 {
  332         assert_sbuf_integrity(s);
  333         assert_sbuf_state(s, 0);
  334 
  335         if (SBUF_HASOVERFLOWED(s))
  336                 return (-1);
  337 
  338         while (*str) {
  339                 if (!SBUF_HASROOM(s) && sbuf_extend(s, strlen(str)) < 0)
  340                         break;
  341                 s->s_buf[s->s_len++] = *str++;
  342         }
  343         if (*str) {
  344                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
  345                 return (-1);
  346         }
  347         return (0);
  348 }
  349 
  350 #ifdef _KERNEL
  351 /*
  352  * Append a string from userland to an sbuf.
  353  */
  354 int
  355 sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len)
  356 {
  357         size_t done;
  358 
  359         assert_sbuf_integrity(s);
  360         assert_sbuf_state(s, 0);
  361 
  362         if (SBUF_HASOVERFLOWED(s))
  363                 return (-1);
  364 
  365         if (len == 0)
  366                 len = SBUF_FREESPACE(s);        /* XXX return 0? */
  367         if (len > SBUF_FREESPACE(s)) {
  368                 sbuf_extend(s, len);
  369                 len = min(len, SBUF_FREESPACE(s));
  370         }
  371         switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) {
  372         case ENAMETOOLONG:
  373                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
  374                 /* fall through */
  375         case 0:
  376                 s->s_len += done - 1;
  377                 break;
  378         default:
  379                 return (-1);    /* XXX */
  380         }
  381 
  382         return (0);
  383 }
  384 #endif
  385 
  386 /*
  387  * Copy a string into an sbuf.
  388  */
  389 int
  390 sbuf_cpy(struct sbuf *s, const char *str)
  391 {
  392         assert_sbuf_integrity(s);
  393         assert_sbuf_state(s, 0);
  394 
  395         sbuf_clear(s);
  396         return (sbuf_cat(s, str));
  397 }
  398 
  399 /*
  400  * Format the given argument list and append the resulting string to an sbuf.
  401  */
  402 int
  403 sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap)
  404 {
  405         va_list ap_copy;
  406         int len;
  407 
  408         assert_sbuf_integrity(s);
  409         assert_sbuf_state(s, 0);
  410 
  411         KASSERT(fmt != NULL,
  412             ("%s called with a NULL format string", __func__));
  413 
  414         if (SBUF_HASOVERFLOWED(s))
  415                 return (-1);
  416 
  417         do {
  418                 va_copy(ap_copy, ap);
  419                 len = vsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1,
  420                     fmt, ap_copy);
  421                 va_end(ap_copy);
  422         } while (len > SBUF_FREESPACE(s) &&
  423             sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0);
  424 
  425         /*
  426          * s->s_len is the length of the string, without the terminating nul.
  427          * When updating s->s_len, we must subtract 1 from the length that
  428          * we passed into vsnprintf() because that length includes the
  429          * terminating nul.
  430          *
  431          * vsnprintf() returns the amount that would have been copied,
  432          * given sufficient space, hence the min() calculation below.
  433          */
  434         s->s_len += min(len, SBUF_FREESPACE(s));
  435         if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s))
  436                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
  437 
  438         KASSERT(s->s_len < s->s_size,
  439             ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
  440 
  441         if (SBUF_HASOVERFLOWED(s))
  442                 return (-1);
  443         return (0);
  444 }
  445 
  446 /*
  447  * Format the given arguments and append the resulting string to an sbuf.
  448  */
  449 int
  450 sbuf_printf(struct sbuf *s, const char *fmt, ...)
  451 {
  452         va_list ap;
  453         int result;
  454 
  455         va_start(ap, fmt);
  456         result = sbuf_vprintf(s, fmt, ap);
  457         va_end(ap);
  458         return(result);
  459 }
  460 
  461 /*
  462  * Append a character to an sbuf.
  463  */
  464 int
  465 sbuf_putc(struct sbuf *s, int c)
  466 {
  467         assert_sbuf_integrity(s);
  468         assert_sbuf_state(s, 0);
  469 
  470         if (SBUF_HASOVERFLOWED(s))
  471                 return (-1);
  472 
  473         if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) {
  474                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
  475                 return (-1);
  476         }
  477         if (c != '\0')
  478             s->s_buf[s->s_len++] = c;
  479         return (0);
  480 }
  481 
  482 /*
  483  * Trim whitespace characters from end of an sbuf.
  484  */
  485 int
  486 sbuf_trim(struct sbuf *s)
  487 {
  488         assert_sbuf_integrity(s);
  489         assert_sbuf_state(s, 0);
  490 
  491         if (SBUF_HASOVERFLOWED(s))
  492                 return (-1);
  493 
  494         while (s->s_len && isspace(s->s_buf[s->s_len-1]))
  495                 --s->s_len;
  496 
  497         return (0);
  498 }
  499 
  500 /*
  501  * Check if an sbuf overflowed
  502  */
  503 int
  504 sbuf_overflowed(struct sbuf *s)
  505 {
  506     return SBUF_HASOVERFLOWED(s);
  507 }
  508 
  509 /*
  510  * Finish off an sbuf.
  511  */
  512 void
  513 sbuf_finish(struct sbuf *s)
  514 {
  515         assert_sbuf_integrity(s);
  516         assert_sbuf_state(s, 0);
  517 
  518         s->s_buf[s->s_len] = '\0';
  519         SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
  520         SBUF_SETFLAG(s, SBUF_FINISHED);
  521 }
  522 
  523 /*
  524  * Return a pointer to the sbuf data.
  525  */
  526 char *
  527 sbuf_data(struct sbuf *s)
  528 {
  529         assert_sbuf_integrity(s);
  530         assert_sbuf_state(s, SBUF_FINISHED);
  531 
  532         return s->s_buf;
  533 }
  534 
  535 /*
  536  * Return the length of the sbuf data.
  537  */
  538 int
  539 sbuf_len(struct sbuf *s)
  540 {
  541         assert_sbuf_integrity(s);
  542         /* don't care if it's finished or not */
  543 
  544         if (SBUF_HASOVERFLOWED(s))
  545                 return (-1);
  546         return s->s_len;
  547 }
  548 
  549 /*
  550  * Clear an sbuf, free its buffer if necessary.
  551  */
  552 void
  553 sbuf_delete(struct sbuf *s)
  554 {
  555         int isdyn;
  556 
  557         assert_sbuf_integrity(s);
  558         /* don't care if it's finished or not */
  559 
  560         if (SBUF_ISDYNAMIC(s))
  561                 SBFREE(s->s_buf);
  562         isdyn = SBUF_ISDYNSTRUCT(s);
  563         bzero(s, sizeof *s);
  564         if (isdyn)
  565                 SBFREE(s);
  566 }
  567 
  568 /*
  569  * Check if an sbuf has been finished.
  570  */
  571 int
  572 sbuf_done(struct sbuf *s)
  573 {
  574 
  575         return(SBUF_ISFINISHED(s));
  576 }
Cache object: 92a111bc6206d8c4b9cbdc50bcd83cf2
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/kern/subr_sbuf.c

FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_sbuf.c
