Drop support for SHA-1

[people/ms/pakfire.git] / src / libpakfire / file.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2014 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 <errno.h>
#include <libgen.h>
#include <linux/limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>

#include <archive_entry.h>
#include <openssl/evp.h>

#include <pakfire/constants.h>
#include <pakfire/file.h>
#include <pakfire/logging.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>
#include <pakfire/string.h>
#include <pakfire/util.h>

#define MAX_DIGESTS 4

struct pakfire_file_digest {
        enum pakfire_digests type;
        unsigned char digest[EVP_MAX_MD_SIZE];
        size_t length;

        // Add a buffer to store the hex representation
        char* hexdigest;
};

struct pakfire_file {
        struct pakfire* pakfire;
        int nrefs;

        // The relative path
        char path[PATH_MAX];

        // The absolute path in the file system
        char abspath[PATH_MAX];

        // File Ownership
        char user[LOGIN_NAME_MAX];
        char group[LOGIN_NAME_MAX];

        // File Size
        ssize_t size;

        // File Mode
        mode_t mode;

        // Dev Minor/Major
        dev_t dev;

        // Creation/Modification Time
        time_t ctime;
        time_t mtime;

        // Link destinations
        char hardlink[PATH_MAX];
        char symlink[PATH_MAX];

        // Digests
        struct pakfire_file_digest digests[MAX_DIGESTS];

        #warning TODO capabilities, config, data
        // capabilities
        //int is_configfile;
        //int is_datafile;
};

PAKFIRE_EXPORT int pakfire_file_create(struct pakfire_file** file, struct pakfire* pakfire) {
        struct pakfire_file* f = calloc(1, sizeof(*f));
        if (!f)
                return 1;

        // Store reference to Pakfire
        f->pakfire = pakfire_ref(pakfire);

        // Initialize reference counter
        f->nrefs = 1;

        *file = f;
        return 0;
}

int pakfire_file_create_from_archive_entry(struct pakfire_file** file, struct pakfire* pakfire,
                struct archive_entry* entry) {
        int r = pakfire_file_create(file, pakfire);
        if (r)
                return r;

        // Copy archive entry
        r = pakfire_file_copy_archive_entry(*file, entry);
        if (r)
                goto ERROR;

        return 0;

ERROR:
        pakfire_file_unref(*file);
        *file = NULL;

        return r;
}

static const struct pakfire_libarchive_digest {
        enum pakfire_digests pakfire;
        int libarchive;
} pakfire_libarchive_digests[] = {
        { PAKFIRE_DIGEST_SHA512, ARCHIVE_ENTRY_DIGEST_SHA512 },
        { PAKFIRE_DIGEST_SHA256, ARCHIVE_ENTRY_DIGEST_SHA256 },
        { PAKFIRE_DIGEST_NONE, 0 },
};

int pakfire_file_copy_archive_entry(struct pakfire_file* file, struct archive_entry* entry) {
        int r = 0;

        // Set abspath
        pakfire_file_set_abspath(file, archive_entry_sourcepath(entry));

        // Set path
        const char* path = archive_entry_pathname(entry);
        if (path) {
                // Strip any leading dots from paths
                if (pakfire_string_startswith(path, "./"))
                        path++;

                pakfire_file_set_path(file, path);
        }

        // Set links
        pakfire_file_set_hardlink(file, archive_entry_hardlink(entry));
        pakfire_file_set_symlink(file, archive_entry_symlink(entry));

        // Set size
        pakfire_file_set_size(file, archive_entry_size(entry));

        // Set mode
        pakfire_file_set_mode(file, archive_entry_mode(entry));

        // Set dev type
        if (archive_entry_dev_is_set(entry))
                pakfire_file_set_dev(file, archive_entry_dev(entry));

        // Set user
        pakfire_file_set_user(file, archive_entry_uname(entry));

        // Set group
        pakfire_file_set_group(file, archive_entry_gname(entry));

        // Set times
        pakfire_file_set_ctime(file, archive_entry_ctime(entry));
        pakfire_file_set_mtime(file, archive_entry_mtime(entry));

        // Copy digest
        for (const struct pakfire_libarchive_digest* type = pakfire_libarchive_digests;
                        type->pakfire; type++) {
                const unsigned char* digest = archive_entry_digest(entry, type->libarchive);
                if (digest) {
                        size_t length = pakfire_digest_length(type->pakfire);

                        r = pakfire_file_set_digest(file, type->pakfire, digest, length);
                        if (r)
                                return r;
                }
        }

        return r;
}

struct archive_entry* pakfire_file_archive_entry(struct pakfire_file* file) {
        struct archive_entry* entry = archive_entry_new();
        if (!entry) {
                ERROR(file->pakfire, "Could not allocate archive entry: %m\n");
                return NULL;
        }

        // Set path
        archive_entry_copy_pathname(entry, pakfire_file_get_path(file));

        // Set source path
        archive_entry_copy_sourcepath(entry, file->abspath);

        // Set links
        if (*file->hardlink)
                archive_entry_set_hardlink(entry, file->hardlink);
        if (*file->symlink)
                archive_entry_set_symlink(entry, file->symlink);

        // Set size
        archive_entry_set_size(entry, pakfire_file_get_size(file));

        // Set mode
        archive_entry_set_mode(entry, pakfire_file_get_mode(file));

        // Set user
        archive_entry_set_uname(entry, pakfire_file_get_user(file));

        // Set group
        archive_entry_set_gname(entry, pakfire_file_get_group(file));

        // Set times
        archive_entry_set_ctime(entry, pakfire_file_get_ctime(file), 0);
        archive_entry_set_mtime(entry, pakfire_file_get_mtime(file), 0);

        // XXX copy digest

        return entry;
}

static void pakfire_file_free(struct pakfire_file* file) {
        struct pakfire_file_digest* digest = NULL;

        // Free any generated hexdigests
        for (unsigned int i = 0; i < MAX_DIGESTS; i++) {
                digest = &file->digests[i];

                if (digest->hexdigest) {
                        free(digest->hexdigest);
                        digest->hexdigest = NULL;
                }
        }

        pakfire_unref(file->pakfire);
        free(file);
}

PAKFIRE_EXPORT struct pakfire_file* pakfire_file_ref(struct pakfire_file* file) {
        file->nrefs++;

        return file;
}

PAKFIRE_EXPORT struct pakfire_file* pakfire_file_unref(struct pakfire_file* file) {
        if (--file->nrefs > 0)
                return file;

        pakfire_file_free(file);
        return NULL;
}

PAKFIRE_EXPORT int pakfire_file_cmp(struct pakfire_file* file1, struct pakfire_file* file2) {
        const char* path1 = pakfire_file_get_path(file1);
        const char* path2 = pakfire_file_get_path(file2);

        return strcmp(path1, path2);
}

const char* pakfire_file_get_abspath(struct pakfire_file* file) {
        return file->abspath;
}

int pakfire_file_set_abspath(struct pakfire_file* file, const char* path) {
        // Check if path is set and absolute
        if (!path || *path != '/') {
                errno = EINVAL;
                return 1;
        }

        return pakfire_string_set(file->abspath, path);
}

PAKFIRE_EXPORT const char* pakfire_file_get_path(struct pakfire_file* file) {
        return file->path;
}

PAKFIRE_EXPORT int pakfire_file_set_path(struct pakfire_file* file, const char* path) {
        // Check if path is set and absolute
        if (!path || *path != '/') {
                errno = EINVAL;
                return 1;
        }

        return pakfire_string_set(file->path, path);
}

PAKFIRE_EXPORT const char* pakfire_file_get_hardlink(struct pakfire_file* file) {
        if (!*file->hardlink)
                return NULL;

        return file->hardlink;
}

PAKFIRE_EXPORT void pakfire_file_set_hardlink(struct pakfire_file* file, const char* link) {
        if (!link || !*link)
                *file->hardlink = '\0';
        else
                pakfire_string_set(file->hardlink, link);
}

PAKFIRE_EXPORT const char* pakfire_file_get_symlink(struct pakfire_file* file) {
        if (!*file->symlink)
                return NULL;

        return file->symlink;
}

PAKFIRE_EXPORT void pakfire_file_set_symlink(struct pakfire_file* file, const char* link) {
        if (!link || !*link)
                *file->hardlink = '\0';
        else
                pakfire_string_set(file->symlink, link);
}

PAKFIRE_EXPORT int pakfire_file_get_type(struct pakfire_file* file) {
        return file->mode & S_IFMT;
}

PAKFIRE_EXPORT ssize_t pakfire_file_get_size(struct pakfire_file* file) {
        return file->size;
}

PAKFIRE_EXPORT void pakfire_file_set_size(struct pakfire_file* file, ssize_t size) {
        file->size = size;
}

PAKFIRE_EXPORT const char* pakfire_file_get_user(struct pakfire_file* file) {
        return file->user;
}

PAKFIRE_EXPORT void pakfire_file_set_user(struct pakfire_file* file, const char* user) {
        pakfire_string_set(file->user, user);
}

PAKFIRE_EXPORT const char* pakfire_file_get_group(struct pakfire_file* file) {
        return file->group;
}

PAKFIRE_EXPORT void pakfire_file_set_group(struct pakfire_file* file, const char* group) {
        pakfire_string_set(file->group, group);
}

PAKFIRE_EXPORT mode_t pakfire_file_get_mode(struct pakfire_file* file) {
        return file->mode;
}

PAKFIRE_EXPORT void pakfire_file_set_mode(struct pakfire_file* file, mode_t mode) {
        file->mode = mode;
}

PAKFIRE_EXPORT dev_t pakfire_file_get_dev(struct pakfire_file* file) {
        return file->dev;
}

PAKFIRE_EXPORT void pakfire_file_set_dev(struct pakfire_file* file, dev_t dev) {
        file->dev = dev;
}

PAKFIRE_EXPORT time_t pakfire_file_get_ctime(struct pakfire_file* file) {
        return file->ctime;
}

PAKFIRE_EXPORT void pakfire_file_set_ctime(struct pakfire_file* file, time_t time) {
        file->ctime = time;
}

PAKFIRE_EXPORT time_t pakfire_file_get_mtime(struct pakfire_file* file) {
        return file->mtime;
}

PAKFIRE_EXPORT void pakfire_file_set_mtime(struct pakfire_file* file, time_t time) {
        file->mtime = time;
}

static struct pakfire_file_digest* pakfire_file_find_digest(
                struct pakfire_file* file, enum pakfire_digests type) {
        struct pakfire_file_digest* digest = NULL;

        for (unsigned int i = 0; i < MAX_DIGESTS; i++) {
                digest = &file->digests[i];

                if (digest->type == type)
                        return digest;
        }

        // No match
        return NULL;
}

PAKFIRE_EXPORT const unsigned char* pakfire_file_get_digest(
                struct pakfire_file* file, enum pakfire_digests type, size_t* length) {
        const struct pakfire_file_digest* digest = pakfire_file_find_digest(file, type);
        if (!digest)
                return NULL;

        // Export length
        if (length)
                *length = digest->length;

        return digest->digest;
}

PAKFIRE_EXPORT const char* pakfire_file_get_hexdigest(
                struct pakfire_file* file, enum pakfire_digests type) {
        struct pakfire_file_digest* digest = pakfire_file_find_digest(file, type);
        if (!digest)
                return NULL;

        // Generate the hexdigest if non exists
        if (!digest->hexdigest) {
                const size_t length = pakfire_digest_length(digest->type);
                if (!length)
                        return NULL;

                digest->hexdigest = __pakfire_hexlify(digest->digest, length);
        }

        return digest->hexdigest;
}

PAKFIRE_EXPORT int pakfire_file_set_digest(struct pakfire_file* file,
                enum pakfire_digests type, const unsigned char* digest, size_t length) {
        if (!digest || !length) {
                errno = EINVAL;
                return 1;
        }

        // Find any existing digests of this type
        struct pakfire_file_digest* d = pakfire_file_find_digest(file, type);

        // If there is no digest, we will try finding a new one
        if (!d)
                d = pakfire_file_find_digest(file, PAKFIRE_DIGEST_NONE);

        // If we could not find a free spot, we probably run out of space
        if (!d) {
                errno = ENOBUFS;
                return 1;
        }

        // Check if the digest fits into our pre-allocated buffer space
        if (length > sizeof(d->digest)) {
                errno = ENOBUFS;
                return 1;
        }

        // Store type & length
        d->type = type;
        d->length = length;

        // Store digest
        memcpy(d->digest, digest, d->length);

        return 0;
}

PAKFIRE_EXPORT int pakfire_file_set_hexdigest(struct pakfire_file* file,
                enum pakfire_digests type, const char* hexdigest) {
        const size_t digest_length = pakfire_digest_length(type);
        if (!digest_length) {
                errno = EINVAL;
                return 1;
        }

        // Allocate a buffer for the binary representation of the digest
        unsigned char* digest = alloca(digest_length);
        if (!digest)
                return 1;

        // Convert from hex to binary
        __pakfire_unhexlify(digest, digest_length, hexdigest);

        return pakfire_file_set_digest(file, type, digest, digest_length);
}

static int pakfire_file_levels(struct pakfire_file* file) {
        if (!*file->path)
                return 0;

        int levels = 0;

        for (char* p = file->path; *p; p++) {
                if (*p == '/')
                        levels++;
        }

        return levels;
}

FILE* pakfire_file_open(struct pakfire_file* file) {
        FILE* f = fopen(file->abspath, "r");
        if (!f)
                ERROR(file->pakfire, "Could not open %s: %m\n", file->abspath);

        return f;
}

int pakfire_file_remove(struct pakfire_file* file) {
        if (!*file->abspath) {
                errno = EINVAL;
                return 1;
        }

        DEBUG(file->pakfire, "Removing %s...\n", file->path);

        int r = remove(file->abspath);
        if (r) {
                switch (errno) {
                        // Ignore when we could not remove directories
                        case ENOTEMPTY:
                                return 0;

                        // Ignore if the file didn't exist
                        case ENOENT:
                                return 0;

                        default:
                                break;
                }

                ERROR(file->pakfire, "Could not remove %s (%s): %m\n", file->path, file->abspath);
        }

        return r;
}

/*
        This function tries to remove the file after it has been packaged.

        It will try to delete any parent directories as well and ignore if directories
        cannot be deleted because they might contain other files
*/
int pakfire_file_cleanup(struct pakfire_file* file) {
        char path[PATH_MAX];

        // Try removing the file
        int r = pakfire_file_remove(file);
        if (r)
                return r;

        // Create a working copy of abspath
        r = pakfire_string_set(path, file->abspath);
        if (r)
                return r;

        // See how many levels this file has
        int levels = pakfire_file_levels(file);

        // Walk all the way up and remove all parent directories if possible
        while (--levels) {
                dirname(path);

                // Break if path is suddenly empty
                if (!*path)
                        break;

                r = rmdir(path);
                if (r) {
                        if (errno == ENOTEMPTY)
                                return 0;

                        return r;
                }
        }

        return 0;
}