1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2000-2008 Poul-Henning Kamp 5 * Copyright (c) 2000-2008 Dag-Erling Coïdan Smørgrav 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer 13 * in this position and unchanged. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/param.h> 35 36 #ifdef _KERNEL 37 #include <sys/ctype.h> 38 #include <sys/errno.h> 39 #include <sys/kernel.h> 40 #include <sys/limits.h> 41 #include <sys/malloc.h> 42 #include <sys/systm.h> 43 #include <sys/uio.h> 44 #include <machine/stdarg.h> 45 #else /* _KERNEL */ 46 #include <ctype.h> 47 #include <errno.h> 48 #include <limits.h> 49 #include <stdarg.h> 50 #include <stdio.h> 51 #include <stdlib.h> 52 #include <string.h> 53 #endif /* _KERNEL */ 54 55 #include <sys/sbuf.h> 56 57 #ifdef _KERNEL 58 static MALLOC_DEFINE(M_SBUF, "sbuf", "string buffers"); 59 #define SBMALLOC(size, flags) malloc(size, M_SBUF, (flags) | M_ZERO) 60 #define SBFREE(buf) free(buf, M_SBUF) 61 #else /* _KERNEL */ 62 #define KASSERT(e, m) 63 #define SBMALLOC(size, flags) calloc(1, size) 64 #define SBFREE(buf) free(buf) 65 #endif /* _KERNEL */ 66 67 /* 68 * Predicates 69 */ 70 #define SBUF_ISDYNAMIC(s) ((s)->s_flags & SBUF_DYNAMIC) 71 #define SBUF_ISDYNSTRUCT(s) ((s)->s_flags & SBUF_DYNSTRUCT) 72 #define SBUF_ISFINISHED(s) ((s)->s_flags & SBUF_FINISHED) 73 #define SBUF_ISDRAINATEOL(s) ((s)->s_flags & SBUF_DRAINATEOL) 74 #define SBUF_HASROOM(s) ((s)->s_len < (s)->s_size - 1) 75 #define SBUF_FREESPACE(s) ((s)->s_size - ((s)->s_len + 1)) 76 #define SBUF_CANEXTEND(s) ((s)->s_flags & SBUF_AUTOEXTEND) 77 #define SBUF_ISSECTION(s) ((s)->s_flags & SBUF_INSECTION) 78 #define SBUF_NULINCLUDED(s) ((s)->s_flags & SBUF_INCLUDENUL) 79 #define SBUF_ISDRAINTOEOR(s) ((s)->s_flags & SBUF_DRAINTOEOR) 80 #define SBUF_DODRAINTOEOR(s) (SBUF_ISSECTION(s) && SBUF_ISDRAINTOEOR(s)) 81 #define SBUF_MALLOCFLAG(s) \ 82 (((s)->s_flags & SBUF_NOWAIT) ? M_NOWAIT : M_WAITOK) 83 84 /* 85 * Set / clear flags 86 */ 87 #define SBUF_SETFLAG(s, f) do { (s)->s_flags |= (f); } while (0) 88 #define SBUF_CLEARFLAG(s, f) do { (s)->s_flags &= ~(f); } while (0) 89 90 #define SBUF_MINSIZE 2 /* Min is 1 byte + nulterm. */ 91 #define SBUF_MINEXTENDSIZE 16 /* Should be power of 2. */ 92 93 #ifdef PAGE_SIZE 94 #define SBUF_MAXEXTENDSIZE PAGE_SIZE 95 #define SBUF_MAXEXTENDINCR PAGE_SIZE 96 #else 97 #define SBUF_MAXEXTENDSIZE 4096 98 #define SBUF_MAXEXTENDINCR 4096 99 #endif 100 101 /* 102 * Debugging support 103 */ 104 #if defined(_KERNEL) && defined(INVARIANTS) 105 106 static void 107 _assert_sbuf_integrity(const char *fun, struct sbuf *s) 108 { 109 110 KASSERT(s != NULL, 111 ("%s called with a NULL sbuf pointer", fun)); 112 KASSERT(s->s_buf != NULL, 113 ("%s called with uninitialized or corrupt sbuf", fun)); 114 if (SBUF_ISFINISHED(s) && SBUF_NULINCLUDED(s)) { 115 KASSERT(s->s_len <= s->s_size, 116 ("wrote past end of sbuf (%jd >= %jd)", 117 (intmax_t)s->s_len, (intmax_t)s->s_size)); 118 } else { 119 KASSERT(s->s_len < s->s_size, 120 ("wrote past end of sbuf (%jd >= %jd)", 121 (intmax_t)s->s_len, (intmax_t)s->s_size)); 122 } 123 } 124 125 static void 126 _assert_sbuf_state(const char *fun, struct sbuf *s, int state) 127 { 128 129 KASSERT((s->s_flags & SBUF_FINISHED) == state, 130 ("%s called with %sfinished or corrupt sbuf", fun, 131 (state ? "un" : ""))); 132 } 133 134 #define assert_sbuf_integrity(s) _assert_sbuf_integrity(__func__, (s)) 135 #define assert_sbuf_state(s, i) _assert_sbuf_state(__func__, (s), (i)) 136 137 #else /* _KERNEL && INVARIANTS */ 138 139 #define assert_sbuf_integrity(s) do { } while (0) 140 #define assert_sbuf_state(s, i) do { } while (0) 141 142 #endif /* _KERNEL && INVARIANTS */ 143 144 #ifdef CTASSERT 145 CTASSERT(powerof2(SBUF_MAXEXTENDSIZE)); 146 CTASSERT(powerof2(SBUF_MAXEXTENDINCR)); 147 #endif 148 149 static int 150 sbuf_extendsize(int size) 151 { 152 int newsize; 153 154 if (size < (int)SBUF_MAXEXTENDSIZE) { 155 newsize = SBUF_MINEXTENDSIZE; 156 while (newsize < size) 157 newsize *= 2; 158 } else { 159 newsize = roundup2(size, SBUF_MAXEXTENDINCR); 160 } 161 KASSERT(newsize >= size, ("%s: %d < %d\n", __func__, newsize, size)); 162 return (newsize); 163 } 164 165 /* 166 * Extend an sbuf. 167 */ 168 static int 169 sbuf_extend(struct sbuf *s, int addlen) 170 { 171 char *newbuf; 172 int newsize; 173 174 if (!SBUF_CANEXTEND(s)) 175 return (-1); 176 newsize = sbuf_extendsize(s->s_size + addlen); 177 newbuf = SBMALLOC(newsize, SBUF_MALLOCFLAG(s)); 178 if (newbuf == NULL) 179 return (-1); 180 memcpy(newbuf, s->s_buf, s->s_size); 181 if (SBUF_ISDYNAMIC(s)) 182 SBFREE(s->s_buf); 183 else 184 SBUF_SETFLAG(s, SBUF_DYNAMIC); 185 s->s_buf = newbuf; 186 s->s_size = newsize; 187 return (0); 188 } 189 190 /* 191 * Initialize an sbuf. 192 * If buf is non-NULL, it points to a static or already-allocated string 193 * big enough to hold at least length characters. 194 */ 195 struct sbuf * 196 sbuf_new(struct sbuf *s, char *buf, int length, int flags) 197 { 198 199 KASSERT(length >= 0, 200 ("attempt to create an sbuf of negative length (%d)", length)); 201 KASSERT((flags & ~SBUF_USRFLAGMSK) == 0, 202 ("%s called with invalid flags", __func__)); 203 KASSERT((flags & SBUF_AUTOEXTEND) || length >= SBUF_MINSIZE, 204 ("sbuf buffer %d smaller than minimum %d bytes", length, 205 SBUF_MINSIZE)); 206 207 flags &= SBUF_USRFLAGMSK; 208 209 /* 210 * Allocate 'DYNSTRUCT' sbuf from the heap, if NULL 's' was provided. 211 */ 212 if (s == NULL) { 213 s = SBMALLOC(sizeof(*s), 214 (flags & SBUF_NOWAIT) ? M_NOWAIT : M_WAITOK); 215 if (s == NULL) 216 goto out; 217 SBUF_SETFLAG(s, SBUF_DYNSTRUCT); 218 } else { 219 /* 220 * DYNSTRUCT SBMALLOC sbufs are allocated with M_ZERO, but 221 * user-provided sbuf objects must be initialized. 222 */ 223 memset(s, 0, sizeof(*s)); 224 } 225 226 s->s_flags |= flags; 227 s->s_size = length; 228 s->s_buf = buf; 229 /* 230 * Never-written sbufs do not need \n termination. 231 */ 232 SBUF_SETFLAG(s, SBUF_DRAINATEOL); 233 234 /* 235 * Allocate DYNAMIC, i.e., heap data buffer backing the sbuf, if no 236 * buffer was provided. 237 */ 238 if (s->s_buf == NULL) { 239 if (SBUF_CANEXTEND(s)) 240 s->s_size = sbuf_extendsize(s->s_size); 241 s->s_buf = SBMALLOC(s->s_size, SBUF_MALLOCFLAG(s)); 242 if (s->s_buf == NULL) 243 goto out; 244 SBUF_SETFLAG(s, SBUF_DYNAMIC); 245 } 246 247 out: 248 if (s != NULL && s->s_buf == NULL) { 249 if (SBUF_ISDYNSTRUCT(s)) 250 SBFREE(s); 251 s = NULL; 252 } 253 return (s); 254 } 255 256 #ifdef _KERNEL 257 /* 258 * Create an sbuf with uio data 259 */ 260 struct sbuf * 261 sbuf_uionew(struct sbuf *s, struct uio *uio, int *error) 262 { 263 264 KASSERT(uio != NULL, 265 ("%s called with NULL uio pointer", __func__)); 266 KASSERT(error != NULL, 267 ("%s called with NULL error pointer", __func__)); 268 269 if (uio->uio_resid >= INT_MAX || uio->uio_resid < SBUF_MINSIZE - 1) { 270 *error = EINVAL; 271 return (NULL); 272 } 273 s = sbuf_new(s, NULL, uio->uio_resid + 1, 0); 274 if (s == NULL) { 275 *error = ENOMEM; 276 return (NULL); 277 } 278 *error = uiomove(s->s_buf, uio->uio_resid, uio); 279 if (*error != 0) { 280 sbuf_delete(s); 281 return (NULL); 282 } 283 s->s_len = s->s_size - 1; 284 if (SBUF_ISSECTION(s)) 285 s->s_sect_len = s->s_size - 1; 286 *error = 0; 287 return (s); 288 } 289 #endif 290 291 int 292 sbuf_get_flags(struct sbuf *s) 293 { 294 295 return (s->s_flags & SBUF_USRFLAGMSK); 296 } 297 298 void 299 sbuf_clear_flags(struct sbuf *s, int flags) 300 { 301 302 s->s_flags &= ~(flags & SBUF_USRFLAGMSK); 303 } 304 305 void 306 sbuf_set_flags(struct sbuf *s, int flags) 307 { 308 309 s->s_flags |= (flags & SBUF_USRFLAGMSK); 310 } 311 312 /* 313 * Clear an sbuf and reset its position. 314 */ 315 void 316 sbuf_clear(struct sbuf *s) 317 { 318 319 assert_sbuf_integrity(s); 320 /* don't care if it's finished or not */ 321 KASSERT(s->s_drain_func == NULL, 322 ("%s makes no sense on sbuf %p with drain", __func__, s)); 323 324 SBUF_CLEARFLAG(s, SBUF_FINISHED); 325 s->s_error = 0; 326 s->s_len = 0; 327 s->s_rec_off = 0; 328 s->s_sect_len = 0; 329 } 330 331 /* 332 * Set the sbuf's end position to an arbitrary value. 333 * Effectively truncates the sbuf at the new position. 334 */ 335 int 336 sbuf_setpos(struct sbuf *s, ssize_t pos) 337 { 338 339 assert_sbuf_integrity(s); 340 assert_sbuf_state(s, 0); 341 342 KASSERT(pos >= 0, 343 ("attempt to seek to a negative position (%jd)", (intmax_t)pos)); 344 KASSERT(pos < s->s_size, 345 ("attempt to seek past end of sbuf (%jd >= %jd)", 346 (intmax_t)pos, (intmax_t)s->s_size)); 347 KASSERT(!SBUF_ISSECTION(s), 348 ("attempt to seek when in a section")); 349 350 if (pos < 0 || pos > s->s_len) 351 return (-1); 352 s->s_len = pos; 353 return (0); 354 } 355 356 /* 357 * Drain into a counter. Counts amount of data without producing output. 358 * Useful for cases like sysctl, where user may first request only size. 359 * This allows to avoid pointless allocation/freeing of large buffers. 360 */ 361 int 362 sbuf_count_drain(void *arg, const char *data __unused, int len) 363 { 364 size_t *sizep; 365 366 sizep = (size_t *)arg; 367 *sizep += len; 368 return (len); 369 } 370 371 /* 372 * Set up a drain function and argument on an sbuf to flush data to 373 * when the sbuf buffer overflows. 374 */ 375 void 376 sbuf_set_drain(struct sbuf *s, sbuf_drain_func *func, void *ctx) 377 { 378 379 assert_sbuf_state(s, 0); 380 assert_sbuf_integrity(s); 381 KASSERT(func == s->s_drain_func || s->s_len == 0, 382 ("Cannot change drain to %p on non-empty sbuf %p", func, s)); 383 s->s_drain_func = func; 384 s->s_drain_arg = ctx; 385 } 386 387 /* 388 * Call the drain and process the return. 389 */ 390 int 391 sbuf_drain(struct sbuf *s) 392 { 393 int len; 394 395 /* 396 * Immediately return when no work to do, 397 * or an error has already been accumulated. 398 */ 399 if ((s->s_len == 0) || (s->s_error != 0)) 400 return(s->s_error); 401 402 if (SBUF_DODRAINTOEOR(s) && s->s_rec_off == 0) 403 return (s->s_error = EDEADLK); 404 len = s->s_drain_func(s->s_drain_arg, s->s_buf, 405 SBUF_DODRAINTOEOR(s) ? s->s_rec_off : s->s_len); 406 if (len <= 0) { 407 s->s_error = len ? -len : EDEADLK; 408 return (s->s_error); 409 } 410 KASSERT(len > 0 && len <= s->s_len, 411 ("Bad drain amount %d for sbuf %p", len, s)); 412 s->s_len -= len; 413 s->s_rec_off -= len; 414 /* 415 * Fast path for the expected case where all the data was 416 * drained. 417 */ 418 if (s->s_len == 0) { 419 /* 420 * When the s_buf is entirely drained, we need to remember if 421 * the last character was a '\n' or not for 422 * sbuf_nl_terminate(). 423 */ 424 if (s->s_buf[len - 1] == '\n') 425 SBUF_SETFLAG(s, SBUF_DRAINATEOL); 426 else 427 SBUF_CLEARFLAG(s, SBUF_DRAINATEOL); 428 return (0); 429 } 430 /* 431 * Move the remaining characters to the beginning of the 432 * string. 433 */ 434 memmove(s->s_buf, s->s_buf + len, s->s_len); 435 return (0); 436 } 437 438 /* 439 * Append bytes to an sbuf. This is the core function for appending 440 * to an sbuf and is the main place that deals with extending the 441 * buffer and marking overflow. 442 */ 443 static void 444 sbuf_put_bytes(struct sbuf *s, const char *buf, size_t len) 445 { 446 size_t n; 447 448 assert_sbuf_integrity(s); 449 assert_sbuf_state(s, 0); 450 451 if (s->s_error != 0) 452 return; 453 while (len > 0) { 454 if (SBUF_FREESPACE(s) <= 0) { 455 /* 456 * If there is a drain, use it, otherwise extend the 457 * buffer. 458 */ 459 if (s->s_drain_func != NULL) 460 (void)sbuf_drain(s); 461 else if (sbuf_extend(s, len > INT_MAX ? INT_MAX : len) 462 < 0) 463 s->s_error = ENOMEM; 464 if (s->s_error != 0) 465 return; 466 } 467 n = SBUF_FREESPACE(s); 468 if (len < n) 469 n = len; 470 memcpy(&s->s_buf[s->s_len], buf, n); 471 s->s_len += n; 472 if (SBUF_ISSECTION(s)) 473 s->s_sect_len += n; 474 len -= n; 475 buf += n; 476 } 477 } 478 479 static void 480 sbuf_put_byte(struct sbuf *s, char c) 481 { 482 483 assert_sbuf_integrity(s); 484 assert_sbuf_state(s, 0); 485 486 if (__predict_false(s->s_error != 0)) 487 return; 488 if (__predict_false(SBUF_FREESPACE(s) <= 0)) { 489 /* 490 * If there is a drain, use it, otherwise extend the 491 * buffer. 492 */ 493 if (s->s_drain_func != NULL) 494 (void)sbuf_drain(s); 495 else if (sbuf_extend(s, 1) < 0) 496 s->s_error = ENOMEM; 497 if (s->s_error != 0) 498 return; 499 } 500 s->s_buf[s->s_len++] = c; 501 if (SBUF_ISSECTION(s)) 502 s->s_sect_len++; 503 } 504 505 /* 506 * Append a byte string to an sbuf. 507 */ 508 int 509 sbuf_bcat(struct sbuf *s, const void *buf, size_t len) 510 { 511 512 sbuf_put_bytes(s, buf, len); 513 if (s->s_error != 0) 514 return (-1); 515 return (0); 516 } 517 518 #ifdef _KERNEL 519 /* 520 * Copy a byte string from userland into an sbuf. 521 */ 522 int 523 sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len) 524 { 525 526 assert_sbuf_integrity(s); 527 assert_sbuf_state(s, 0); 528 KASSERT(s->s_drain_func == NULL, 529 ("Nonsensical copyin to sbuf %p with a drain", s)); 530 531 if (s->s_error != 0) 532 return (-1); 533 if (len == 0) 534 return (0); 535 if (len > SBUF_FREESPACE(s)) { 536 sbuf_extend(s, len - SBUF_FREESPACE(s)); 537 if (SBUF_FREESPACE(s) < len) 538 len = SBUF_FREESPACE(s); 539 } 540 if (copyin(uaddr, s->s_buf + s->s_len, len) != 0) 541 return (-1); 542 s->s_len += len; 543 544 return (0); 545 } 546 #endif 547 548 /* 549 * Copy a byte string into an sbuf. 550 */ 551 int 552 sbuf_bcpy(struct sbuf *s, const void *buf, size_t len) 553 { 554 555 assert_sbuf_integrity(s); 556 assert_sbuf_state(s, 0); 557 558 sbuf_clear(s); 559 return (sbuf_bcat(s, buf, len)); 560 } 561 562 /* 563 * Append a string to an sbuf. 564 */ 565 int 566 sbuf_cat(struct sbuf *s, const char *str) 567 { 568 size_t n; 569 570 n = strlen(str); 571 sbuf_put_bytes(s, str, n); 572 if (s->s_error != 0) 573 return (-1); 574 return (0); 575 } 576 577 #ifdef _KERNEL 578 /* 579 * Append a string from userland to an sbuf. 580 */ 581 int 582 sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len) 583 { 584 size_t done; 585 586 assert_sbuf_integrity(s); 587 assert_sbuf_state(s, 0); 588 KASSERT(s->s_drain_func == NULL, 589 ("Nonsensical copyin to sbuf %p with a drain", s)); 590 591 if (s->s_error != 0) 592 return (-1); 593 594 if (len == 0) 595 len = SBUF_FREESPACE(s); /* XXX return 0? */ 596 if (len > SBUF_FREESPACE(s)) { 597 sbuf_extend(s, len); 598 if (SBUF_FREESPACE(s) < len) 599 len = SBUF_FREESPACE(s); 600 } 601 switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) { 602 case ENAMETOOLONG: 603 s->s_error = ENOMEM; 604 /* fall through */ 605 case 0: 606 s->s_len += done - 1; 607 if (SBUF_ISSECTION(s)) 608 s->s_sect_len += done - 1; 609 break; 610 default: 611 return (-1); /* XXX */ 612 } 613 614 return (done); 615 } 616 #endif 617 618 /* 619 * Copy a string into an sbuf. 620 */ 621 int 622 sbuf_cpy(struct sbuf *s, const char *str) 623 { 624 625 assert_sbuf_integrity(s); 626 assert_sbuf_state(s, 0); 627 628 sbuf_clear(s); 629 return (sbuf_cat(s, str)); 630 } 631 632 /* 633 * Format the given argument list and append the resulting string to an sbuf. 634 */ 635 #ifdef _KERNEL 636 637 /* 638 * Append a non-NUL character to an sbuf. This prototype signature is 639 * suitable for use with kvprintf(9). 640 */ 641 static void 642 sbuf_putc_func(int c, void *arg) 643 { 644 645 if (__predict_true(c != '\0')) 646 sbuf_put_byte(arg, c); 647 } 648 649 int 650 sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap) 651 { 652 653 assert_sbuf_integrity(s); 654 assert_sbuf_state(s, 0); 655 656 KASSERT(fmt != NULL, 657 ("%s called with a NULL format string", __func__)); 658 659 (void)kvprintf(fmt, sbuf_putc_func, s, 10, ap); 660 if (s->s_error != 0) 661 return (-1); 662 return (0); 663 } 664 #else /* !_KERNEL */ 665 int 666 sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap) 667 { 668 va_list ap_copy; 669 int error, len; 670 671 assert_sbuf_integrity(s); 672 assert_sbuf_state(s, 0); 673 674 KASSERT(fmt != NULL, 675 ("%s called with a NULL format string", __func__)); 676 677 if (s->s_error != 0) 678 return (-1); 679 680 /* 681 * For the moment, there is no way to get vsnprintf(3) to hand 682 * back a character at a time, to push everything into 683 * sbuf_putc_func() as was done for the kernel. 684 * 685 * In userspace, while drains are useful, there's generally 686 * not a problem attempting to malloc(3) on out of space. So 687 * expand a userland sbuf if there is not enough room for the 688 * data produced by sbuf_[v]printf(3). 689 */ 690 691 error = 0; 692 do { 693 va_copy(ap_copy, ap); 694 len = vsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1, 695 fmt, ap_copy); 696 if (len < 0) { 697 s->s_error = errno; 698 return (-1); 699 } 700 va_end(ap_copy); 701 702 if (SBUF_FREESPACE(s) >= len) 703 break; 704 /* Cannot print with the current available space. */ 705 if (s->s_drain_func != NULL && s->s_len > 0) 706 error = sbuf_drain(s); /* sbuf_drain() sets s_error. */ 707 else if (sbuf_extend(s, len - SBUF_FREESPACE(s)) != 0) 708 s->s_error = error = ENOMEM; 709 } while (error == 0); 710 711 /* 712 * s->s_len is the length of the string, without the terminating nul. 713 * When updating s->s_len, we must subtract 1 from the length that 714 * we passed into vsnprintf() because that length includes the 715 * terminating nul. 716 * 717 * vsnprintf() returns the amount that would have been copied, 718 * given sufficient space, so don't over-increment s_len. 719 */ 720 if (SBUF_FREESPACE(s) < len) 721 len = SBUF_FREESPACE(s); 722 s->s_len += len; 723 if (SBUF_ISSECTION(s)) 724 s->s_sect_len += len; 725 726 KASSERT(s->s_len < s->s_size, 727 ("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size)); 728 729 if (s->s_error != 0) 730 return (-1); 731 return (0); 732 } 733 #endif /* _KERNEL */ 734 735 /* 736 * Format the given arguments and append the resulting string to an sbuf. 737 */ 738 int 739 sbuf_printf(struct sbuf *s, const char *fmt, ...) 740 { 741 va_list ap; 742 int result; 743 744 va_start(ap, fmt); 745 result = sbuf_vprintf(s, fmt, ap); 746 va_end(ap); 747 return (result); 748 } 749 750 /* 751 * Append a character to an sbuf. 752 */ 753 int 754 sbuf_putc(struct sbuf *s, int c) 755 { 756 757 sbuf_put_byte(s, c); 758 if (s->s_error != 0) 759 return (-1); 760 return (0); 761 } 762 763 /* 764 * Append a trailing newline to a non-empty sbuf, if one is not already 765 * present. Handles sbufs with drain functions correctly. 766 */ 767 int 768 sbuf_nl_terminate(struct sbuf *s) 769 { 770 771 assert_sbuf_integrity(s); 772 assert_sbuf_state(s, 0); 773 774 /* 775 * If the s_buf isn't empty, the last byte is simply s_buf[s_len - 1]. 776 * 777 * If the s_buf is empty because a drain function drained it, we 778 * remember if the last byte was a \n with the SBUF_DRAINATEOL flag in 779 * sbuf_drain(). 780 * 781 * In either case, we only append a \n if the previous character was 782 * something else. 783 */ 784 if (s->s_len == 0) { 785 if (!SBUF_ISDRAINATEOL(s)) 786 sbuf_put_byte(s, '\n'); 787 } else if (s->s_buf[s->s_len - 1] != '\n') 788 sbuf_put_byte(s, '\n'); 789 790 if (s->s_error != 0) 791 return (-1); 792 return (0); 793 } 794 795 /* 796 * Trim whitespace characters from end of an sbuf. 797 */ 798 int 799 sbuf_trim(struct sbuf *s) 800 { 801 802 assert_sbuf_integrity(s); 803 assert_sbuf_state(s, 0); 804 KASSERT(s->s_drain_func == NULL, 805 ("%s makes no sense on sbuf %p with drain", __func__, s)); 806 807 if (s->s_error != 0) 808 return (-1); 809 810 while (s->s_len > 0 && isspace(s->s_buf[s->s_len-1])) { 811 --s->s_len; 812 if (SBUF_ISSECTION(s)) 813 s->s_sect_len--; 814 } 815 816 return (0); 817 } 818 819 /* 820 * Check if an sbuf has an error. 821 */ 822 int 823 sbuf_error(const struct sbuf *s) 824 { 825 826 return (s->s_error); 827 } 828 829 /* 830 * Finish off an sbuf. 831 */ 832 int 833 sbuf_finish(struct sbuf *s) 834 { 835 836 assert_sbuf_integrity(s); 837 assert_sbuf_state(s, 0); 838 839 s->s_buf[s->s_len] = '\0'; 840 if (SBUF_NULINCLUDED(s)) 841 s->s_len++; 842 if (s->s_drain_func != NULL) { 843 while (s->s_len > 0 && s->s_error == 0) 844 s->s_error = sbuf_drain(s); 845 } 846 SBUF_SETFLAG(s, SBUF_FINISHED); 847 #ifdef _KERNEL 848 return (s->s_error); 849 #else 850 if (s->s_error != 0) { 851 errno = s->s_error; 852 return (-1); 853 } 854 return (0); 855 #endif 856 } 857 858 /* 859 * Return a pointer to the sbuf data. 860 */ 861 char * 862 sbuf_data(struct sbuf *s) 863 { 864 865 assert_sbuf_integrity(s); 866 assert_sbuf_state(s, SBUF_FINISHED); 867 KASSERT(s->s_drain_func == NULL, 868 ("%s makes no sense on sbuf %p with drain", __func__, s)); 869 870 return (s->s_buf); 871 } 872 873 /* 874 * Return the length of the sbuf data. 875 */ 876 ssize_t 877 sbuf_len(struct sbuf *s) 878 { 879 880 assert_sbuf_integrity(s); 881 /* don't care if it's finished or not */ 882 KASSERT(s->s_drain_func == NULL, 883 ("%s makes no sense on sbuf %p with drain", __func__, s)); 884 885 if (s->s_error != 0) 886 return (-1); 887 888 /* If finished, nulterm is already in len, else add one. */ 889 if (SBUF_NULINCLUDED(s) && !SBUF_ISFINISHED(s)) 890 return (s->s_len + 1); 891 return (s->s_len); 892 } 893 894 /* 895 * Clear an sbuf, free its buffer if necessary. 896 */ 897 void 898 sbuf_delete(struct sbuf *s) 899 { 900 int isdyn; 901 902 assert_sbuf_integrity(s); 903 /* don't care if it's finished or not */ 904 905 if (SBUF_ISDYNAMIC(s)) 906 SBFREE(s->s_buf); 907 isdyn = SBUF_ISDYNSTRUCT(s); 908 memset(s, 0, sizeof(*s)); 909 if (isdyn) 910 SBFREE(s); 911 } 912 913 /* 914 * Check if an sbuf has been finished. 915 */ 916 int 917 sbuf_done(const struct sbuf *s) 918 { 919 920 return (SBUF_ISFINISHED(s)); 921 } 922 923 /* 924 * Start a section. 925 */ 926 void 927 sbuf_start_section(struct sbuf *s, ssize_t *old_lenp) 928 { 929 930 assert_sbuf_integrity(s); 931 assert_sbuf_state(s, 0); 932 933 if (!SBUF_ISSECTION(s)) { 934 KASSERT(s->s_sect_len == 0, 935 ("s_sect_len != 0 when starting a section")); 936 if (old_lenp != NULL) 937 *old_lenp = -1; 938 s->s_rec_off = s->s_len; 939 SBUF_SETFLAG(s, SBUF_INSECTION); 940 } else { 941 KASSERT(old_lenp != NULL, 942 ("s_sect_len should be saved when starting a subsection")); 943 *old_lenp = s->s_sect_len; 944 s->s_sect_len = 0; 945 } 946 } 947 948 /* 949 * End the section padding to the specified length with the specified 950 * character. 951 */ 952 ssize_t 953 sbuf_end_section(struct sbuf *s, ssize_t old_len, size_t pad, int c) 954 { 955 ssize_t len; 956 957 assert_sbuf_integrity(s); 958 assert_sbuf_state(s, 0); 959 KASSERT(SBUF_ISSECTION(s), 960 ("attempt to end a section when not in a section")); 961 962 if (pad > 1) { 963 len = roundup(s->s_sect_len, pad) - s->s_sect_len; 964 for (; s->s_error == 0 && len > 0; len--) 965 sbuf_put_byte(s, c); 966 } 967 len = s->s_sect_len; 968 if (old_len == -1) { 969 s->s_rec_off = s->s_sect_len = 0; 970 SBUF_CLEARFLAG(s, SBUF_INSECTION); 971 } else { 972 s->s_sect_len += old_len; 973 } 974 if (s->s_error != 0) 975 return (-1); 976 return (len); 977 } 978