---
name: "sbuf"
section: "9freebsd"
platform: "linux"
package: "freebsd-manpages"
version: "12.2-2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/sbuf/9freebsd"
---

# sbuf(9freebsd)

safe string composition

## NAME

**sbuf**, **sbuf\_new**, **sbuf\_new\_auto**, **sbuf\_new\_for\_sysctl**, **sbuf\_clear**, **sbuf\_get\_flags**, **sbuf\_set\_flags**, **sbuf\_clear\_flags**, **sbuf\_setpos**, **sbuf\_bcat**, **sbuf\_bcopyin**, **sbuf\_bcpy**, **sbuf\_cat**, **sbuf\_copyin**, **sbuf\_cpy**, **sbuf\_printf**, **sbuf\_vprintf**, **sbuf\_putc**, **sbuf\_set\_drain**, **sbuf\_trim**, **sbuf\_error**, **sbuf\_finish**, **sbuf\_data**, **sbuf\_len**, **sbuf\_done**, **sbuf\_delete**, **sbuf\_start\_section**, **sbuf\_end\_section**, **sbuf\_hexdump**, **sbuf\_putbuf** – safe string composition

## SYNOPSIS

**#include \<sys/types.h\>**

**#include \<sys/sbuf.h\>**

*typedef int* (*sbuf\_drain\_func*) (*void \*arg,* *const char \*data,* *int len*);\

*struct* *sbuf* *\**\

**sbuf\_new**(*struct sbuf \*s*, *char \*buf*, *int length*, *int flags*);

*struct* *sbuf* *\**\

**sbuf\_new\_auto**(*void*);

*void*\

**sbuf\_clear**(*struct sbuf \*s*);

*int*\

**sbuf\_get\_flags**(*struct sbuf \*s*);

*void*\

**sbuf\_set\_flags**(*struct sbuf \*s*, *int flags*);

*void*\

**sbuf\_clear\_flags**(*struct sbuf \*s*, *int flags*);

*int*\

**sbuf\_setpos**(*struct sbuf \*s*, *int pos*);

*int*\

**sbuf\_bcat**(*struct sbuf \*s*, *const void \*buf*, *size\_t len*);

*int*\

**sbuf\_bcpy**(*struct sbuf \*s*, *const void \*buf*, *size\_t len*);

*int*\

**sbuf\_cat**(*struct sbuf \*s*, *const char \*str*);

*int*\

**sbuf\_cpy**(*struct sbuf \*s*, *const char \*str*);

*int*\

**sbuf\_printf**(*struct sbuf \*s*, *const char \*fmt*, *...*);

*int*\

**sbuf\_vprintf**(*struct sbuf \*s*, *const char \*fmt*, *va\_list ap*);

*int*\

**sbuf\_putc**(*struct sbuf \*s*, *int c*);

*void*\

**sbuf\_set\_drain**(*struct sbuf \*s*, *sbuf\_drain\_func \*func*, *void \*arg*);

*int*\

**sbuf\_trim**(*struct sbuf \*s*);

*int*\

**sbuf\_error**(*struct sbuf \*s*);

*int*\

**sbuf\_finish**(*struct sbuf \*s*);

*char* *\**\

**sbuf\_data**(*struct sbuf \*s*);

*ssize\_t*\

**sbuf\_len**(*struct sbuf \*s*);

*int*\

**sbuf\_done**(*struct sbuf \*s*);

*void*\

**sbuf\_delete**(*struct sbuf \*s*);

*void*\

**sbuf\_start\_section**(*struct sbuf \*s*, *ssize\_t \*old\_lenp*);

*ssize\_t*\

**sbuf\_end\_section**(*struct sbuf \*s*, *ssize\_t old\_len*, *size\_t pad*, *int c*);

*void*\

**sbuf\_hexdump**(*struct sbuf \*sb*, *void \*ptr*, *int length*, *const char \*hdr*, *int flags*);

*void*\

**sbuf\_putbuf**(*struct sbuf \*s*);

**#ifdef \_KERNEL**

**#include \<sys/types.h\>**

**#include \<sys/sbuf.h\>**

*int*\

**sbuf\_bcopyin**(*struct sbuf \*s*, *const void \*uaddr*, *size\_t len*);

*int*\

**sbuf\_copyin**(*struct sbuf \*s*, *const void \*uaddr*, *size\_t len*);

**#include \<sys/sysctl.h\>**

*struct* *sbuf* *\**\

**sbuf\_new\_for\_sysctl**(*struct sbuf \*s*, *char \*buf*, *int length*, *struct sysctl\_req \*req*);

**#endif /\* \_KERNEL \*/**

## DESCRIPTION

The **sbuf** family of functions allows one to safely allocate, compose and release strings in kernel or user space.

Instead of arrays of characters, these functions operate on structures called *sbufs*, defined in ⟨sys/sbuf.h⟩.

Any errors encountered during the allocation or composition of the string will be latched in the data structure, making a single error test at the end of the composition sufficient to determine success or failure of the entire process.

The **sbuf\_new**() function initializes the *sbuf* pointed to by its first argument. If that pointer is NULL, **sbuf\_new**() allocates a *struct* *sbuf* using [malloc(9)](/malloc/9.md). The *buf* argument is a pointer to a buffer in which to store the actual string; if it is NULL, **sbuf\_new**() will allocate one using [malloc(9)](/malloc/9.md). The *length* is the initial size of the storage buffer. The fourth argument, *flags*, may be comprised of the following flags:

- SBUF\_FIXEDLEN

  The storage buffer is fixed at its initial size. Attempting to extend the sbuf beyond this size results in an overflow condition.

- SBUF\_AUTOEXTEND

  This indicates that the storage buffer may be extended as necessary, so long as resources allow, to hold additional data.

- SBUF\_INCLUDENUL

  This causes the final nulterm byte to be counted in the length of the data.

- SBUF\_DRAINTOEOR

  Treat top-level sections started with **sbuf\_start\_section**() as a record boundary marker that will be used during drain operations to avoid records being split. If a record grows sufficiently large such that it fills the *sbuf* and therefore cannot be drained without being split, an error of EDEADLK is set.

Note that if *buf* is not NULL, it must point to an array of at least *length* characters. The result of accessing that array directly while it is in use by the sbuf is undefined.

The **sbuf\_new\_auto**() function is a shortcut for creating a completely dynamic **sbuf**. It is the equivalent of calling **sbuf\_new**() with values NULL, NULL, 0, and SBUF\_AUTOEXTEND.

The **sbuf\_new\_for\_sysctl**() function will set up an sbuf with a drain function to use **SYSCTL\_OUT**() when the internal buffer fills. Note that if the various functions which append to an sbuf are used while a non-sleepable lock is held, the user buffer should be wired using **sysctl\_wire\_old\_buffer**().

The **sbuf\_delete**() function clears the *sbuf* and frees any memory allocated for it. There must be a call to **sbuf\_delete**() for every call to **sbuf\_new**(). Any attempt to access the sbuf after it has been deleted will fail.

The **sbuf\_clear**() function invalidates the contents of the *sbuf* and resets its position to zero.

The **sbuf\_get\_flags**() function returns the current user flags. The **sbuf\_set\_flags**() and **sbuf\_get\_flags**() functions set or clear one or more user flags, respectively. The user flags are described under the **sbuf\_new**() function.

The **sbuf\_setpos**() function sets the *sbuf*'s end position to *pos*, which is a value between zero and the current position in the buffer. It can only truncate the sbuf to the new position.

The **sbuf\_bcat**() function appends the first *len* bytes from the buffer *buf* to the *sbuf*.

The **sbuf\_bcopyin**() function copies *len* bytes from the specified userland address into the *sbuf*.

The **sbuf\_bcpy**() function replaces the contents of the *sbuf* with the first *len* bytes from the buffer *buf*.

The **sbuf\_cat**() function appends the NUL-terminated string *str* to the *sbuf* at the current position.

The **sbuf\_set\_drain**() function sets a drain function *func* for the *sbuf*, and records a pointer *arg* to be passed to the drain on callback. The drain function cannot be changed while *sbuf\_len* is non-zero.

The registered drain function *sbuf\_drain\_func* will be called with the argument *arg* provided to **sbuf\_set\_drain**(), a pointer *data* to a byte string that is the contents of the sbuf, and the length *len* of the data. If the drain function exists, it will be called when the sbuf internal buffer is full, or on behalf of **sbuf\_finish**(). The drain function may drain some or all of the data, but must drain at least 1 byte. The return value from the drain function, if positive, indicates how many bytes were drained. If negative, the return value indicates the negative error code which will be returned from this or a later call to **sbuf\_finish**(). The returned drained length cannot be zero. To do unbuffered draining, initialize the sbuf with a two-byte buffer. The drain will be called for every byte added to the sbuf. The **sbuf\_bcopyin**(), **sbuf\_copyin**(), **sbuf\_trim**(), and **sbuf\_data**() functions cannot be used on an sbuf with a drain.

The **sbuf\_copyin**() function copies a NUL-terminated string from the specified userland address into the *sbuf*. If the *len* argument is non-zero, no more than *len* characters (not counting the terminating NUL) are copied; otherwise the entire string, or as much of it as can fit in the *sbuf*, is copied.

The **sbuf\_cpy**() function replaces the contents of the *sbuf* with those of the NUL-terminated string *str*. This is equivalent to calling **sbuf\_cat**() with a fresh *sbuf* or one which position has been reset to zero with **sbuf\_clear**() or **sbuf\_setpos**().

The **sbuf\_printf**() function formats its arguments according to the format string pointed to by *fmt* and appends the resulting string to the *sbuf* at the current position.

The **sbuf\_vprintf**() function behaves the same as **sbuf\_printf**() except that the arguments are obtained from the variable-length argument list *ap*.

The **sbuf\_putc**() function appends the character *c* to the *sbuf* at the current position.

The **sbuf\_trim**() function removes trailing whitespace from the *sbuf*.

The **sbuf\_error**() function returns any error value that the *sbuf* may have accumulated, either from the drain function, or ENOMEM if the *sbuf* overflowed. This function is generally not needed and instead the error code from **sbuf\_finish**() is the preferred way to discover whether an sbuf had an error.

The **sbuf\_finish**() function will call the attached drain function if one exists until all the data in the *sbuf* is flushed. If there is no attached drain, **sbuf\_finish**() NUL-terminates the *sbuf*. In either case it marks the *sbuf* as finished, which means that it may no longer be modified using **sbuf\_setpos**(), **sbuf\_cat**(), **sbuf\_cpy**(), **sbuf\_printf**() or **sbuf\_putc**(), until **sbuf\_clear**() is used to reset the sbuf.

The **sbuf\_data**() function returns the actual string; **sbuf\_data**() only works on a finished *sbuf*. The **sbuf\_len**() function returns the length of the string. For an *sbuf* with an attached drain, **sbuf\_len**() returns the length of the un-drained data. **sbuf\_done**() returns non-zero if the *sbuf* is finished.

The **sbuf\_start\_section**() and **sbuf\_end\_section**() functions may be used for automatic section alignment. The arguments *pad* and *c* specify the padding size and a character used for padding. The arguments *old\_lenp* and *old\_len* are to save and restore the current section length when nested sections are used. For the top level section NULL and -1 can be specified for *old\_lenp* and *old\_len* respectively.

The **sbuf\_hexdump**() function prints an array of bytes to the supplied sbuf, along with an ASCII representation of the bytes if possible. See the [hexdump(3)](/hexdump/3.md) man page for more details on the interface.

The **sbuf\_putbuf**() function printfs the sbuf to stdout if in userland, and to the console and log if in the kernel. It does not drain the buffer or update any pointers.

## NOTES

If an operation caused an *sbuf* to overflow, most subsequent operations on it will fail until the *sbuf* is finished using **sbuf\_finish**() or reset using **sbuf\_clear**(), or its position is reset to a value between 0 and one less than the size of its storage buffer using **sbuf\_setpos**(), or it is reinitialized to a sufficiently short string using **sbuf\_cpy**().

Drains in user-space will not always function as indicated. While the drain function will be called immediately on overflow from the *sbuf\_putc*, *sbuf\_bcat*, *sbuf\_cat* functions, *sbuf\_printf* and *sbuf\_vprintf* currently have no way to determine whether there will be an overflow until after it occurs, and cannot do a partial expansion of the format string. Thus when using libsbuf the buffer may be extended to allow completion of a single printf call, even though a drain is attached.

## RETURN VALUES

The **sbuf\_new**() function returns NULL if it failed to allocate a storage buffer, and a pointer to the new *sbuf* otherwise.

The **sbuf\_setpos**() function returns -1 if *pos* was invalid, and zero otherwise.

The **sbuf\_bcat**(), **sbuf\_cat**(), **sbuf\_cpy**(), **sbuf\_printf**(), **sbuf\_putc**(), and **sbuf\_trim**() functions all return -1 if the buffer overflowed, and zero otherwise.

The **sbuf\_error**() function returns a non-zero value if the buffer has an overflow or drain error, and zero otherwise.

The **sbuf\_len**() function returns -1 if the buffer overflowed.

The **sbuf\_copyin**() function returns -1 if copying string from userland failed, and number of bytes copied otherwise.

The **sbuf\_end\_section**() function returns the section length or -1 if the buffer has an error.

The **sbuf\_finish**(*9*) function (the kernel version) returns ENOMEM if the sbuf overflowed before being finished, or returns the error code from the drain if one is attached.

The **sbuf\_finish**(*3*) function (the userland version) will return zero for success and -1 and set errno on error.

## EXAMPLES

```
#include <sys/types.h>
#include <sys/sbuf.h>
struct sbuf *sb;
sb = sbuf_new_auto();
sbuf_cat(sb, "Customers found:\n");
TAILQ_FOREACH(foo, &foolist, list) {
	sbuf_printf(sb, "   %4d %s\n", foo->index, foo->name);
	sbuf_printf(sb, "      Address: %s\n", foo->address);
	sbuf_printf(sb, "      Zip: %s\n", foo->zipcode);
}
if (sbuf_finish(sb) != 0) /* Check for any and all errors */
	err(1, "Could not generate message");
transmit_msg(sbuf_data(sb), sbuf_len(sb));
sbuf_delete(sb);
```

## SEE ALSO

[hexdump(3)](/hexdump/3.md), [printf(3)](/printf/3.md), [strcat(3)](/strcat/3.md), [strcpy(3)](/strcpy/3.md), [copyin(9)](/copyin/9.md), [copyinstr(9)](/copyinstr/9.md), [printf(9)](/printf/9.md)

## HISTORY

The **sbuf** family of functions first appeared in FreeBSD 4.4.

## AUTHORS

The **sbuf** family of functions was designed by Poul-Henning Kamp ⟨*phk@FreeBSD.org*⟩ and implemented by Dag-Erling Smørgrav ⟨*des@FreeBSD.org*⟩. Additional improvements were suggested by Justin T. Gibbs ⟨*gibbs@FreeBSD.org*⟩. Auto-extend support added by Kelly Yancey ⟨*kbyanc@FreeBSD.org*⟩. Drain functionality added by Matthew Fleming ⟨*mdf@FreeBSD.org*⟩.

This manual page was written by Dag-Erling Smørgrav ⟨*des@FreeBSD.org*⟩.