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: src/sys/kern/subr_sbuf.c,v 1.11.2.2 2002/03/12 01:01:07 archie Exp $
  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)          kmalloc(size, M_SBUF, M_WAITOK)
  53 #define SBFREE(buf)             kfree(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 kvsnprintf              vsnprintf
  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(const 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(const 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(__func__, (s))
 105 #define assert_sbuf_state(s, i)  _assert_sbuf_state(__func__, (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", __func__));
 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", __func__));
 205         KASSERT(error != NULL,
 206             ("%s called with NULL error pointer", __func__));
 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         __va_list ap_copy;
 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", __func__));
 410
 411         if (SBUF_HASOVERFLOWED(s))
 412                 return (-1);
 413
 414         do {
 415                 __va_copy(ap_copy, ap);
 416                 len = kvsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1,
 417                                  fmt, ap_copy);
 418                 __va_end(ap_copy);
 419         } while (len > SBUF_FREESPACE(s) &&
 420             sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0);
 421
 422         /*
 423          * s->s_len is the length of the string, without the terminating nul.
 424          * When updating s->s_len, we must subtract 1 from the length that
 425          * we passed into kvsnprintf() because that length includes the
 426          * terminating nul.
 427          *
 428          * kvsnprintf() returns the amount that would have been copied,
 429          * given sufficient space, hence the min() calculation below.
 430          */
 431         s->s_len += MIN(len, SBUF_FREESPACE(s));
 432         if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s))
 433                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
 434
 435         KASSERT(s->s_len < s->s_size,
 436             ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
 437
 438         if (SBUF_HASOVERFLOWED(s))
 439                 return (-1);
 440         return (0);
 441 }
 442
 443 /*
 444  * Format the given arguments and append the resulting string to an sbuf.
 445  */
 446 int
 447 sbuf_printf(struct sbuf *s, const char *fmt, ...)
 448 {
 449         __va_list ap;
 450         int result;
 451
 452         __va_start(ap, fmt);
 453         result = sbuf_vprintf(s, fmt, ap);
 454         __va_end(ap);
 455         return(result);
 456 }
 457
 458 /*
 459  * Append a character to an sbuf.
 460  */
 461 int
 462 sbuf_putc(struct sbuf *s, int c)
 463 {
 464         assert_sbuf_integrity(s);
 465         assert_sbuf_state(s, 0);
 466
 467         if (SBUF_HASOVERFLOWED(s))
 468                 return (-1);
 469
 470         if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) {
 471                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
 472                 return (-1);
 473         }
 474         if (c != '\0')
 475             s->s_buf[s->s_len++] = c;
 476         return (0);
 477 }
 478
 479 /*
 480  * Trim whitespace characters from end of an sbuf.
 481  */
 482 int
 483 sbuf_trim(struct sbuf *s)
 484 {
 485         assert_sbuf_integrity(s);
 486         assert_sbuf_state(s, 0);
 487
 488         if (SBUF_HASOVERFLOWED(s))
 489                 return (-1);
 490
 491         while (s->s_len && isspace(s->s_buf[s->s_len-1]))
 492                 --s->s_len;
 493
 494         return (0);
 495 }
 496
 497 /*
 498  * Check if an sbuf overflowed
 499  */
 500 int
 501 sbuf_overflowed(struct sbuf *s)
 502 {
 503     return SBUF_HASOVERFLOWED(s);
 504 }
 505
 506 /*
 507  * Finish off an sbuf.
 508  */
 509 void
 510 sbuf_finish(struct sbuf *s)
 511 {
 512         assert_sbuf_integrity(s);
 513         assert_sbuf_state(s, 0);
 514
 515         s->s_buf[s->s_len] = '\0';
 516         SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
 517         SBUF_SETFLAG(s, SBUF_FINISHED);
 518 }
 519
 520 /*
 521  * Return a pointer to the sbuf data.
 522  */
 523 char *
 524 sbuf_data(struct sbuf *s)
 525 {
 526         assert_sbuf_integrity(s);
 527         assert_sbuf_state(s, SBUF_FINISHED);
 528
 529         return s->s_buf;
 530 }
 531
 532 /*
 533  * Return the length of the sbuf data.
 534  */
 535 int
 536 sbuf_len(struct sbuf *s)
 537 {
 538         assert_sbuf_integrity(s);
 539         /* don't care if it's finished or not */
 540
 541         if (SBUF_HASOVERFLOWED(s))
 542                 return (-1);
 543         return s->s_len;
 544 }
 545
 546 /*
 547  * Clear an sbuf, free its buffer if necessary.
 548  */
 549 void
 550 sbuf_delete(struct sbuf *s)
 551 {
 552         int isdyn;
 553
 554         assert_sbuf_integrity(s);
 555         /* don't care if it's finished or not */
 556
 557         if (SBUF_ISDYNAMIC(s))
 558                 SBFREE(s->s_buf);
 559         isdyn = SBUF_ISDYNSTRUCT(s);
 560         bzero(s, sizeof *s);
 561         if (isdyn)
 562                 SBFREE(s);
 563 }
 564
 565 /*
 566  * Check if an sbuf has been finished.
 567  */
 568 int
 569 sbuf_done(struct sbuf *s)
 570 {
 571         return(SBUF_ISFINISHED(s));
 572 }