util.c

/* See LICENSE file for copyright and license details. */
#include "util.h"

#include <libclut.h>

#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>


/**
 * Duplicate a memory segment
 * 
 * @param   src  The memory segment, must not be `NULL`
 * @param   n    The size of the memory segment, must not be zero
 * @return       The duplicate of the memory segment,
 *               `NULL` on error
 */
void *
memdup(const void *restrict src, size_t n)
{
	void *dest = malloc(n);
	if (!dest)
		return NULL;
	memcpy(dest, src, n);
	return dest;
}


/**
 * Read an entire file
 * 
 * Not cancelled by `EINTR`
 * 
 * @param   fd  The file descriptor
 * @param   n   Output for the size of the file
 * @return      The read content, plus a NUL byte at
 *              the end (not counted in `*n`)
 */
void *
nread(int fd, size_t *restrict n)
{
	size_t size = 32;
	ssize_t got;
	struct stat st;
	char *buf, *new;

	*n = 0;

	if (!fstat(fd, &st))
		size = st.st_size <= 0 ? 32 : (size_t)(st.st_size);

	buf = malloc(size + 1);
	if (!buf)
		return NULL;

	for (;;) {
		if (*n == size) {
			new = realloc(buf, (size <<= 1) + 1);
			if (!new)
				goto fail;
			buf = new;
		}

		got = read(fd, buf + *n, size - *n);
		if (got <= 0) {
			if (!got)
				break;
			if (errno == EINTR)
				continue;
			goto fail;
		}
		*n += (size_t)got;
	}

	buf[*n] = '\0';
	return buf;

fail:
	free(buf);
	return NULL;
}


/**
 * Write an entire buffer to a file
 * 
 * Not cancelled by `EINTR`
 * 
 * @param   fd   The file descriptor
 * @param   buf  The buffer which shall be written to the fail
 * @param   n    The size of the buffer
 * @return       The number of written bytes, less than `n`
 *               on error, cannot exceed `n`
 */
size_t
nwrite(int fd, const void *restrict buf, size_t n)
{
	const char *restrict bs = buf;
	ssize_t wrote;
	size_t ptr = 0;

	while (ptr < n) {
		wrote = write(fd, bs + ptr, n - ptr);
		if (wrote <= 0) {
			if (wrote < 0 && errno == EINTR)
				continue;
			return ptr;
		}
		ptr += (size_t)wrote;
	}

	return ptr;
}


/**
 * Perform a timed suspention of the process.
 * The process resumes when the timer expires,
 * or when it is interrupted.
 * 
 * @param  ms  The number of milliseconds to sleep,
 *             must be less than 1000
 */
void
msleep(unsigned ms)
{
	struct timespec ts;
	ts.tv_sec = 0;
	ts.tv_nsec = (long)ms * 1000000L;
	if (clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL) == ENOTSUP)
		nanosleep(&ts, NULL);
}


/**
 * Check whether a NUL-terminated string is encoded in UTF-8
 * 
 * @param   string  The string
 * @return          Zero if good, -1 on encoding error
 */
int
verify_utf8(const char *restrict string)
{
	static long BYTES_TO_MIN_BITS[] = {0, 0,  8, 12, 17, 22, 37};
	static long BYTES_TO_MAX_BITS[] = {0, 7, 11, 16, 21, 26, 31};
	long int bytes = 0, read_bytes = 0, bits = 0, c, character = 0;

	/*                                                      min bits  max bits
	  0.......                                                 0         7
	  110..... 10......                                        8        11
	  1110.... 10...... 10......                              12        16
	  11110... 10...... 10...... 10......                     17        21
	  111110.. 10...... 10...... 10...... 10......            22        26
	  1111110. 10...... 10...... 10...... 10...... 10......   27        31
	 */

	while ((c = (long)(*string++))) {
		if (!read_bytes) {
			/* First byte of the character. */

			if ((c & 0x80) == 0x00) {
				/* Single-byte character. */
				continue;
			}

			if ((c & 0xC0) == 0x80) {
				/* Single-byte character marked as multibyte, or
				   a non-first byte in a multibyte character. */
				return -1;
			}

			/* Multibyte character. */
			while ((c & 0x80)) {
				bytes++;
				c <<= 1;
			}
			read_bytes = 1;
			character = c & 0x7F;
			if (bytes > 6) {
				/* 31-bit characters can be encoded with 6-bytes,
				   and UTF-8 does not cover higher code points. */
				return -1;
			}
		} else {
			/* Not first byte of the character. */

			if ((c & 0xC0) != 0x80) {
				/* Beginning of new character before a
				   multibyte character has ended. */
				return -1;
			}

			character = (character << 6) | (c & 0x7F);

			if (++read_bytes < bytes) {
				/* Not at last byte yet. */
				continue;
			}

			/* Check that the character is not unnecessarily long. */
			while (character) {
				character >>= 1, bits++;
			}
			if ((bits < BYTES_TO_MIN_BITS[bytes]) || (BYTES_TO_MAX_BITS[bytes] < bits)) {
				return -1;
			}

			read_bytes = bytes = bits = 0;
		}
	}

	/* Make sure we did not stop at the middle of a multibyte character. */
	return !read_bytes ? 0 : -1;
}


/**
 * Make identity mapping ramps
 * 
 * @param   ramps   Output parameter for the ramps
 * @param   output  The output for which the ramps shall be configured
 * @return          Zero on success, -1 on error
 */
int
make_plain_ramps(union gamma_ramps *restrict ramps, struct output *restrict output)
{
	COPY_RAMP_SIZES(&ramps->u8, output);
	switch (output->depth) {
	case 8:
		if (libgamma_gamma_ramps8_initialise(&(ramps->u8)))
			return -1;
		libclut_start_over(&ramps->u8, UINT8_MAX, uint8_t, 1, 1, 1);
		break;

	case 16:
		if (libgamma_gamma_ramps16_initialise(&(ramps->u16)))
			return -1;
		libclut_start_over(&ramps->u16, UINT16_MAX, uint16_t, 1, 1, 1);
		break;

	case 32:
		if (libgamma_gamma_ramps32_initialise(&(ramps->u32)))
			return -1;
		libclut_start_over(&ramps->u32, UINT32_MAX, uint32_t, 1, 1, 1);
		break;

	case 64:
		if (libgamma_gamma_ramps64_initialise(&(ramps->u64)))
			return -1;
		libclut_start_over(&ramps->u64, UINT64_MAX, uint64_t, 1, 1, 1);
		break;

	case -1:
		if (libgamma_gamma_rampsf_initialise(&(ramps->f)))
			return -1;
		libclut_start_over(&ramps->f, 1.0f, float, 1, 1, 1);
		break;

	case -2:
		if (libgamma_gamma_rampsd_initialise(&(ramps->d)))
			return -1;
		libclut_start_over(&ramps->d, (double)1, double, 1, 1, 1);
		break;

	default:
		abort();
	}
	return 0;
}