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