| // SPDX-License-Identifier: GPL-2.0+ |
| /* |
| * Utility functions for the 'fsverity' program |
| * |
| * Copyright (C) 2018 Google LLC |
| * |
| * Written by Eric Biggers. |
| */ |
| |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <limits.h> |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| |
| #include "util.h" |
| |
| /* ========== Memory allocation ========== */ |
| |
| void *xmalloc(size_t size) |
| { |
| void *p = malloc(size); |
| |
| if (!p) |
| fatal_error("out of memory"); |
| return p; |
| } |
| |
| void *xzalloc(size_t size) |
| { |
| return memset(xmalloc(size), 0, size); |
| } |
| |
| void *xmemdup(const void *mem, size_t size) |
| { |
| return memcpy(xmalloc(size), mem, size); |
| } |
| |
| char *xstrdup(const char *s) |
| { |
| return xmemdup(s, strlen(s) + 1); |
| } |
| |
| char *xasprintf(const char *format, ...) |
| { |
| va_list va1, va2; |
| int size; |
| char *s; |
| |
| va_start(va1, format); |
| |
| va_copy(va2, va1); |
| size = vsnprintf(NULL, 0, format, va2); |
| va_end(va2); |
| |
| ASSERT(size >= 0); |
| s = xmalloc(size + 1); |
| vsprintf(s, format, va1); |
| |
| va_end(va1); |
| return s; |
| } |
| |
| /* ========== Error messages and assertions ========== */ |
| |
| void do_error_msg(const char *format, va_list va, int err) |
| { |
| fputs("ERROR: ", stderr); |
| vfprintf(stderr, format, va); |
| if (err) |
| fprintf(stderr, ": %s", strerror(err)); |
| putc('\n', stderr); |
| } |
| |
| void error_msg(const char *format, ...) |
| { |
| va_list va; |
| |
| va_start(va, format); |
| do_error_msg(format, va, 0); |
| va_end(va); |
| } |
| |
| void error_msg_errno(const char *format, ...) |
| { |
| va_list va; |
| |
| va_start(va, format); |
| do_error_msg(format, va, errno); |
| va_end(va); |
| } |
| |
| __noreturn void fatal_error(const char *format, ...) |
| { |
| va_list va; |
| |
| va_start(va, format); |
| do_error_msg(format, va, 0); |
| va_end(va); |
| abort(); |
| } |
| |
| __noreturn void assertion_failed(const char *expr, const char *file, int line) |
| { |
| fatal_error("Assertion failed: %s at %s:%d", expr, file, line); |
| } |
| |
| /* ========== File utilities ========== */ |
| |
| bool open_file(struct filedes *file, const char *filename, int flags, int mode) |
| { |
| file->fd = open(filename, flags, mode); |
| if (file->fd < 0) { |
| error_msg_errno("can't open '%s' for %s", filename, |
| (flags & O_ACCMODE) == O_RDONLY ? "reading" : |
| (flags & O_ACCMODE) == O_WRONLY ? "writing" : |
| "reading and writing"); |
| return false; |
| } |
| file->autodelete = false; |
| file->name = xstrdup(filename); |
| file->pos = 0; |
| return true; |
| } |
| |
| bool open_tempfile(struct filedes *file) |
| { |
| const char *tmpdir = getenv("TMPDIR") ?: P_tmpdir; |
| char *name = xasprintf("%s/fsverity-XXXXXX", tmpdir); |
| |
| file->fd = mkstemp(name); |
| if (file->fd < 0) { |
| error_msg_errno("can't create temporary file"); |
| free(name); |
| return false; |
| } |
| file->autodelete = true; |
| file->name = name; |
| file->pos = 0; |
| return true; |
| } |
| |
| bool get_file_size(struct filedes *file, u64 *size_ret) |
| { |
| struct stat stbuf; |
| |
| if (fstat(file->fd, &stbuf) != 0) { |
| error_msg_errno("can't stat file '%s'", file->name); |
| return false; |
| } |
| *size_ret = stbuf.st_size; |
| return true; |
| } |
| |
| bool filedes_seek(struct filedes *file, u64 pos, int whence) |
| { |
| off_t res; |
| |
| res = lseek(file->fd, pos, whence); |
| if (res < 0) { |
| error_msg_errno("seek error on '%s'", file->name); |
| return false; |
| } |
| file->pos = res; |
| return true; |
| } |
| |
| bool full_read(struct filedes *file, void *buf, size_t count) |
| { |
| while (count) { |
| int n = read(file->fd, buf, min(count, INT_MAX)); |
| |
| if (n < 0) { |
| error_msg_errno("reading from '%s'", file->name); |
| return false; |
| } |
| if (n == 0) { |
| error_msg("unexpected end-of-file on '%s'", file->name); |
| return false; |
| } |
| buf += n; |
| count -= n; |
| file->pos += n; |
| } |
| return true; |
| } |
| |
| bool full_pread(struct filedes *file, void *buf, size_t count, u64 offset) |
| { |
| while (count) { |
| int n = pread(file->fd, buf, min(count, INT_MAX), offset); |
| |
| if (n < 0) { |
| error_msg_errno("reading from '%s'", file->name); |
| return false; |
| } |
| if (n == 0) { |
| error_msg("unexpected end-of-file on '%s'", file->name); |
| return false; |
| } |
| buf += n; |
| count -= n; |
| offset += n; |
| } |
| return true; |
| } |
| |
| bool full_write(struct filedes *file, const void *buf, size_t count) |
| { |
| while (count) { |
| int n = write(file->fd, buf, min(count, INT_MAX)); |
| |
| if (n < 0) { |
| error_msg_errno("writing to '%s'", file->name); |
| return false; |
| } |
| buf += n; |
| count -= n; |
| file->pos += n; |
| } |
| return true; |
| } |
| |
| bool full_pwrite(struct filedes *file, const void *buf, size_t count, |
| u64 offset) |
| { |
| while (count) { |
| int n = pwrite(file->fd, buf, min(count, INT_MAX), offset); |
| |
| if (n < 0) { |
| error_msg_errno("writing to '%s'", file->name); |
| return false; |
| } |
| buf += n; |
| count -= n; |
| offset += n; |
| } |
| return true; |
| } |
| |
| /* Copy 'count' bytes of data from 'src' to 'dst' */ |
| bool copy_file_data(struct filedes *src, struct filedes *dst, u64 count) |
| { |
| char buf[4096]; |
| |
| while (count) { |
| size_t n = min(count, sizeof(buf)); |
| |
| if (!full_read(src, buf, n)) |
| return false; |
| if (!full_write(dst, buf, n)) |
| return false; |
| count -= n; |
| } |
| return true; |
| } |
| |
| /* Write 'count' bytes of zeroes to the file */ |
| bool write_zeroes(struct filedes *file, u64 count) |
| { |
| char buf[4096]; |
| |
| memset(buf, 0, min(count, sizeof(buf))); |
| |
| while (count) { |
| size_t n = min(count, sizeof(buf)); |
| |
| if (!full_write(file, buf, n)) |
| return false; |
| count -= n; |
| } |
| return true; |
| } |
| |
| bool filedes_close(struct filedes *file) |
| { |
| int res; |
| |
| if (file->fd < 0) |
| return true; |
| res = close(file->fd); |
| if (res != 0) |
| error_msg_errno("closing '%s'", file->name); |
| if (file->autodelete) |
| (void)unlink(file->name); |
| file->fd = -1; |
| free(file->name); |
| file->name = NULL; |
| return res == 0; |
| } |
| |
| /* ========== String utilities ========== */ |
| |
| static int hex2bin_char(char c) |
| { |
| if (c >= '0' && c <= '9') |
| return c - '0'; |
| if (c >= 'a' && c <= 'f') |
| return 10 + (c - 'a'); |
| if (c >= 'A' && c <= 'F') |
| return 10 + (c - 'A'); |
| return -1; |
| } |
| |
| bool hex2bin(const char *hex, u8 *bin, size_t bin_len) |
| { |
| if (strlen(hex) != 2 * bin_len) |
| return false; |
| |
| while (bin_len--) { |
| int hi = hex2bin_char(*hex++); |
| int lo = hex2bin_char(*hex++); |
| |
| if (hi < 0 || lo < 0) |
| return false; |
| *bin++ = (hi << 4) | lo; |
| } |
| return true; |
| } |
| |
| static char bin2hex_char(u8 nibble) |
| { |
| ASSERT(nibble <= 0xf); |
| |
| if (nibble < 10) |
| return '0' + nibble; |
| return 'a' + (nibble - 10); |
| } |
| |
| void bin2hex(const u8 *bin, size_t bin_len, char *hex) |
| { |
| while (bin_len--) { |
| *hex++ = bin2hex_char(*bin >> 4); |
| *hex++ = bin2hex_char(*bin & 0xf); |
| bin++; |
| } |
| *hex = '\0'; |
| } |
| |
| void string_list_append(struct string_list *list, char *string) |
| { |
| ASSERT(list->length <= list->capacity); |
| if (list->length == list->capacity) { |
| list->capacity = (list->capacity * 2) + 4; |
| list->strings = realloc(list->strings, |
| sizeof(list->strings[0]) * |
| list->capacity); |
| if (!list->strings) |
| fatal_error("out of memory"); |
| } |
| list->strings[list->length++] = string; |
| } |
| |
| void string_list_destroy(struct string_list *list) |
| { |
| free(list->strings); |
| memset(list, 0, sizeof(*list)); |
| } |