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; }