[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

const char* pakfire_dep2str(struct pakfire* pakfire, Id id) {
        Pool* pool = pakfire_get_solv_pool(pakfire);
        if (!pool)
                return NULL;

        return pool_dep2str(pool, id);
}

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) {
        // Validate input
        if (!s || !pattern) {
                errno = EINVAL;
                return 1;
        }

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