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  *      $DragonFly: src/sys/kern/subr_sbuf.c,v 1.9 2006/12/22 08:08:25 swildner Exp $
  30  */
  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 MALLOC_DEFINE(M_SBUF, "sbuf", "string buffers");
  53 #define SBMALLOC(size)          kmalloc(size, M_SBUF, M_WAITOK)
  54 #define SBFREE(buf)             kfree(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 kvsnprintf              vsnprintf
  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 < 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 char *str, size_t len)
 265 {
 266         assert_sbuf_integrity(s);
 267         assert_sbuf_state(s, 0);
 268
 269         if (SBUF_HASOVERFLOWED(s))
 270                 return (-1);
 271
 272         for (; len; len--) {
 273                 if (!SBUF_HASROOM(s) && sbuf_extend(s, len) < 0)
 274                         break;
 275                 s->s_buf[s->s_len++] = *str++;
 276         }
 277         if (len) {
 278                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
 279                 return (-1);
 280         }
 281         return (0);
 282 }
 283
 284 #ifdef _KERNEL
 285 /*
 286  * Copy a byte string from userland into an sbuf.
 287  */
 288 int
 289 sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len)
 290 {
 291         assert_sbuf_integrity(s);
 292         assert_sbuf_state(s, 0);
 293
 294         if (SBUF_HASOVERFLOWED(s))
 295                 return (-1);
 296
 297         if (len == 0)
 298                 return (0);
 299         if (len > SBUF_FREESPACE(s)) {
 300                 sbuf_extend(s, len - SBUF_FREESPACE(s));
 301                 len = MIN(len, SBUF_FREESPACE(s));
 302         }
 303         if (copyin(uaddr, s->s_buf + s->s_len, len) != 0)
 304                 return (-1);
 305         s->s_len += len;
 306
 307         return (0);
 308 }
 309 #endif
 310
 311 /*
 312  * Copy a byte string into an sbuf.
 313  */
 314 int
 315 sbuf_bcpy(struct sbuf *s, const char *str, size_t len)
 316 {
 317         assert_sbuf_integrity(s);
 318         assert_sbuf_state(s, 0);
 319
 320         sbuf_clear(s);
 321         return (sbuf_bcat(s, str, len));
 322 }
 323
 324 /*
 325  * Append a string to an sbuf.
 326  */
 327 int
 328 sbuf_cat(struct sbuf *s, const char *str)
 329 {
 330         assert_sbuf_integrity(s);
 331         assert_sbuf_state(s, 0);
 332
 333         if (SBUF_HASOVERFLOWED(s))
 334                 return (-1);
 335
 336         while (*str) {
 337                 if (!SBUF_HASROOM(s) && sbuf_extend(s, strlen(str)) < 0)
 338                         break;
 339                 s->s_buf[s->s_len++] = *str++;
 340         }
 341         if (*str) {
 342                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
 343                 return (-1);
 344         }
 345         return (0);
 346 }
 347
 348 #ifdef _KERNEL
 349 /*
 350  * Append a string from userland to an sbuf.
 351  */
 352 int
 353 sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len)
 354 {
 355         size_t done;
 356
 357         assert_sbuf_integrity(s);
 358         assert_sbuf_state(s, 0);
 359
 360         if (SBUF_HASOVERFLOWED(s))
 361                 return (-1);
 362
 363         if (len == 0)
 364                 len = SBUF_FREESPACE(s);        /* XXX return 0? */
 365         if (len > SBUF_FREESPACE(s)) {
 366                 sbuf_extend(s, len);
 367                 len = MIN(len, SBUF_FREESPACE(s));
 368         }
 369         switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) {
 370         case ENAMETOOLONG:
 371                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
 372                 /* fall through */
 373         case 0:
 374                 s->s_len += done - 1;
 375                 break;
 376         default:
 377                 return (-1);    /* XXX */
 378         }
 379
 380         return (0);
 381 }
 382 #endif
 383
 384 /*
 385  * Copy a string into an sbuf.
 386  */
 387 int
 388 sbuf_cpy(struct sbuf *s, const char *str)
 389 {
 390         assert_sbuf_integrity(s);
 391         assert_sbuf_state(s, 0);
 392
 393         sbuf_clear(s);
 394         return (sbuf_cat(s, str));
 395 }
 396
 397 /*
 398  * Format the given argument list and append the resulting string to an sbuf.
 399  */
 400 int
 401 sbuf_vprintf(struct sbuf *s, const char *fmt, __va_list ap)
 402 {
 403         int len;
 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                 len = kvsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1,
 416                                  fmt, ap);
 417         } while (len > SBUF_FREESPACE(s) &&
 418             sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0);
 419
 420         /*
 421          * s->s_len is the length of the string, without the terminating nul.
 422          * When updating s->s_len, we must subtract 1 from the length that
 423          * we passed into kvsnprintf() because that length includes the
 424          * terminating nul.
 425          *
 426          * kvsnprintf() returns the amount that would have been copied,
 427          * given sufficient space, hence the min() calculation below.
 428          */
 429         s->s_len += MIN(len, SBUF_FREESPACE(s));
 430         if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s))
 431                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
 432
 433         KASSERT(s->s_len < s->s_size,
 434             ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
 435
 436         if (SBUF_HASOVERFLOWED(s))
 437                 return (-1);
 438         return (0);
 439 }
 440
 441 /*
 442  * Format the given arguments and append the resulting string to an sbuf.
 443  */
 444 int
 445 sbuf_printf(struct sbuf *s, const char *fmt, ...)
 446 {
 447         __va_list ap;
 448         int result;
 449
 450         __va_start(ap, fmt);
 451         result = sbuf_vprintf(s, fmt, ap);
 452         __va_end(ap);
 453         return(result);
 454 }
 455
 456 /*
 457  * Append a character to an sbuf.
 458  */
 459 int
 460 sbuf_putc(struct sbuf *s, int c)
 461 {
 462         assert_sbuf_integrity(s);
 463         assert_sbuf_state(s, 0);
 464
 465         if (SBUF_HASOVERFLOWED(s))
 466                 return (-1);
 467
 468         if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) {
 469                 SBUF_SETFLAG(s, SBUF_OVERFLOWED);
 470                 return (-1);
 471         }
 472         if (c != '\0')
 473             s->s_buf[s->s_len++] = c;
 474         return (0);
 475 }
 476
 477 /*
 478  * Trim whitespace characters from end of an sbuf.
 479  */
 480 int
 481 sbuf_trim(struct sbuf *s)
 482 {
 483         assert_sbuf_integrity(s);
 484         assert_sbuf_state(s, 0);
 485
 486         if (SBUF_HASOVERFLOWED(s))
 487                 return (-1);
 488
 489         while (s->s_len && isspace(s->s_buf[s->s_len-1]))
 490                 --s->s_len;
 491
 492         return (0);
 493 }
 494
 495 /*
 496  * Check if an sbuf overflowed
 497  */
 498 int
 499 sbuf_overflowed(struct sbuf *s)
 500 {
 501     return SBUF_HASOVERFLOWED(s);
 502 }
 503
 504 /*
 505  * Finish off an sbuf.
 506  */
 507 void
 508 sbuf_finish(struct sbuf *s)
 509 {
 510         assert_sbuf_integrity(s);
 511         assert_sbuf_state(s, 0);
 512
 513         s->s_buf[s->s_len] = '\0';
 514         SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
 515         SBUF_SETFLAG(s, SBUF_FINISHED);
 516 }
 517
 518 /*
 519  * Return a pointer to the sbuf data.
 520  */
 521 char *
 522 sbuf_data(struct sbuf *s)
 523 {
 524         assert_sbuf_integrity(s);
 525         assert_sbuf_state(s, SBUF_FINISHED);
 526
 527         return s->s_buf;
 528 }
 529
 530 /*
 531  * Return the length of the sbuf data.
 532  */
 533 int
 534 sbuf_len(struct sbuf *s)
 535 {
 536         assert_sbuf_integrity(s);
 537         /* don't care if it's finished or not */
 538
 539         if (SBUF_HASOVERFLOWED(s))
 540                 return (-1);
 541         return s->s_len;
 542 }
 543
 544 /*
 545  * Clear an sbuf, free its buffer if necessary.
 546  */
 547 void
 548 sbuf_delete(struct sbuf *s)
 549 {
 550         int isdyn;
 551
 552         assert_sbuf_integrity(s);
 553         /* don't care if it's finished or not */
 554
 555         if (SBUF_ISDYNAMIC(s))
 556                 SBFREE(s->s_buf);
 557         isdyn = SBUF_ISDYNSTRUCT(s);
 558         bzero(s, sizeof *s);
 559         if (isdyn)
 560                 SBFREE(s);
 561 }