sys/kern/subr_sbuf.c

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