/*
* 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);
}
/*
* 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);
KASSERT(s->s_drain_func == NULL,
("Nonsensical copyin to sbuf %p with a drain", s));
if (s->s_error != 0)
return (-1);
if (len == 0)
len = SBUF_FREESPACE(s); /* XXX return 0? */
if (len > SBUF_FREESPACE(s)) {
sbuf_extend(s, len);
if (SBUF_FREESPACE(s) < len)
len = SBUF_FREESPACE(s);
}
switch (copyinstr(uaddr, s->s_buf + s->s_len, len + 1, &done)) {
case ENAMETOOLONG:
s->s_error = ENOMEM;
/* fall through */
case 0:
s->s_len += done - 1;
if (SBUF_ISSECTION(s))
s->s_sect_len += done - 1;
break;
default:
return (-1); /* XXX */
}
return (done);
}
/*
* Append a byte to an sbuf. This is the core function for appending
* to an sbuf and is the main place that deals with extending the
* buffer and marking overflow.
*/
static void
sbuf_put_byte(struct sbuf *s, int c)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (s->s_error != 0)
return;
if (SBUF_FREESPACE(s) <= 0) {
/*
* If there is a drain, use it, otherwise extend the
* buffer.
*/
if (s->s_drain_func != NULL)
(void)sbuf_drain(s);
else if (sbuf_extend(s, 1) < 0)
s->s_error = ENOMEM;
if (s->s_error != 0)
return;
}
s->s_buf[s->s_len++] = c;
if (SBUF_ISSECTION(s))
s->s_sect_len++;
}
/*
* Append bytes to an sbuf. This is the core function for appending
* to an sbuf and is the main place that deals with extending the
* buffer and marking overflow.
*/
static void
sbuf_put_bytes(struct sbuf *s, const char *buf, size_t len)
{
size_t n;
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (s->s_error != 0)
return;
while (len > 0) {
if (SBUF_FREESPACE(s) <= 0) {
/*
* If there is a drain, use it, otherwise extend the
* buffer.
*/
if (s->s_drain_func != NULL)
(void)sbuf_drain(s);
else if (sbuf_extend(s, len > INT_MAX ? INT_MAX : len)
< 0)
s->s_error = ENOMEM;
if (s->s_error != 0)
return;
}
n = SBUF_FREESPACE(s);
if (len < n)
n = len;
memcpy(&s->s_buf[s->s_len], buf, n);
s->s_len += n;
if (SBUF_ISSECTION(s))
s->s_sect_len += n;
len -= n;
buf += n;
}
}
void sbuf_mem(struct sbuf *sbuf, char *s, int len)
{
if (sbuf->s_n + len + 1 >= sbuf->s_sz)
sbuf_extend(sbuf, NEXTSZ(sbuf->s_sz, len + 1));
memcpy(sbuf->s + sbuf->s_n, s, len);
sbuf->s_n += len;
}
char *sbuf_buf(struct sbuf *sb)
{
if (!sb->s)
sbuf_extend(sb, 1);
sb->s[sb->s_n] = '\0';
return sb->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);
}
/*
* 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);
}
/*
* Copy a byte string from userland into an sbuf.
*/
int
sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
if (SBUF_HASOVERFLOWED(s))
return (-1);
if (len == 0)
return (0);
if (len > SBUF_FREESPACE(s)) {
sbuf_extend(s, len - SBUF_FREESPACE(s));
len = min(len, SBUF_FREESPACE(s));
}
if (copyin(uaddr, s->s_buf + s->s_len, len) != 0)
return (-1);
s->s_len += len;
return (0);
}
/*
* Copy a byte string from userland into an sbuf.
*/
int
sbuf_bcopyin(struct sbuf *s, const void *uaddr, size_t len)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
KASSERT(s->s_drain_func == NULL,
("Nonsensical copyin to sbuf %p with a drain", s));
if (s->s_error != 0)
return (-1);
if (len == 0)
return (0);
if (len > SBUF_FREESPACE(s)) {
sbuf_extend(s, len - SBUF_FREESPACE(s));
if (SBUF_FREESPACE(s) < len)
len = SBUF_FREESPACE(s);
}
if (copyin(uaddr, s->s_buf + s->s_len, len) != 0)
return (-1);
s->s_len += len;
return (0);
}
/*
* Append a non-NUL character to an sbuf. This prototype signature is
* suitable for use with kvcprintf(9).
*/
static void
sbuf_putc_func(int c, void *arg)
{
if (c != '\0')
sbuf_put_byte(arg, c);
}
int
sbuf_vprintf(struct sbuf *s, const char *fmt, __va_list ap)
{
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
KASSERT(fmt != NULL,
("%s called with a NULL format string", __func__));
(void)kvcprintf(fmt, sbuf_putc_func, s, 10, ap);
if (s->s_error != 0)
return (-1);
return (0);
}
#else /* !_KERNEL */
int
sbuf_vprintf(struct sbuf *s, const char *fmt, __va_list ap)
{
__va_list ap_copy;
int error, len;
assert_sbuf_integrity(s);
assert_sbuf_state(s, 0);
KASSERT(fmt != NULL,
("%s called with a NULL format string", __func__));
if (s->s_error != 0)
return (-1);
/*
* For the moment, there is no way to get vsnprintf(3) to hand
* back a character at a time, to push everything into
* sbuf_putc_func() as was done for the kernel.
*
* In userspace, while drains are useful, there's generally
* not a problem attempting to malloc(3) on out of space. So
* expand a userland sbuf if there is not enough room for the
* data produced by sbuf_[v]printf(3).
*/
error = 0;
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);
if (SBUF_FREESPACE(s) >= len)
break;
/* Cannot print with the current available space. */
if (s->s_drain_func != NULL && s->s_len > 0)
error = sbuf_drain(s);
else
error = sbuf_extend(s, len - SBUF_FREESPACE(s));
} while (error == 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, so don't over-increment s_len.
*/
if (SBUF_FREESPACE(s) < len)
len = SBUF_FREESPACE(s);
s->s_len += len;
if (SBUF_ISSECTION(s))
s->s_sect_len += len;
if (!SBUF_HASROOM(s) && !SBUF_CANEXTEND(s))
s->s_error = ENOMEM;
KASSERT(s->s_len < s->s_size,
("wrote past end of sbuf (%d >= %d)", s->s_len, s->s_size));
if (s->s_error != 0)
return (-1);
return (0);
}
void sbuf_chr(struct sbuf *sbuf, int c)
{
if (sbuf->s_n + 2 >= sbuf->s_sz)
sbuf_extend(sbuf, NEXTSZ(sbuf->s_sz, 1));
sbuf->s[sbuf->s_n++] = c;
}
