SOL_API int
sol_buffer_insert_from_base16(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice, enum sol_decode_case decode_case)
{
char *p;
size_t new_size;
ssize_t decoded_size, r;
const size_t nul_size = nul_byte_size(buf);
int err;
SOL_NULL_CHECK(buf, -EINVAL);
SOL_INT_CHECK(pos, > buf->used, -EINVAL);
if (slice.len == 0)
return 0;
if (pos == buf->used)
return sol_buffer_append_from_base16(buf, slice, decode_case);
decoded_size = sol_util_base16_calculate_decoded_len(slice);
if (decoded_size < 0)
return decoded_size;
err = sol_util_size_add(buf->used, decoded_size, &new_size);
if (err < 0)
return err;
if (nul_size) {
err = sol_util_size_add(new_size, nul_size, &new_size);
if (err < 0)
return err;
}
err = sol_buffer_ensure(buf, new_size);
if (err < 0)
return err;
p = sol_buffer_at(buf, pos);
memmove(p + decoded_size, p, buf->used - pos);
r = sol_util_base16_decode(p, decoded_size, slice, decode_case);
if (r != decoded_size) {
memmove(p, p + decoded_size, buf->used - pos);
if (nul_size)
sol_buffer_ensure_nul_byte(buf);
if (r < 0)
return r;
else
return -EINVAL;
}
buf->used += decoded_size;
if (nul_size)
return sol_buffer_ensure_nul_byte(buf);
return 0;
}
SOL_API int
sol_buffer_insert_as_base64(struct sol_buffer *buf, size_t pos, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)])
{
char *p;
size_t new_size;
ssize_t encoded_size, r;
const size_t nul_size = nul_byte_size(buf);
int err;
SOL_NULL_CHECK(buf, -EINVAL);
SOL_INT_CHECK(pos, > buf->used, -EINVAL);
if (slice.len == 0)
return 0;
if (pos == buf->used)
return sol_buffer_append_as_base64(buf, slice, base64_map);
encoded_size = sol_util_base64_calculate_encoded_len(slice, base64_map);
if (encoded_size < 0)
return encoded_size;
err = sol_util_size_add(buf->used, encoded_size, &new_size);
if (err < 0)
return err;
if (nul_size) {
err = sol_util_size_add(new_size, nul_size, &new_size);
if (err < 0)
return err;
}
err = sol_buffer_ensure(buf, new_size);
if (err < 0)
return err;
p = sol_buffer_at(buf, pos);
memmove(p + encoded_size, p, buf->used - pos);
r = sol_util_base64_encode(p, encoded_size, slice, base64_map);
if (r != encoded_size) {
memmove(p, p + encoded_size, buf->used - pos);
if (nul_size)
sol_buffer_ensure_nul_byte(buf);
if (r < 0)
return r;
else
return -EINVAL;
}
buf->used += encoded_size;
if (nul_size)
return sol_buffer_ensure_nul_byte(buf);
return 0;
}
SOL_API int
sol_buffer_append_as_base16(struct sol_buffer *buf, const struct sol_str_slice slice, bool uppercase)
{
char *p;
size_t new_size;
ssize_t encoded_size, r;
const size_t nul_size = nul_byte_size(buf);
int err;
SOL_NULL_CHECK(buf, -EINVAL);
if (slice.len == 0)
return 0;
encoded_size = sol_util_base16_calculate_encoded_len(slice);
if (encoded_size < 0)
return encoded_size;
err = sol_util_size_add(buf->used, encoded_size, &new_size);
if (err < 0)
return err;
if (nul_size) {
err = sol_util_size_add(new_size, nul_size, &new_size);
if (err < 0)
return err;
}
err = sol_buffer_ensure(buf, new_size);
if (err < 0)
return err;
p = sol_buffer_at_end(buf);
r = sol_util_base16_encode(p, encoded_size, slice, uppercase);
if (r != encoded_size) {
if (nul_size)
sol_buffer_ensure_nul_byte(buf);
if (r < 0)
return r;
else
return -EINVAL;
}
buf->used += encoded_size;
if (nul_size)
return sol_buffer_ensure_nul_byte(buf);
return 0;
}
SOL_API int
sol_buffer_append_from_base64(struct sol_buffer *buf, const struct sol_str_slice slice, const char base64_map[SOL_STATIC_ARRAY_SIZE(65)])
{
char *p;
size_t new_size;
ssize_t decoded_size, r;
const size_t nul_size = nul_byte_size(buf);
int err;
SOL_NULL_CHECK(buf, -EINVAL);
if (slice.len == 0)
return 0;
decoded_size = sol_util_base64_calculate_decoded_len(slice, base64_map);
if (decoded_size < 0)
return decoded_size;
err = sol_util_size_add(buf->used, decoded_size, &new_size);
if (err < 0)
return err;
if (nul_size) {
err = sol_util_size_add(new_size, nul_size, &new_size);
if (err < 0)
return err;
}
err = sol_buffer_ensure(buf, new_size);
if (err < 0)
return err;
p = sol_buffer_at_end(buf);
r = sol_util_base64_decode(p, decoded_size, slice, base64_map);
if (r != decoded_size) {
if (nul_size)
sol_buffer_ensure_nul_byte(buf);
if (r < 0)
return r;
else
return -EINVAL;
}
buf->used += decoded_size;
if (nul_size)
return sol_buffer_ensure_nul_byte(buf);
return 0;
}
SOL_API int
sol_buffer_insert_char(struct sol_buffer *buf, size_t pos, const char c)
{
char *p;
size_t new_size;
int err;
SOL_NULL_CHECK(buf, -EINVAL);
SOL_INT_CHECK(pos, > buf->used, -EINVAL);
if (pos == buf->used)
return sol_buffer_append_char(buf, c);
err = sol_util_size_add(buf->used, 1, &new_size);
if (err < 0)
return err;
err = sol_buffer_ensure(buf, new_size);
if (err < 0)
return err;
p = sol_buffer_at(buf, pos);
memmove(p + 1, p, buf->used - pos);
*p = c;
buf->used++;
if (nul_byte_size(buf))
return sol_buffer_ensure_nul_byte(buf);
return 0;
}
SOL_API int
sol_buffer_append_char(struct sol_buffer *buf, const char c)
{
char *p;
size_t new_size;
int err;
SOL_NULL_CHECK(buf, -EINVAL);
err = sol_util_size_add(buf->used, 1, &new_size);
if (err < 0)
return err;
err = sol_buffer_ensure(buf, new_size);
if (err < 0)
return err;
p = sol_buffer_at_end(buf);
*p = c;
buf->used++;
if (nul_byte_size(buf))
return sol_buffer_ensure_nul_byte(buf);
return 0;
}
SOL_API int
sol_buffer_set_char_at(struct sol_buffer *buf, size_t pos, char c)
{
int err;
const size_t nul_size = nul_byte_size(buf);
SOL_NULL_CHECK(buf, -EINVAL);
if (buf->used < pos) {
return -EINVAL;
}
/* Extra room for the ending NUL-byte. */
if (1 >= SIZE_MAX - nul_size - pos)
return -EOVERFLOW;
err = sol_buffer_ensure(buf, pos + 1 + nul_size);
if (err < 0)
return err;
*((char *)buf->data + pos) = c;
if (pos + 1 >= buf->used)
buf->used = pos + 1;
if (nul_byte_size(buf))
return sol_buffer_ensure_nul_byte(buf);
return 0;
}
SOL_API ssize_t
sol_util_fill_buffer(int fd, struct sol_buffer *buffer, size_t size)
{
size_t bytes_read = 0, s;
unsigned int retry = 0;
ssize_t ret;
SOL_NULL_CHECK(buffer, -EINVAL);
if (sol_util_size_add(buffer->used, size, &s) < 0)
return -EOVERFLOW;
ret = sol_buffer_ensure(buffer, s);
if (ret < 0)
return ret;
do {
ret = read(fd, (char *)buffer->data + buffer->used + bytes_read,
size - bytes_read);
if (ret < 0) {
retry++;
if (retry >= SOL_UTIL_MAX_READ_ATTEMPTS) {
if (errno == EINTR || errno == EAGAIN) {
ret = 0; /* if we exceed maximum attempts, don't return error */
}
break;
}
if (errno == EINTR || errno == EAGAIN)
continue;
else
break;
} else if (ret == 0) {
retry++;
if (retry >= SOL_UTIL_MAX_READ_ATTEMPTS)
break;
continue;
}
retry = 0; //We only count consecutive failures
bytes_read += (size_t)ret;
} while (bytes_read < size);
buffer->used += bytes_read;
if (ret >= 0)
ret = bytes_read;
if (SOL_BUFFER_NEEDS_NUL_BYTE(buffer)) {
int err;
err = sol_buffer_ensure_nul_byte(buffer);
SOL_INT_CHECK(err, < 0, err);
}
return ret;
}
char *
sol_util_load_file_fd_string(int fd, size_t *size)
{
int saved_errno;
size_t size_read;
char *data = NULL;
struct sol_buffer *buffer = NULL;
buffer = sol_util_load_file_raw(fd);
if (!buffer) {
data = strdup("");
size_read = 1;
} else {
buffer->flags = SOL_BUFFER_FLAGS_DEFAULT;
if (sol_buffer_ensure_nul_byte(buffer) < 0)
goto err;
data = sol_buffer_steal(buffer, &size_read);
if (!data)
goto err;
}
sol_buffer_free(buffer);
if (size)
*size = size_read;
return data;
err:
saved_errno = errno;
free(data);
sol_buffer_free(buffer);
errno = saved_errno;
if (size)
*size = 0;
return NULL;
}
