path: root/lib/libalpm/handle.c

/*
 *  handle.c
 *
 *  Copyright (c) 2006-2015 Pacman Development Team <pacman-dev@archlinux.org>
 *  Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
 *  Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
 *  Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
 *
 *  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 2 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 <stdlib.h>
#include <string.h>
#include <limits.h>
#include <sys/types.h>
#include <syslog.h>
#include <sys/stat.h>
#include <fcntl.h>

/* libalpm */
#include "handle.h"
#include "alpm_list.h"
#include "util.h"
#include "log.h"
#include "delta.h"
#include "trans.h"
#include "alpm.h"
#include "deps.h"

alpm_handle_t *_alpm_handle_new(void)
{
        alpm_handle_t *handle;

        CALLOC(handle, 1, sizeof(alpm_handle_t), return NULL);
        handle->deltaratio = 0.0;
        handle->lockfd = -1;

        return handle;
}

void _alpm_handle_free(alpm_handle_t *handle)
{
        if(handle == NULL) {
                return;
        }

        /* close logfile */
        if(handle->logstream) {
                fclose(handle->logstream);
                handle->logstream = NULL;
        }
        if(handle->usesyslog) {
                handle->usesyslog = 0;
                closelog();
        }

#ifdef HAVE_LIBCURL
        /* release curl handle */
        curl_easy_cleanup(handle->curl);
#endif

#ifdef HAVE_LIBGPGME
        FREELIST(handle->known_keys);
#endif

        regfree(&handle->delta_regex);

        /* free memory */
        _alpm_trans_free(handle->trans);
        FREE(handle->root);
        FREE(handle->dbpath);
        FREE(handle->dbext);
        FREELIST(handle->cachedirs);
        FREE(handle->logfile);
        FREE(handle->lockfile);
        FREE(handle->arch);
        FREE(handle->gpgdir);
        FREELIST(handle->noupgrade);
        FREELIST(handle->noextract);
        FREELIST(handle->ignorepkg);
        FREELIST(handle->ignoregroup);

        alpm_list_free_inner(handle->assumeinstalled, (alpm_list_fn_free)alpm_dep_free);
        alpm_list_free(handle->assumeinstalled);

        FREE(handle);
}

/** Lock the database */
int _alpm_handle_lock(alpm_handle_t *handle)
{
        char *dir, *ptr;

        ASSERT(handle->lockfile != NULL, return -1);
        ASSERT(handle->lockfd < 0, return 0);

        /* create the dir of the lockfile first */
        dir = strdup(handle->lockfile);
        ptr = strrchr(dir, '/');
        if(ptr) {
                *ptr = '\0';
        }
        if(_alpm_makepath(dir)) {
                FREE(dir);
                return -1;
        }
        FREE(dir);

        do {
                handle->lockfd = open(handle->lockfile, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0000);
        } while(handle->lockfd == -1 && errno == EINTR);

        return (handle->lockfd >= 0 ? 0 : -1);
}

/** Remove a lock file */
int _alpm_handle_unlock(alpm_handle_t *handle)
{
        ASSERT(handle->lockfile != NULL, return -1);
        ASSERT(handle->lockfd >= 0, return 0);

        close(handle->lockfd);
        handle->lockfd = -1;

        if(unlink(handle->lockfile) != 0) {
                if(errno == ENOENT) {
                        _alpm_log(handle, ALPM_LOG_WARNING,
                                        _("lock file missing %s\n"), handle->lockfile);
                        alpm_logaction(handle, ALPM_CALLER_PREFIX,
                                        "warning: lock file missing %s\n", handle->lockfile);
                        return 0;
                } else {
                        _alpm_log(handle, ALPM_LOG_WARNING,
                                        _("could not remove lock file %s\n"), handle->lockfile);
                        alpm_logaction(handle, ALPM_CALLER_PREFIX,
                                        "warning: could not remove lock file %s\n", handle->lockfile);
                        return -1;
                }
        }
        return 0;
}


alpm_cb_log SYMEXPORT alpm_option_get_logcb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->logcb;
}

alpm_cb_download SYMEXPORT alpm_option_get_dlcb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->dlcb;
}

alpm_cb_fetch SYMEXPORT alpm_option_get_fetchcb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->fetchcb;
}

alpm_cb_totaldl SYMEXPORT alpm_option_get_totaldlcb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->totaldlcb;
}

alpm_cb_event SYMEXPORT alpm_option_get_eventcb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->eventcb;
}

alpm_cb_question SYMEXPORT alpm_option_get_questioncb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->questioncb;
}

alpm_cb_progress SYMEXPORT alpm_option_get_progresscb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->progresscb;
}

const char SYMEXPORT *alpm_option_get_root(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->root;
}

const char SYMEXPORT *alpm_option_get_dbpath(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->dbpath;
}

alpm_list_t SYMEXPORT *alpm_option_get_cachedirs(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->cachedirs;
}

const char SYMEXPORT *alpm_option_get_logfile(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->logfile;
}

const char SYMEXPORT *alpm_option_get_lockfile(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->lockfile;
}

const char SYMEXPORT *alpm_option_get_gpgdir(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->gpgdir;
}

int SYMEXPORT alpm_option_get_usesyslog(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return -1);
        return handle->usesyslog;
}

alpm_list_t SYMEXPORT *alpm_option_get_noupgrades(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->noupgrade;
}

alpm_list_t SYMEXPORT *alpm_option_get_noextracts(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->noextract;
}

alpm_list_t SYMEXPORT *alpm_option_get_ignorepkgs(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->ignorepkg;
}

alpm_list_t SYMEXPORT *alpm_option_get_ignoregroups(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->ignoregroup;
}

alpm_list_t SYMEXPORT *alpm_option_get_assumeinstalled(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->assumeinstalled;
}

const char SYMEXPORT *alpm_option_get_arch(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->arch;
}

double SYMEXPORT alpm_option_get_deltaratio(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return -1);
        return handle->deltaratio;
}

int SYMEXPORT alpm_option_get_checkspace(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return -1);
        return handle->checkspace;
}

const char SYMEXPORT *alpm_option_get_dbext(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->dbext;
}

int SYMEXPORT alpm_option_set_logcb(alpm_handle_t *handle, alpm_cb_log cb)
{
        CHECK_HANDLE(handle, return -1);
        handle->logcb = cb;
        return 0;
}

int SYMEXPORT alpm_option_set_dlcb(alpm_handle_t *handle, alpm_cb_download cb)
{
        CHECK_HANDLE(handle, return -1);
        handle->dlcb = cb;
        return 0;
}

int SYMEXPORT alpm_option_set_fetchcb(alpm_handle_t *handle, alpm_cb_fetch cb)
{
        CHECK_HANDLE(handle, return -1);
        handle->fetchcb = cb;
        return 0;
}

int SYMEXPORT alpm_option_set_totaldlcb(alpm_handle_t *handle, alpm_cb_totaldl cb)
{
        CHECK_HANDLE(handle, return -1);
        handle->totaldlcb = cb;
        return 0;
}

int SYMEXPORT alpm_option_set_eventcb(alpm_handle_t *handle, alpm_cb_event cb)
{
        CHECK_HANDLE(handle, return -1);
        handle->eventcb = cb;
        return 0;
}

int SYMEXPORT alpm_option_set_questioncb(alpm_handle_t *handle, alpm_cb_question cb)
{
        CHECK_HANDLE(handle, return -1);
        handle->questioncb = cb;
        return 0;
}

int SYMEXPORT alpm_option_set_progresscb(alpm_handle_t *handle, alpm_cb_progress cb)
{
        CHECK_HANDLE(handle, return -1);
        handle->progresscb = cb;
        return 0;
}

static char *canonicalize_path(const char *path)
{
        char *new_path;
        size_t len;

        /* verify path ends in a '/' */
        len = strlen(path);
        if(path[len - 1] != '/') {
                len += 1;
        }
        CALLOC(new_path, len + 1, sizeof(char), return NULL);
        strcpy(new_path, path);
        new_path[len - 1] = '/';
        return new_path;
}

alpm_errno_t _alpm_set_directory_option(const char *value,
                char **storage, int must_exist)
{
        struct stat st;
        char real[PATH_MAX];
        const char *path;

        path = value;
        if(!path) {
                return ALPM_ERR_WRONG_ARGS;
        }
        if(must_exist) {
                if(stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
                        return ALPM_ERR_NOT_A_DIR;
                }
                if(!realpath(path, real)) {
                        return ALPM_ERR_NOT_A_DIR;
                }
                path = real;
        }

        if(*storage) {
                FREE(*storage);
        }
        *storage = canonicalize_path(path);
        if(!*storage) {
                return ALPM_ERR_MEMORY;
        }
        return 0;
}

int SYMEXPORT alpm_option_add_cachedir(alpm_handle_t *handle, const char *cachedir)
{
        char *newcachedir;

        CHECK_HANDLE(handle, return -1);
        ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));
        /* don't stat the cachedir yet, as it may not even be needed. we can
         * fail later if it is needed and the path is invalid. */

        newcachedir = canonicalize_path(cachedir);
        if(!newcachedir) {
                RET_ERR(handle, ALPM_ERR_MEMORY, -1);
        }
        handle->cachedirs = alpm_list_add(handle->cachedirs, newcachedir);
        _alpm_log(handle, ALPM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
        return 0;
}

int SYMEXPORT alpm_option_set_cachedirs(alpm_handle_t *handle, alpm_list_t *cachedirs)
{
        alpm_list_t *i;
        CHECK_HANDLE(handle, return -1);
        if(handle->cachedirs) {
                FREELIST(handle->cachedirs);
        }
        for(i = cachedirs; i; i = i->next) {
                int ret = alpm_option_add_cachedir(handle, i->data);
                if(ret) {
                        return ret;
                }
        }
        return 0;
}

int SYMEXPORT alpm_option_remove_cachedir(alpm_handle_t *handle, const char *cachedir)
{
        char *vdata = NULL;
        char *newcachedir;
        CHECK_HANDLE(handle, return -1);
        ASSERT(cachedir != NULL, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));

        newcachedir = canonicalize_path(cachedir);
        if(!newcachedir) {
                RET_ERR(handle, ALPM_ERR_MEMORY, -1);
        }
        handle->cachedirs = alpm_list_remove_str(handle->cachedirs, newcachedir, &vdata);
        FREE(newcachedir);
        if(vdata != NULL) {
                FREE(vdata);
                return 1;
        }
        return 0;
}

int SYMEXPORT alpm_option_set_logfile(alpm_handle_t *handle, const char *logfile)
{
        char *oldlogfile = handle->logfile;

        CHECK_HANDLE(handle, return -1);
        if(!logfile) {
                handle->pm_errno = ALPM_ERR_WRONG_ARGS;
                return -1;
        }

        STRDUP(handle->logfile, logfile, RET_ERR(handle, ALPM_ERR_MEMORY, -1));

        /* free the old logfile path string, and close the stream so logaction
         * will reopen a new stream on the new logfile */
        if(oldlogfile) {
                FREE(oldlogfile);
        }
        if(handle->logstream) {
                fclose(handle->logstream);
                handle->logstream = NULL;
        }
        _alpm_log(handle, ALPM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
        return 0;
}

int SYMEXPORT alpm_option_set_gpgdir(alpm_handle_t *handle, const char *gpgdir)
{
        CHECK_HANDLE(handle, return -1);
        if(!gpgdir) {
                handle->pm_errno = ALPM_ERR_WRONG_ARGS;
                return -1;
        }

        if(handle->gpgdir) {
                FREE(handle->gpgdir);
        }
        STRDUP(handle->gpgdir, gpgdir, RET_ERR(handle, ALPM_ERR_MEMORY, -1));

        _alpm_log(handle, ALPM_LOG_DEBUG, "option 'gpgdir' = %s\n", handle->gpgdir);
        return 0;
}

int SYMEXPORT alpm_option_set_usesyslog(alpm_handle_t *handle, int usesyslog)
{
        CHECK_HANDLE(handle, return -1);
        handle->usesyslog = usesyslog;
        return 0;
}

static int _alpm_option_strlist_add(alpm_handle_t *handle, alpm_list_t **list, const char *str)
{
        char *dup;
        CHECK_HANDLE(handle, return -1);
        STRDUP(dup, str, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
        *list = alpm_list_add(*list, dup);
        return 0;
}

static int _alpm_option_strlist_set(alpm_handle_t *handle, alpm_list_t **list, alpm_list_t *newlist)
{
        CHECK_HANDLE(handle, return -1);
        FREELIST(*list);
        *list = alpm_list_strdup(newlist);
        return 0;
}

static int _alpm_option_strlist_rem(alpm_handle_t *handle, alpm_list_t **list, const char *str)
{
        char *vdata = NULL;
        CHECK_HANDLE(handle, return -1);
        *list = alpm_list_remove_str(*list, str, &vdata);
        if(vdata != NULL) {
                FREE(vdata);
                return 1;
        }
        return 0;
}

int SYMEXPORT alpm_option_add_noupgrade(alpm_handle_t *handle, const char *pkg)
{
        return _alpm_option_strlist_add(handle, &(handle->noupgrade), pkg);
}

int SYMEXPORT alpm_option_set_noupgrades(alpm_handle_t *handle, alpm_list_t *noupgrade)
{
        return _alpm_option_strlist_set(handle, &(handle->noupgrade), noupgrade);
}

int SYMEXPORT alpm_option_remove_noupgrade(alpm_handle_t *handle, const char *pkg)
{
        return _alpm_option_strlist_rem(handle, &(handle->noupgrade), pkg);
}

int SYMEXPORT alpm_option_match_noupgrade(alpm_handle_t *handle, const char *path)
{
        return _alpm_fnmatch_patterns(handle->noupgrade, path);
}

int SYMEXPORT alpm_option_add_noextract(alpm_handle_t *handle, const char *path)
{
        return _alpm_option_strlist_add(handle, &(handle->noextract), path);
}

int SYMEXPORT alpm_option_set_noextracts(alpm_handle_t *handle, alpm_list_t *noextract)
{
        return _alpm_option_strlist_set(handle, &(handle->noextract), noextract);
}

int SYMEXPORT alpm_option_remove_noextract(alpm_handle_t *handle, const char *path)
{
        return _alpm_option_strlist_rem(handle, &(handle->noextract), path);
}

int SYMEXPORT alpm_option_match_noextract(alpm_handle_t *handle, const char *path)
{
        return _alpm_fnmatch_patterns(handle->noextract, path);
}

int SYMEXPORT alpm_option_add_ignorepkg(alpm_handle_t *handle, const char *pkg)
{
        return _alpm_option_strlist_add(handle, &(handle->ignorepkg), pkg);
}

int SYMEXPORT alpm_option_set_ignorepkgs(alpm_handle_t *handle, alpm_list_t *ignorepkgs)
{
        return _alpm_option_strlist_set(handle, &(handle->ignorepkg), ignorepkgs);
}

int SYMEXPORT alpm_option_remove_ignorepkg(alpm_handle_t *handle, const char *pkg)
{
        return _alpm_option_strlist_rem(handle, &(handle->ignorepkg), pkg);
}

int SYMEXPORT alpm_option_add_ignoregroup(alpm_handle_t *handle, const char *grp)
{
        return _alpm_option_strlist_add(handle, &(handle->ignoregroup), grp);
}

int SYMEXPORT alpm_option_set_ignoregroups(alpm_handle_t *handle, alpm_list_t *ignoregrps)
{
        return _alpm_option_strlist_set(handle, &(handle->ignoregroup), ignoregrps);
}

int SYMEXPORT alpm_option_remove_ignoregroup(alpm_handle_t *handle, const char *grp)
{
        return _alpm_option_strlist_rem(handle, &(handle->ignoregroup), grp);
}

int SYMEXPORT alpm_option_add_assumeinstalled(alpm_handle_t *handle, const alpm_depend_t *dep)
{
        CHECK_HANDLE(handle, return -1);

        handle->assumeinstalled = alpm_list_add(handle->assumeinstalled, (void *)dep);
        return 0;
}

int SYMEXPORT alpm_option_set_assumeinstalled(alpm_handle_t *handle, alpm_list_t *deps)
{
        CHECK_HANDLE(handle, return -1);
        if(handle->assumeinstalled) {
                alpm_list_free_inner(handle->assumeinstalled, (alpm_list_fn_free)alpm_dep_free);
                alpm_list_free(handle->assumeinstalled);
        }
        handle->assumeinstalled = deps;
        return 0;
}

static int assumeinstalled_cmp(const void *d1, const void *d2)
{
        const alpm_depend_t *dep1 = d1;
        const alpm_depend_t *dep2 = d2;

        if(strcmp(dep1->name, dep2->name) == 0 && strcmp(dep1->version, dep2->version) == 0) {
                return 0;
        }

        return -1;
}

int SYMEXPORT alpm_option_remove_assumeinstalled(alpm_handle_t *handle, const alpm_depend_t *dep)
{
        alpm_depend_t *vdata = NULL;
        CHECK_HANDLE(handle, return -1);

        handle->assumeinstalled = alpm_list_remove(handle->assumeinstalled, dep, &assumeinstalled_cmp, (void **)&vdata);
        if(vdata != NULL) {
                alpm_dep_free(vdata);
                return 1;
        }

        return 0;
}

int SYMEXPORT alpm_option_set_arch(alpm_handle_t *handle, const char *arch)
{
        CHECK_HANDLE(handle, return -1);
        if(handle->arch) FREE(handle->arch);
        STRDUP(handle->arch, arch, RET_ERR(handle, ALPM_ERR_MEMORY, -1));
        return 0;
}

int SYMEXPORT alpm_option_set_deltaratio(alpm_handle_t *handle, double ratio)
{
        CHECK_HANDLE(handle, return -1);
        if(ratio < 0.0 || ratio > 2.0) {
                RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1);
        }
        handle->deltaratio = ratio;
        return 0;
}

alpm_db_t SYMEXPORT *alpm_get_localdb(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->db_local;
}

alpm_list_t SYMEXPORT *alpm_get_syncdbs(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return NULL);
        return handle->dbs_sync;
}

int SYMEXPORT alpm_option_set_checkspace(alpm_handle_t *handle, int checkspace)
{
        CHECK_HANDLE(handle, return -1);
        handle->checkspace = checkspace;
        return 0;
}

int SYMEXPORT alpm_option_set_dbext(alpm_handle_t *handle, const char *dbext)
{
        CHECK_HANDLE(handle, return -1);
        ASSERT(dbext, RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1));

        if(handle->dbext) {
                FREE(handle->dbext);
        }

        STRDUP(handle->dbext, dbext, RET_ERR(handle, ALPM_ERR_MEMORY, -1));

        _alpm_log(handle, ALPM_LOG_DEBUG, "option 'dbext' = %s\n", handle->dbext);
        return 0;
}

int SYMEXPORT alpm_option_set_default_siglevel(alpm_handle_t *handle,
                alpm_siglevel_t level)
{
        CHECK_HANDLE(handle, return -1);
#ifdef HAVE_LIBGPGME
        handle->siglevel = level;
#else
        if(level != 0 && level != ALPM_SIG_USE_DEFAULT) {
                RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1);
        }
#endif
        return 0;
}

alpm_siglevel_t SYMEXPORT alpm_option_get_default_siglevel(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return -1);
        return handle->siglevel;
}

int SYMEXPORT alpm_option_set_local_file_siglevel(alpm_handle_t *handle,
                alpm_siglevel_t level)
{
        CHECK_HANDLE(handle, return -1);
#ifdef HAVE_LIBGPGME
        handle->localfilesiglevel = level;
#else
        if(level != 0 && level != ALPM_SIG_USE_DEFAULT) {
                RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1);
        }
#endif
        return 0;
}

alpm_siglevel_t SYMEXPORT alpm_option_get_local_file_siglevel(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return -1);
        if(handle->localfilesiglevel & ALPM_SIG_USE_DEFAULT) {
                return handle->siglevel;
        } else {
                return handle->localfilesiglevel;
        }
}

int SYMEXPORT alpm_option_set_remote_file_siglevel(alpm_handle_t *handle,
                alpm_siglevel_t level)
{
        CHECK_HANDLE(handle, return -1);
#ifdef HAVE_LIBGPGME
        handle->remotefilesiglevel = level;
#else
        if(level != 0 && level != ALPM_SIG_USE_DEFAULT) {
                RET_ERR(handle, ALPM_ERR_WRONG_ARGS, -1);
        }
#endif
        return 0;
}

alpm_siglevel_t SYMEXPORT alpm_option_get_remote_file_siglevel(alpm_handle_t *handle)
{
        CHECK_HANDLE(handle, return -1);
        if(handle->remotefilesiglevel & ALPM_SIG_USE_DEFAULT) {
                return handle->siglevel;
        } else {
                return handle->remotefilesiglevel;
        }
}

/* vim: set noet: */