util: Add test for pakfire_string_endswith

[pakfire.git] / src / libpakfire / util.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2013 Pakfire development team                                 #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <ftw.h>
#include <libgen.h>
#include <math.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>

#include <archive.h>
#include <archive_entry.h>
#include <json.h>
#include <solv/pool.h>
#include <uuid/uuid.h>

#include <pakfire/constants.h>
#include <pakfire/logging.h>
#include <pakfire/package.h>
#include <pakfire/util.h>

#define NSEC_PER_SEC 1000000000

static Id pakfire_parse_namespace(Pool* pool, const char* s) {
	const char* p = strchr(s, '(');
	if (!p)
		return 0;

	// Store the namespace ID
	Id namespace = pool_strn2id(pool, s, p - s, 1);

	// Find the end of the string
	s = strrchr(p, ')');
	if (!s)
		return 0;

	Id id = pool_strn2id(pool, p + 1, s - p - 1, 1);

	// Bring it all together
	return pool_rel2id(pool, namespace, id, REL_NAMESPACE, 1);
}

Id pakfire_parse_dep(struct pakfire* pakfire, const char* s) {
	Id id;

	if (!s) {
		errno = EINVAL;
		return 0;
	}

	// Ignore empty strings
	if (!*s)
		return 0;

	Pool* pool = pakfire_get_solv_pool(pakfire);

	// Consume any leading space
	if (isspace(*s))
		s++;

	const char* p = s;

	// Find the first part (before =, >= or <=)
	while (*p && !isspace(*p) && *p != '<' && *p != '=' && *p != '>')
		p++;

	// The length of the first part
	size_t l = p - s;

	// Add name to pool
	if (pakfire_string_startswith(s, "pakfire("))
		id = pakfire_parse_namespace(pool, s);
	else
		id = pool_strn2id(pool, s, l, 1);

	// Consume any more space
	if (isspace(*p))
		p++;

	if (*p == '<' || *p == '=' || *p == '>') {
		int flags = 0;

		while (1) {
			if (*p == '<')
				flags |= REL_LT;
			else if (*p == '=')
				flags |= REL_EQ;
			else if (*p == '>')
				flags |= REL_GT;
			else
				break;

			p++;
		}

		// Consume any more space
		if (isspace(*p))
			p++;

		// Add EVR to pool
		Id evr = pool_str2id(pool, p, 1);

		// Combine everything
		id = pool_rel2id(pool, id, evr, flags, 1);
	}

	return id;
}

void pakfire_parse_deps(struct pakfire* pakfire, struct pakfire_package* pkg,
		void (*func)(struct pakfire_package* pkg, const char* dep), const char* deps) {
	char* p = strdupa(deps);

	while (*p) {
		char* e = strchr(p, '\n');

		// Terminate the string
		if (e)
			*e = '\0';

		// Add the dependency
		func(pkg, p);

		// End loop when we reached the end
		if (!e)
			break;

		// Or continue at the next line
		p = e + 1;
	}
}

int pakfire_string_startswith(const char* s, const char* prefix) {
	// Validate input
	if (!s || !prefix) {
		errno = EINVAL;
		return 1;
	}

	return !strncmp(s, prefix, strlen(prefix));
}

int pakfire_string_endswith(const char* s, const char* suffix) {
	// Validate input
	if (!s || !suffix) {
		errno = EINVAL;
		return 1;
	}

	return !strcmp(s + strlen(s) - strlen(suffix), suffix);
}

int pakfire_string_matches(const char* s, const char* pattern) {
	return !!strstr(s, pattern);
}

char* pakfire_unquote_in_place(char* s) {
	if (!s || !*s)
		return s;

	// Is the first character a quote?
	if (*s != '"')
		return s;

	// Find the end of value
	size_t l = strlen(s);
	if (!l)
		return s;

	// Is the last character a quote?
	if (s[l - 1] != '"')
		return s;

	// The string seems to be in quotes; remove them
	s[l - 1] = '\0';
	s++;

	return s;
}

int pakfire_string_partition(const char* s, const char* delim, char** s1, char** s2) {
	char* p = strstr(s, delim);

	// Delim was not found
	if (!p) {
		*s1 = NULL;
		*s2 = NULL;
		return 1;
	}

	// Length of string before delim
	size_t l = p - s;

	char* buffer = malloc(l + 1);
	if (!buffer)
		return -ENOMEM;

	// Copy first part
	*s1 = memcpy(buffer, s, l);
	buffer[l] = '\0';

	// Copy second part
	*s2 = strdup(p + strlen(delim));

	return 0;
}

char* pakfire_string_replace(const char* s, const char* pattern, const char* repl) {
	// Return NULL on no input or no pattern
	if (!s || !pattern) {
		errno = EINVAL;
		return NULL;
	}

	// Replace with nothing when repl is NULL
	if (!repl)
		repl = "";

	char* result = NULL;
	const char** cache = NULL;
	unsigned int count = 0;

	const size_t pattern_length = strlen(pattern);

	// Working pointer
	const char* p = s;

	// Find all occurrences of pattern and store their location
	while (1) {
		const char* needle = strstr(p, pattern);
		if (!needle)
			break;

		// Make space in the cache
		cache = reallocarray(cache, sizeof(*cache), count + 1);
		cache[count++] = needle;

		// Move p forward
		p = needle + pattern_length;
	}

	// Copy the string if no occurence was found
	if (count == 0) {
		result = strdup(s);
		goto ERROR;
	}

	// Store the end pointer
	cache = reallocarray(cache, sizeof(*cache), count + 1);
	cache[count] = s + strlen(s);

	const size_t repl_length = strlen(repl);

	// Determine the length of the final string
	const size_t length = strlen(s) + ((repl_length - pattern_length) * count);

	// Allocate enough memory for the result
	result = malloc(length + 1);
	if (!result)
		goto ERROR;

	// Reset p
	p = s;

	// Working pointer for the result
	char* r = result;

	// Copy everything up to the first match
	ssize_t l = cache[0] - s;
	memcpy(r, p, l);
	r += l;
	p += l;

	for (unsigned int i = 0; i < count; i++) {
		// Put replacement here
		memcpy(r, repl, repl_length);
		r += repl_length;
		p += pattern_length;

		// Determine the length between two matches
		l = cache[i+1] - (cache[i] + pattern_length);

		memcpy(r, p, l);
		r += l;
		p += l;
	}

	// Terminate the string
	result[length] = '\0';

ERROR:
	if (cache)
		free(cache);

	return result;
}

static unsigned int pakfire_chrcnt(const char* s, char delim) {
	size_t length = strlen(s);

	unsigned int count = 0;

	for (unsigned int i = 0; i < length; i++)
		if (s[i] == delim)
			count++;

	return count;
}

char** pakfire_split_string(const char* s, char delim) {
	char** array = NULL;

	if (!s) {
		errno = EINVAL;
		return NULL;
	}

	// Count how often we need to split
	unsigned int count = pakfire_chrcnt(s, delim) + 1;

	// Allocate array
	array = calloc(count + 1, sizeof(*array));
	if (!array)
		return NULL;

	// Copy string to stack
	char* p = strdupa(s);
	if (!p)
		return NULL;

	unsigned int i = 0;
	while (*p) {
		char* e = strchr(p, delim);

		// Terminate the string
		if (e)
			*e = '\0';

		// Add string to the array
		array[i++] = strdup(p);

		// End loop when we reached the end
		if (!e)
			break;

		// Or continue at the next line
		p = e + 1;
	}

	return array;
}

char* pakfire_string_join(char** list, const char* delim) {
	if (!list)
		return NULL;

	size_t length = 0;
	unsigned int elements = 0;

	// Count the number of elements and the total length
	for (char** item = list; *item; item++) {
		length += strlen(*item);
		elements++;
	}

	// Empty list?
	if (!elements)
		return NULL;

	// Add the delimiters
	length += strlen(delim) * (elements - 1);

	// Allocate the result string
	char* string = malloc(length + 1);
	if (!string)
		return NULL;

	// Pointer to where we are writing
	char* p = string;

	size_t bytes_left = length;
	size_t bytes_written;

	for (char** item = list; *item; item++) {
		bytes_written = snprintf(p, bytes_left, "%s", *item);

		bytes_left -= bytes_written;
		p += bytes_written;

		// Write the delimiter
		if (bytes_left) {
			bytes_written = snprintf(p, bytes_left, "%s", delim);

			bytes_left -= bytes_written;
			p += bytes_written;
		}
	}

	return string;
}

int pakfire_format_size(char* dst, size_t length, double value) {
	const char* units[] = {
		"%.0f ",
		"%.0fk",
		"%.1fM",
		"%.1fG",
		"%.1fT",
		NULL
	};
	const char** unit = units;

	while (*(unit + 1) && value >= 1024.0) {
		value /= 1024.0;
		unit++;
	}

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
	return snprintf(dst, length, *unit, value);
#pragma GCC diagnostic pop
}

int pakfire_format_speed(char* dst, size_t length, double value) {
	const char* units[] = {
		"%4.0fB/s",
		"%4.0fkB/s",
		"%4.1fMB/s",
		"%4.1fGB/s",
		"%4.1fTB/s",
		NULL
	};
	const char** unit = units;

	while (*(unit + 1) && value >= 1024.0) {
		value /= 1024.0;
		unit++;
	}

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
	return snprintf(dst, length, *unit, value);
#pragma GCC diagnostic pop
}

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
static char* pakfire_strftime(const char* format, time_t t) {
	char string[128];
	struct tm* tm = gmtime(&t);

	strftime(string, sizeof(string) - 1, format, tm);

	return strdup(string);
}
#pragma GCC diagnostic pop

char* pakfire_format_date(time_t t) {
	return pakfire_strftime("%Y-%m-%d", t);
}

int __pakfire_strftime_now(char* dest, size_t length, const char* format) {
	struct tm tm;

	// Fetch the current time
	const time_t t = time(NULL);
	if (t < 0)
		return 1;

	// Convert to struct tm
	struct tm* now = gmtime_r(&t, &tm);
	if (!now)
		return 1;

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
	strftime(dest, length, format, now);
#pragma GCC diagnostic pop

	return 0;
}

int __pakfire_path_join(char* dest, size_t length,
		const char* first, const char* second) {
	if (!first)
		return snprintf(dest, length, "%s", second);

	if (!second)
		return snprintf(dest, length, "%s", first);

	// Remove leading slashes from second argument
	while (*second == '/')
		second++;

	return snprintf(dest, length, "%s/%s", first, second);
}

const char* pakfire_path_relpath(const char* root, const char* path) {
	if (pakfire_string_startswith(path, root))
		return path + strlen(root);

	return NULL;
}

int pakfire_path_exists(const char* path) {
	return !access(path, F_OK);
}

time_t pakfire_path_age(const char* path) {
	struct stat st;

	int r = stat(path, &st);
	if (r == 0) {
		// Get current timestamp
		time_t now = time(NULL);

		// Return the difference since the file has been created and now
		return now - st.st_ctime;
	}

	return -1;
}

char* pakfire_basename(const char* path) {
	char* name = strdup(path);

	char* r = basename(name);
	if (r)
		r = strdup(r);

	free(name);

	return r;
}

char* pakfire_dirname(const char* path) {
	char* parent = strdup(path);

	char* r = dirname(parent);
	if (r)
		r = strdup(r);

	free(parent);

	return r;
}

char* pakfire_remove_trailing_newline(char* str) {
	ssize_t pos = strlen(str) - 1;

	if (str[pos] == '\n')
		str[pos] = '\0';

	return str;
}

int pakfire_read_file_into_buffer(FILE* f, char** buffer, size_t* len) {
	if (!f)
		return -EBADF;

	int r = fseek(f, 0, SEEK_END);
	if (r)
		return r;

	// Save length of file
	*len = ftell(f);

	// Go back to the start
	r = fseek(f, 0, SEEK_SET);
	if (r)
		return r;

	// Allocate buffer
	*buffer = malloc((sizeof(**buffer) * *len) + 1);
	if (!*buffer)
		return -ENOMEM;

	// Read content
	fread(*buffer, *len, sizeof(**buffer), f);

	// Check we encountered any errors
	r = ferror(f);
	if (r) {
		free(*buffer);
		return r;
	}

	// Terminate the buffer
	(*buffer)[*len] = '\0';

	return 0;
}

char* pakfire_generate_uuid() {
	uuid_t uuid;

	// Generate a new random value
	uuid_generate_random(uuid);

	char* ret = malloc(UUID_STR_LEN + 1);
	if (!ret)
		return NULL;

	// Convert it to string
	uuid_unparse_lower(uuid, ret);

	// Terminate string
	ret[UUID_STR_LEN] = '\0';

	return ret;
}

int pakfire_tty_is_noninteractive(void) {
	const int fds[] = {
		STDIN_FILENO,
		STDOUT_FILENO,
		STDERR_FILENO,
		-1,
	};

	for (const int* fd = fds; *fd >= 0; fd++) {
		if (!isatty(*fd))
			return 1;
	}

	return 0;
}

char* __pakfire_hexlify(const unsigned char* digest, const size_t length) {
	const char* hexdigits = "0123456789abcdef";

	char* s = malloc((length * 2) + 1);
	if (!s)
		return NULL;

	for (unsigned int i = 0, j = 0; i < length; i++) {
		char b = digest[i];

		s[j++] = hexdigits[(b >> 4) & 0xf];
		s[j++] = hexdigits[(b & 0x0f)];
	}

	// Terminate result
	s[length * 2] = '\0';

	return s;
}

static int parse_nibble(char nibble) {
	// Handle digits
	if (nibble >= '0' && nibble <= '9')
		return nibble - '0';

	// Handle lowercase letters
	if (nibble >= 'a' && nibble <= 'f')
		return 10 + nibble - 'a';

	// Handle uppercase letters
	if (nibble >= 'A' && nibble <= 'F')
		return 10 + nibble - 'A';

	// Error
	return -1;
}

int __pakfire_unhexlify(unsigned char* dst, const size_t l, const char* src) {
	if (!src) {
		errno = EINVAL;
		return 1;
	}

	// Determine input length
	const size_t length = strlen(src);

	for (unsigned int i = 0, j = 0; i < length && j < l; i += 2, j++) {
		int h = parse_nibble(src[i]);
		int l = parse_nibble(src[i+1]);

		// Check for invalid input
		if (h < 0 || l < 0) {
			errno = EINVAL;
			return 1;
		}

		// Store result
		dst[j] = h << 4 | l;
	}

	return 0;
}

int pakfire_mkparentdir(const char* path, mode_t mode) {
	int r;

	char* dirname = pakfire_dirname(path);
	if (!dirname)
		return 1;

	// We have arrived at the top of the tree
	if (*dirname == '.' || strcmp(dirname, "/") == 0)
		return 0;

	// Ensure the parent directory exists
	r = pakfire_mkparentdir(dirname, mode);
	if (r)
		goto END;

	// Create this directory
	r = mkdir(dirname, mode);

	// Ignore when the directory already exists
	if (r && errno == EEXIST)
		r = 0;

END:
	free(dirname);

	return r;
}

int pakfire_mkdir(const char* path, mode_t mode) {
	int r = pakfire_mkparentdir(path, mode);
	if (r)
		return r;

	// Finally, create the directory we want
	return mkdir(path, mode);
}

FILE* pakfire_mktemp(char* path) {
	int r = pakfire_mkparentdir(path, 0);
	if (r)
		return NULL;

	// Create a temporary result file
	int fd = mkostemp(path, O_CLOEXEC);
	if (fd < 0)
		return NULL;

	// Re-open as file handle
	return fdopen(fd, "w+");
}

char* pakfire_mkdtemp(char* path) {
	int r = pakfire_mkparentdir(path, 0);
	if (r)
		return NULL;

	return mkdtemp(path);
}

static int _unlink(const char* path, const struct stat* stat, int typeflag, struct FTW* ftwbuf) {
	return remove(path);
}

int pakfire_rmtree(const char* path, int flags) {
	int r = nftw(path, _unlink, 64, flags|FTW_DEPTH|FTW_PHYS);

	// Ignore if path didn't exist
	if (r < 0 && errno == ENOENT)
		r = 0;

	return r;
}

// Digests

size_t pakfire_digest_length(enum pakfire_digests digest) {
	switch (digest) {
		case PAKFIRE_DIGEST_SHA512:
			return 64;

		case PAKFIRE_DIGEST_SHA256:
			return 32;

		case PAKFIRE_DIGEST_SHA1:
			return 20;

		case PAKFIRE_DIGEST_NONE:
			return 0;
	}

	return 0;
}

// Archive Stuff

int pakfire_archive_copy_data(struct archive* src, struct archive* dst,
		struct archive_entry* entry) {
	const void* buffer;
	size_t size;
	off_t offset;
	int r;

	for (;;) {
		// Read a block of data
		r = archive_read_data_block(src, &buffer, &size, &offset);
		if (r == ARCHIVE_EOF)
			return ARCHIVE_OK;
		else if (r)
			return r;

		// Write the read block of data
		r = archive_write_data(dst, buffer, size);
		if (r < 0)
			return r;
	}
}

int pakfire_archive_copy_data_to_buffer(struct pakfire* pakfire, struct archive* a,
		struct archive_entry* entry, char** data, size_t* data_size) {
	*data = NULL;
	*data_size = 0;

	size_t required_size = archive_entry_size(entry);
	if (!required_size)
		return 0;

	// Allocate a block of the required size
	*data = calloc(1, required_size + 1);
	if (!*data)
		return ENOMEM;

	ssize_t bytes_read = archive_read_data(a, *data, required_size);
	if (bytes_read < 0) {
		ERROR(pakfire, "Could not read from archive: %s\n", archive_error_string(a));
		free(*data);
		return 1;
	}

	*data_size = bytes_read;

	return 0;
}

// JSON Stuff

static struct json_object* pakfire_json_parse(struct pakfire* pakfire, FILE* f) {
	struct json_tokener* tokener = NULL;
	struct json_object* json = NULL;
	char* buffer = NULL;
	size_t length;

	// Read everything into memory
	int r = pakfire_read_file_into_buffer(f, &buffer, &length);
	if (r)
		goto ERROR;

	// Create tokener
	tokener = json_tokener_new();
	if (!tokener) {
		ERROR(pakfire, "Could not allocate JSON tokener: %m\n");
		goto ERROR;
	}

	// Parse JSON from path
	json = json_tokener_parse_ex(tokener, buffer, length);
	if (!json) {
		enum json_tokener_error error = json_tokener_get_error(tokener);

		ERROR(pakfire, "JSON parsing error: %s\n", json_tokener_error_desc(error));
		goto ERROR;
	}

	// Log what we have parsed
	DEBUG(pakfire, "Parsed JSON:\n%s\n",
		json_object_to_json_string_ext(json,
			JSON_C_TO_STRING_SPACED | JSON_C_TO_STRING_PRETTY)
	);

ERROR:
	if (buffer)
		free(buffer);

	if (tokener)
		json_tokener_free(tokener);

	return json;
}

struct json_object* pakfire_json_parse_from_file(struct pakfire* pakfire, const char* path) {
	FILE* f = fopen(path, "r");
	if (!f)
		return NULL;

	struct json_object* json = pakfire_json_parse(pakfire, f);
	fclose(f);

	return json;
}

// Time Stuff

static void timespec_normalize(struct timespec* t) {
	while (t->tv_nsec >= NSEC_PER_SEC) {
		t->tv_sec++;
		t->tv_nsec -= NSEC_PER_SEC;
	}

	while (t->tv_nsec <= -NSEC_PER_SEC) {
		t->tv_sec--;
		t->tv_nsec += NSEC_PER_SEC;
	}
}

struct timespec timespec_add(const struct timespec* t1, const struct timespec* t2) {
	struct timespec r = {
		.tv_sec  = t1->tv_sec  + t2->tv_sec,
		.tv_nsec = t2->tv_nsec + t2->tv_nsec,
	};

	// Correct any negative values
	timespec_normalize(&r);

	return r;
}

struct timespec timespec_from_ms(int milliseconds) {
	struct timespec t = {
		.tv_sec  = (milliseconds / 1000),
		.tv_nsec = (milliseconds % 1000) * 1000000,
	};
	
	return t;
}

int timespec_lt(struct timespec* t1, struct timespec* t2) {	
	return (
		t1->tv_sec < t2->tv_sec ||
		(t1->tv_sec == t2->tv_sec && t1->tv_nsec < t2->tv_nsec)
	);
}

// Resource Limits

int pakfire_rlimit_set(struct pakfire* pakfire, int limit) {
	struct rlimit rl;

	// Sanity check
	if (limit < 3) {
		errno = EINVAL;
		return 1;
	}

	// Fetch current configuration
	if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
		ERROR(pakfire, "Could not read RLIMIT_NOFILE: %m\n");
		return 1;
	}

	// Do not attempt to set higher than maximum
	if ((long unsigned int)limit > rl.rlim_max)
		limit = rl.rlim_max;

	rl.rlim_cur = limit;

	// Set the new limit
	if (setrlimit(RLIMIT_NOFILE, &rl) < 0) {
		ERROR(pakfire, "Could not set RLIMIT_NOFILE to %lu: %m\n", rl.rlim_cur);
		return 1;
	}

	DEBUG(pakfire, "RLIMIT_NOFILE set to %d\n", limit);

	return 0;
}

/*
	Resets RLIMIT_NOFILE to FD_SETSIZE (e.g. 1024)
	for compatibility with software that uses select()
*/
int pakfire_rlimit_reset_nofile(struct pakfire* pakfire) {
	return pakfire_rlimit_set(pakfire, FD_SETSIZE);
}