/*
* Initialize an sbuf.
* If buf is non-NULL, it points to a static or already-allocated string
* big enough to hold at least length characters.
*/
struct sbuf *
sbuf_new(struct sbuf *s, char *buf, int length, int flags)
{
KASSERT(length >= 0);
KASSERT((flags & ~SBUF_USRFLAGMSK) == 0);
flags &= SBUF_USRFLAGMSK;
if (s == NULL) {
s = (struct sbuf *)SBMALLOC(sizeof *s);
if (s == NULL)
return (NULL);
bzero(s, sizeof *s);
s->s_flags = flags;
SBUF_SETFLAG(s, SBUF_DYNSTRUCT);
} else {
bzero(s, sizeof *s);
s->s_flags = flags;
}
s->s_size = length;
if (buf) {
s->s_buf = buf;
return (s);
}
if (flags & SBUF_AUTOEXTEND)
s->s_size = sbuf_extendsize(s->s_size);
s->s_buf = (char *)SBMALLOC(s->s_size);
if (s->s_buf == NULL) {
if (SBUF_ISDYNSTRUCT(s))
SBFREE(s);
return (NULL);
}
SBUF_SETFLAG(s, SBUF_DYNAMIC);
return (s);
}
/*
* Initialize the internals of an sbuf.
* If buf is non-NULL, it points to a static or already-allocated string
* big enough to hold at least length characters.
*/
static struct sbuf *
sbuf_newbuf(struct sbuf *s, char *buf, int length, int flags)
{
memset(s, 0, sizeof(*s));
s->s_flags = flags;
s->s_size = length;
s->s_buf = buf;
if ((s->s_flags & SBUF_AUTOEXTEND) == 0) {
KASSERT(s->s_size >= 0,
("attempt to create a too small sbuf"));
}
if (s->s_buf != NULL)
return (s);
if ((flags & SBUF_AUTOEXTEND) != 0)
s->s_size = sbuf_extendsize(s->s_size);
s->s_buf = SBMALLOC(s->s_size);
if (s->s_buf == NULL)
return (NULL);
SBUF_SETFLAG(s, SBUF_DYNAMIC);
return (s);
}
/*
* Append a string from userland to an sbuf.
*/
int
sbuf_copyin(struct sbuf *s, const void *uaddr, size_t len)
{
size_t done;
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (SBUF_HASOVERFLOWED(s))
return (-1);
if (len == 0)
len = SBUF_FREESPACE(s); /* XXX return 0? */
if (len > SBUF_FREESPACE(s)) {
sbuf_extend(s, len);
len = min(len, SBUF_FREESPACE(s));
}
switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) {
case ENAMETOOLONG:
SBUF_SETFLAG(s, SBUF_OVERFLOWED);
/* fall through */
case 0:
s->s_len += done - 1;
break;
default:
return (-1); /* XXX */
}
return (done);
}
/*
* Finish off an sbuf.
*/
int
sbuf_finish(struct sbuf *s)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
s->s_buf[s->s_len] = '\0';
if (SBUF_NULINCLUDED(s))
s->s_len++;
if (s->s_drain_func != NULL) {
while (s->s_len > 0 && s->s_error == 0)
s->s_error = sbuf_drain(s);
}
SBUF_SETFLAG(s, SBUF_FINISHED);
#ifdef _KERNEL
return (s->s_error);
#else
if (s->s_error != 0) {
errno = s->s_error;
return (-1);
}
return (0);
#endif
}
/*
* Finish off an sbuf.
*/
void
sbuf_finish(struct sbuf *s)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
s->s_buf[s->s_len] = '\0';
SBUF_CLEARFLAG(s, SBUF_OVERFLOWED);
SBUF_SETFLAG(s, SBUF_FINISHED);
}
/*
* Initialize an sbuf.
* If buf is non-NULL, it points to a static or already-allocated string
* big enough to hold at least length characters.
*/
struct sbuf *
sbuf_new(struct sbuf *s, char *buf, int length, int flags)
{
KASSERT(length >= 0,
("attempt to create an sbuf of negative length (%d)", length));
KASSERT((flags & ~SBUF_USRFLAGMSK) == 0,
("%s called with invalid flags", __func__));
flags &= SBUF_USRFLAGMSK;
if (s == NULL) {
s = SBMALLOC(sizeof(*s));
if (s == NULL)
return (NULL);
bzero(s, sizeof(*s));
s->s_flags = flags;
SBUF_SETFLAG(s, SBUF_DYNSTRUCT);
} else {
bzero(s, sizeof(*s));
s->s_flags = flags;
}
s->s_size = length;
if (buf) {
s->s_buf = buf;
return (s);
}
if (flags & SBUF_AUTOEXTEND)
s->s_size = sbuf_extendsize(s->s_size);
s->s_buf = SBMALLOC(s->s_size);
if (s->s_buf == NULL) {
if (SBUF_ISDYNSTRUCT(s))
SBFREE(s);
return (NULL);
}
SBUF_SETFLAG(s, SBUF_DYNAMIC);
return (s);
}
/*
* Append a character to an sbuf.
*/
int
sbuf_putc(struct sbuf *s, int c)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (SBUF_HASOVERFLOWED(s))
return (-1);
if (!SBUF_HASROOM(s) && sbuf_extend(s, 1) < 0) {
SBUF_SETFLAG(s, SBUF_OVERFLOWED);
return (-1);
}
if (c != '\0')
s->s_buf[s->s_len++] = c;
return (0);
}
/*
* Format the given argument list and append the resulting string to an sbuf.
*/
int
sbuf_vprintf(struct sbuf *s, const char *fmt, va_list ap)
{
va_list ap_copy;
int len;
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
KASSERT(fmt != NULL,
("%s called with a NULL format string", __func__));
if (SBUF_HASOVERFLOWED(s))
return (-1);
do {
va_copy(ap_copy, ap);
len = vsnprintf(&s->s_buf[s->s_len], SBUF_FREESPACE(s) + 1,
fmt, ap_copy);
va_end(ap_copy);
} while (len > SBUF_FREESPACE(s) &&
sbuf_extend(s, len - SBUF_FREESPACE(s)) == 0);
/*
* s->s_len is the length of the string, without the terminating nul.
* When updating s->s_len, we must subtract 1 from the length that
* we passed into vsnprintf() because that length includes the
* terminating nul.
*
* vsnprintf() returns the amount that would have been copied,
* given sufficient space, hence the min() calculation below.
*/
s->s_len += min(len, SBUF_FREESPACE(s));
if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s))
SBUF_SETFLAG(s, SBUF_OVERFLOWED);
KASSERT(s->s_len < s->s_size,
("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
if (SBUF_HASOVERFLOWED(s))
return (-1);
return (0);
}
/*
* Start a section.
*/
void
sbuf_start_section(struct sbuf *s, ssize_t *old_lenp)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (!SBUF_ISSECTION(s)) {
KASSERT(s->s_sect_len == 0,
("s_sect_len != 0 when starting a section"));
if (old_lenp != NULL)
*old_lenp = -1;
SBUF_SETFLAG(s, SBUF_INSECTION);
} else {
KASSERT(old_lenp != NULL,
("s_sect_len should be saved when starting a subsection"));
*old_lenp = s->s_sect_len;
s->s_sect_len = 0;
}
}
/*
* Append a string to an sbuf.
*/
int
sbuf_cat(struct sbuf *s, const char *str)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (SBUF_HASOVERFLOWED(s))
return (-1);
while (*str) {
if (!SBUF_HASROOM(s) && sbuf_extend(s, strlen(str)) < 0)
break;
s->s_buf[s->s_len++] = *str++;
}
if (*str) {
SBUF_SETFLAG(s, SBUF_OVERFLOWED);
return (-1);
}
return (0);
}
/*
* Append a byte string to an sbuf.
*/
int
sbuf_bcat(struct sbuf *s, const char *str, size_t len)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (SBUF_HASOVERFLOWED(s))
return (-1);
for (; len; len--) {
if (!SBUF_HASROOM(s) && sbuf_extend(s, len) < 0)
break;
s->s_buf[s->s_len++] = *str++;
}
if (len) {
SBUF_SETFLAG(s, SBUF_OVERFLOWED);
return (-1);
}
return (0);
}
/*
* Extend an sbuf.
*/
static int
sbuf_extend(struct sbuf *s, int addlen)
{
char *newbuf;
int newsize;
if (!SBUF_CANEXTEND(s))
return (-1);
newsize = sbuf_extendsize(s->s_size + addlen);
newbuf = SBMALLOC(newsize);
if (newbuf == NULL)
return (-1);
memcpy(newbuf, s->s_buf, s->s_size);
if (SBUF_ISDYNAMIC(s))
SBFREE(s->s_buf);
else
SBUF_SETFLAG(s, SBUF_DYNAMIC);
s->s_buf = newbuf;
s->s_size = newsize;
return (0);
}
/*
* Initialize an sbuf.
* If buf is non-NULL, it points to a static or already-allocated string
* big enough to hold at least length characters.
*/
struct sbuf *
sbuf_new(struct sbuf *s, char *buf, int length, int flags)
{
KASSERT(length >= 0,
("attempt to create an sbuf of negative length (%d)", length));
KASSERT((flags & ~SBUF_USRFLAGMSK) == 0,
("%s called with invalid flags", __func__));
flags &= SBUF_USRFLAGMSK;
if (s != NULL)
return (sbuf_newbuf(s, buf, length, flags));
s = SBMALLOC(sizeof(*s));
if (s == NULL)
return (NULL);
if (sbuf_newbuf(s, buf, length, flags) == NULL) {
SBFREE(s);
return (NULL);
}
SBUF_SETFLAG(s, SBUF_DYNSTRUCT);
return (s);
}