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
  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 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 (done);
 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 }