/* * add.c * * Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.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, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, * USA. */ #include "config.h" #include <stdlib.h> #include <errno.h> #include <time.h> #include <fcntl.h> #include <string.h> #ifdef CYGWIN #include <limits.h> /* PATH_MAX */ #endif #include <zlib.h> #include <libtar.h> /* pacman */ #include "util.h" #include "error.h" #include "list.h" #include "cache.h" #include "versioncmp.h" #include "md5.h" #include "log.h" #include "backup.h" #include "package.h" #include "db.h" #include "provide.h" #include "conflict.h" #include "trans.h" #include "deps.h" #include "add.h" #include "remove.h" #include "handle.h" extern pmhandle_t *handle; int add_loadtarget(pmtrans_t *trans, pmdb_t *db, char *name) { pmpkg_t *info = NULL; pmpkg_t *dummy; char pkgname[PKG_NAME_LEN], pkgver[PKG_VERSION_LEN]; PMList *i; struct stat buf; ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1)); ASSERT(name != NULL && strlen(name) != 0, RET_ERR(PM_ERR_WRONG_ARGS, -1)); /* Check if we need to add a fake target to the transaction. * format: field1=value1|field2=value2|... * Supported fields are "name", "version", "depend" * A fake package is created with the given tokens (name and version are * required). */ if(strchr(name, '|')) { char *str, *ptr, *p; dummy = pkg_new(NULL, NULL); if(dummy == NULL) { pm_errno = PM_ERR_MEMORY; goto error; } str = strdup(name); ptr = str; while((p = strsep(&ptr, "|")) != NULL) { char *q; if(p[0] == 0) { continue; } q = strchr(p, '='); if(q == NULL) { /* not a valid token */ continue; } if(strncmp("name", p, q-p) == 0) { STRNCPY(dummy->name, q+1, PKG_NAME_LEN); } else if(strncmp("version", p, q-p) == 0) { STRNCPY(dummy->version, q+1, PKG_VERSION_LEN); } else if(strncmp("depend", p, q-p) == 0) { dummy->depends = pm_list_add(dummy->depends, strdup(q+1)); } else { _alpm_log(PM_LOG_ERROR, "could not parse token %s", p); } } FREE(str); if(dummy->name[0] == 0 || dummy->version[0] == 0) { pm_errno = PM_ERR_PKG_INVALID_NAME; FREEPKG(dummy); goto error; } /* add the package to the transaction */ trans->packages = pm_list_add(trans->packages, dummy); return(0); } _alpm_log(PM_LOG_FLOW2, "loading target %s", name); if(stat(name, &buf)) { pm_errno = PM_ERR_NOT_A_FILE; goto error; } if(pkg_splitname(name, pkgname, pkgver) == -1) { pm_errno = PM_ERR_PKG_INVALID_NAME; goto error; } /* no additional hyphens in version strings */ if(strchr(pkgver, '-') != strrchr(pkgver, '-')) { pm_errno = PM_ERR_PKG_INVALID_NAME; goto error; } if(trans->type != PM_TRANS_TYPE_UPGRADE) { /* only install this package if it is not already installed */ dummy = db_get_pkgfromcache(db, pkgname); if(dummy) { pm_errno = PM_ERR_PKG_INSTALLED; goto error; } } else { if(trans->flags & PM_TRANS_FLAG_FRESHEN) { /* only upgrade/install this package if it is already installed and at a lesser version */ dummy = db_get_pkgfromcache(db, pkgname); if(dummy == NULL || versioncmp(dummy->version, pkgver) >= 0) { pm_errno = PM_ERR_PKG_CANT_FRESH; goto error; } } } /* check if an older version of said package is already in transaction packages. * if so, replace it in the list */ for(i = trans->packages; i; i = i->next) { pmpkg_t *pkg = i->data; if(strcmp(pkg->name, pkgname) == 0) { if(versioncmp(pkg->version, pkgver) < 0) { pmpkg_t *newpkg; _alpm_log(PM_LOG_WARNING, "replacing older version of %s %s by %s in target list", pkg->name, pkg->version, pkgver); newpkg = pkg_load(name); if(newpkg == NULL) { /* pm_errno is already set by pkg_load() */ goto error; } FREEPKG(i->data); i->data = newpkg; } return(0); } } _alpm_log(PM_LOG_FLOW2, "reading %s", name); info = pkg_load(name); if(info == NULL) { /* pm_errno is already set by pkg_load() */ goto error; } /* check to verify we're not getting fooled by a corrupted package */ if(strcmp(pkgname, info->name) != 0 || strcmp(pkgver, info->version) != 0) { pm_errno = PM_ERR_PKG_INVALID; goto error; } if(trans->flags & PM_TRANS_FLAG_ALLDEPS) { info->reason = PM_PKG_REASON_DEPEND; } /* add the package to the transaction */ trans->packages = pm_list_add(trans->packages, info); return(0); error: FREEPKG(info); return(-1); } int add_prepare(pmtrans_t *trans, pmdb_t *db, PMList **data) { PMList *lp; ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1)); /* Check dependencies */ if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) { EVENT(trans, PM_TRANS_EVT_CHECKDEPS_START, NULL, NULL); /* look for unsatisfied dependencies */ _alpm_log(PM_LOG_FLOW1, "looking for unsatisfied dependencies"); lp = checkdeps(db, trans->type, trans->packages); if(lp != NULL) { if(data) { *data = lp; } else { FREELIST(lp); } RET_ERR(PM_ERR_UNSATISFIED_DEPS, -1); } /* no unsatisfied deps, so look for conflicts */ _alpm_log(PM_LOG_FLOW1, "looking for conflicts"); lp = checkconflicts(db, trans->packages); if(lp != NULL) { if(data) { *data = lp; } else { FREELIST(lp); } RET_ERR(PM_ERR_CONFLICTING_DEPS, -1); } /* re-order w.r.t. dependencies */ _alpm_log(PM_LOG_FLOW1, "sorting by dependencies"); lp = sortbydeps(trans->packages, PM_TRANS_TYPE_ADD); /* free the old alltargs */ FREELISTPTR(trans->packages); trans->packages = lp; EVENT(trans, PM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL); } /* Check for file conflicts */ if(!(trans->flags & PM_TRANS_FLAG_FORCE)) { PMList *skiplist = NULL; EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL); _alpm_log(PM_LOG_FLOW1, "looking for file conflicts"); lp = db_find_conflicts(db, trans->packages, handle->root, &skiplist); if(lp != NULL) { if(data) { *data = lp; } else { FREELIST(lp); } FREELIST(skiplist); RET_ERR(PM_ERR_FILE_CONFLICTS, -1); } /* copy the file skiplist into the transaction */ trans->skiplist = skiplist; EVENT(trans, PM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL); } return(0); } int add_commit(pmtrans_t *trans, pmdb_t *db) { int i, ret = 0, errors = 0; TAR *tar = NULL; char expath[PATH_MAX]; time_t t; PMList *targ, *lp; ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1)); if(trans->packages == NULL) { return(0); } for(targ = trans->packages; targ; targ = targ->next) { tartype_t gztype = { (openfunc_t)_alpm_gzopen_frontend, (closefunc_t)gzclose, (readfunc_t)gzread, (writefunc_t)gzwrite }; unsigned short pmo_upgrade; char pm_install[PATH_MAX]; pmpkg_t *info = (pmpkg_t *)targ->data; pmpkg_t *oldpkg = NULL; errors = 0; pmo_upgrade = (trans->type == PM_TRANS_TYPE_UPGRADE) ? 1 : 0; /* see if this is an upgrade. if so, remove the old package first */ if(pmo_upgrade) { pmpkg_t *local = db_get_pkgfromcache(db, info->name); if(local) { EVENT(trans, PM_TRANS_EVT_UPGRADE_START, info, NULL); _alpm_log(PM_LOG_FLOW1, "upgrading package %s-%s", info->name, info->version); /* we'll need to save some record for backup checks later */ oldpkg = pkg_new(local->name, local->version); if(oldpkg) { if(!(local->infolevel & INFRQ_FILES)) { char name[PKG_FULLNAME_LEN]; snprintf(name, PKG_FULLNAME_LEN, "%s-%s", local->name, local->version); _alpm_log(PM_LOG_DEBUG, "loading FILES info for %s", local->name); db_read(db, name, INFRQ_FILES, local); } oldpkg->backup = _alpm_list_strdup(local->backup); } /* pre_upgrade scriptlet */ if(info->scriptlet) { _alpm_runscriptlet(handle->root, info->data, "pre_upgrade", info->version, oldpkg ? oldpkg->version : NULL); } if(oldpkg) { pmtrans_t *tr; _alpm_log(PM_LOG_FLOW1, "removing old package first (%s-%s)", oldpkg->name, oldpkg->version); tr = trans_new(); if(tr == NULL) { RET_ERR(PM_ERR_TRANS_ABORT, -1); } if(trans_init(tr, PM_TRANS_TYPE_UPGRADE, trans->flags, NULL, NULL) == -1) { FREETRANS(tr); RET_ERR(PM_ERR_TRANS_ABORT, -1); } /* copy over the install reason */ info->reason = local->reason; if(remove_loadtarget(tr, db, info->name) == -1) { FREETRANS(tr); RET_ERR(PM_ERR_TRANS_ABORT, -1); } /* copy the skiplist over */ tr->skiplist = _alpm_list_strdup(trans->skiplist); if(remove_commit(tr, db) == -1) { FREETRANS(tr); RET_ERR(PM_ERR_TRANS_ABORT, -1); } FREETRANS(tr); } } else { /* no previous package version is installed, so this is actually * just an install. */ pmo_upgrade = 0; } } if(!pmo_upgrade) { EVENT(trans, PM_TRANS_EVT_ADD_START, info, NULL); _alpm_log(PM_LOG_FLOW1, "adding package %s-%s", info->name, info->version); /* pre_install scriptlet */ if(info->scriptlet) { _alpm_runscriptlet(handle->root, info->data, "pre_install", info->version, NULL); } } else { _alpm_log(PM_LOG_FLOW1, "adding new package (%s-%s)", info->name, info->version); } if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) { _alpm_log(PM_LOG_FLOW1, "extracting files"); /* Extract the .tar.gz package */ if(tar_open(&tar, info->data, &gztype, O_RDONLY, 0, TAR_GNU) == -1) { RET_ERR(PM_ERR_PKG_OPEN, -1); } for(i = 0; !th_read(tar); i++) { int nb = 0; int notouch = 0; char *md5_orig = NULL; char pathname[PATH_MAX]; struct stat buf; STRNCPY(pathname, th_get_pathname(tar), PATH_MAX); if(!strcmp(pathname, ".PKGINFO") || !strcmp(pathname, ".FILELIST")) { tar_skip_regfile(tar); continue; } if(!strcmp(pathname, "._install") || !strcmp(pathname, ".INSTALL")) { /* the install script goes inside the db */ snprintf(expath, PATH_MAX, "%s/%s-%s/install", db->path, info->name, info->version); } else { /* build the new pathname relative to handle->root */ snprintf(expath, PATH_MAX, "%s%s", handle->root, pathname); } /* if a file is in NoExtract then we never extract it. * * eg, /home/httpd/html/index.html may be removed so index.php * could be used. */ if(pm_list_is_strin(pathname, handle->noextract)) { alpm_logaction("notice: %s is in NoExtract -- skipping extraction", pathname); tar_skip_regfile(tar); continue; } if(!stat(expath, &buf) && !S_ISDIR(buf.st_mode)) { /* file already exists */ if(pm_list_is_strin(pathname, handle->noupgrade)) { notouch = 1; } else { if(!pmo_upgrade || oldpkg == NULL) { nb = pm_list_is_strin(pathname, info->backup) ? 1 : 0; } else { /* op == PM_TRANS_TYPE_UPGRADE */ md5_orig = _alpm_needbackup(pathname, oldpkg->backup); if(md5_orig) { nb = 1; } } } } if(nb) { char *temp; char *md5_local, *md5_pkg; int fd; /* extract the package's version to a temporary file and md5 it */ temp = strdup("/tmp/alpm_XXXXXX"); fd = mkstemp(temp); if(tar_extract_file(tar, temp)) { alpm_logaction("could not extract %s (%s)", pathname, strerror(errno)); errors++; unlink(temp); FREE(temp); FREE(md5_orig); close(fd); continue; } md5_local = MDFile(expath); md5_pkg = MDFile(temp); /* append the new md5 hash to it's respective entry in info->backup * (it will be the new orginal) */ for(lp = info->backup; lp; lp = lp->next) { char *file = lp->data; if(!file) { continue; } if(!strcmp(file, pathname)) { char *fn; /* 32 for the hash, 1 for the terminating NULL, and 1 for the tab delimiter */ MALLOC(fn, strlen(file)+34); sprintf(fn, "%s\t%s", file, md5_pkg); FREE(file); lp->data = fn; } } _alpm_log(PM_LOG_DEBUG, "checking md5 hashes for %s", pathname); _alpm_log(PM_LOG_DEBUG, "current: %s", md5_local); _alpm_log(PM_LOG_DEBUG, "new: %s", md5_pkg); if(md5_orig) { _alpm_log(PM_LOG_DEBUG, "original: %s", md5_orig); } if(!pmo_upgrade) { /* PM_ADD */ /* if a file already exists with a different md5 hash, * then we rename it to a .pacorig extension and continue */ if(strcmp(md5_local, md5_pkg)) { char newpath[PATH_MAX]; snprintf(newpath, PATH_MAX, "%s.pacorig", expath); if(rename(expath, newpath)) { _alpm_log(PM_LOG_ERROR, "could not rename %s (%s)", pathname, strerror(errno)); alpm_logaction("error: could not rename %s (%s)", expath, strerror(errno)); } if(_alpm_copyfile(temp, expath)) { _alpm_log(PM_LOG_ERROR, "could not copy %s to %s (%s)", temp, pathname, strerror(errno)); alpm_logaction("error: could not copy %s to %s (%s)", temp, expath, strerror(errno)); errors++; } else { _alpm_log(PM_LOG_WARNING, "%s saved as %s.pacorig", pathname, pathname); alpm_logaction("warning: %s saved as %s", expath, newpath); } } } else if(md5_orig) { /* PM_UPGRADE */ int installnew = 0; /* the fun part */ if(!strcmp(md5_orig, md5_local)) { if(!strcmp(md5_local, md5_pkg)) { _alpm_log(PM_LOG_DEBUG, "action: installing new file"); installnew = 1; } else { _alpm_log(PM_LOG_DEBUG, "action: installing new file"); installnew = 1; } } else if(!strcmp(md5_orig, md5_pkg)) { _alpm_log(PM_LOG_DEBUG, "action: leaving existing file in place"); } else if(!strcmp(md5_local, md5_pkg)) { _alpm_log(PM_LOG_DEBUG, "action: installing new file"); installnew = 1; } else { _alpm_log(PM_LOG_DEBUG, "action: leaving file in place, installing new one as .pacnew\n"); strncat(expath, ".pacnew", PATH_MAX); installnew = 1; _alpm_log(PM_LOG_WARNING, "extracting %s as %s.pacnew", pathname, pathname); alpm_logaction("warning: extracting %s%s as %s", handle->root, pathname, expath); } if(installnew) { /*_alpm_log(PM_LOG_FLOW2, " %s", expath);*/ if(_alpm_copyfile(temp, expath)) { _alpm_log(PM_LOG_ERROR, "could not copy %s to %s (%s)", temp, pathname, strerror(errno)); errors++; } } } FREE(md5_local); FREE(md5_pkg); FREE(md5_orig); unlink(temp); FREE(temp); close(fd); } else { if(!notouch) { _alpm_log(PM_LOG_FLOW2, "extracting %s", pathname); } else { _alpm_log(PM_LOG_FLOW2, "%s is in NoUpgrade -- skipping", pathname); strncat(expath, ".pacnew", PATH_MAX); _alpm_log(PM_LOG_WARNING, "extracting %s as %s.pacnew", pathname, pathname); alpm_logaction("warning: extracting %s%s as %s", handle->root, pathname, expath); /*tar_skip_regfile(tar);*/ } if(trans->flags & PM_TRANS_FLAG_FORCE) { /* if FORCE was used, then unlink() each file (whether it's there * or not) before extracting. this prevents the old "Text file busy" * error that crops up if one tries to --force a glibc or pacman * upgrade. */ unlink(expath); } if(tar_extract_file(tar, expath)) { _alpm_log(PM_LOG_ERROR, "could not extract %s (%s)", pathname, strerror(errno)); alpm_logaction("could not extract %s (%s)", pathname, strerror(errno)); errors++; } /* calculate an md5 hash if this is in info->backup */ for(lp = info->backup; lp; lp = lp->next) { char *fn, *md5; char path[PATH_MAX]; char *file = lp->data; if(!file) continue; if(!strcmp(file, pathname)) { snprintf(path, PATH_MAX, "%s%s", handle->root, file); md5 = MDFile(path); /* 32 for the hash, 1 for the terminating NULL, and 1 for the tab delimiter */ MALLOC(fn, strlen(file)+34); sprintf(fn, "%s\t%s", file, md5); FREE(md5); FREE(file); lp->data = fn; } } } } tar_close(tar); if(errors) { ret = 1; _alpm_log(PM_LOG_ERROR, "errors occurred while %s %s", (pmo_upgrade ? "upgrading" : "installing"), info->name); alpm_logaction("errors occurred while %s %s", (pmo_upgrade ? "upgrading" : "installing"), info->name); } } /* Add the package to the database */ t = time(NULL); /* Update the requiredby field by scanning the whole database * looking for packages depending on the package to add */ for(lp = db_get_pkgcache(db); lp; lp = lp->next) { pmpkg_t *tmpp = lp->data; PMList *tmppm = NULL; if(tmpp == NULL) { continue; } for(tmppm = tmpp->depends; tmppm; tmppm = tmppm->next) { pmdepend_t depend; if(splitdep(tmppm->data, &depend)) { continue; } if(tmppm->data && !strcmp(depend.name, info->name)) { _alpm_log(PM_LOG_DEBUG, "adding '%s' in requiredby field for '%s'", tmpp->name, info->name); info->requiredby = pm_list_add(info->requiredby, strdup(tmpp->name)); } } } /* make an install date (in UTC) */ STRNCPY(info->installdate, asctime(gmtime(&t)), sizeof(info->installdate)); /* remove the extra line feed appended by asctime() */ info->installdate[strlen(info->installdate)-1] = 0; _alpm_log(PM_LOG_FLOW1, "updating database"); _alpm_log(PM_LOG_FLOW2, "adding database entry '%s'", info->name); if(db_write(db, info, INFRQ_ALL)) { _alpm_log(PM_LOG_ERROR, "could not update database entry '%s-%s'", info->name, info->version); alpm_logaction(NULL, "error updating database for %s-%s!", info->name, info->version); RET_ERR(PM_ERR_DB_WRITE, -1); } if(db_add_pkgincache(db, info) == -1) { _alpm_log(PM_LOG_ERROR, "could not add entry %s in cache", info->name); } /* update dependency packages' REQUIREDBY fields */ if(info->depends) { _alpm_log(PM_LOG_FLOW2, "updating dependency packages 'requiredby' fields"); } for(lp = info->depends; lp; lp = lp->next) { pmpkg_t *depinfo; pmdepend_t depend; if(splitdep(lp->data, &depend)) { continue; } depinfo = db_get_pkgfromcache(db, depend.name); if(depinfo == NULL) { /* look for a provides package */ PMList *provides = _alpm_db_whatprovides(db, depend.name); if(provides) { /* TODO: should check _all_ packages listed in provides, not just * the first one. */ /* use the first one */ depinfo = db_get_pkgfromcache(db, ((pmpkg_t *)provides->data)->name); FREELISTPTR(provides); } if(depinfo == NULL) { _alpm_log(PM_LOG_ERROR, "could not find dependency '%s'", depend.name); /* wtf */ continue; } } _alpm_log(PM_LOG_DEBUG, "adding '%s' in requiredby field for '%s'", info->name, depinfo->name); depinfo->requiredby = pm_list_add(depinfo->requiredby, strdup(info->name)); if(db_write(db, depinfo, INFRQ_DEPENDS)) { _alpm_log(PM_LOG_ERROR, "could not update 'requiredby' database entry '%s-%s'", depinfo->name, depinfo->version); } } /* run the post-install script if it exists */ if(info->scriptlet) { snprintf(pm_install, PATH_MAX, "%s%s/%s/%s-%s/install", handle->root, handle->dbpath, db->treename, info->name, info->version); if(pmo_upgrade) { _alpm_runscriptlet(handle->root, pm_install, "post_upgrade", info->version, oldpkg ? oldpkg->version : NULL); } else { _alpm_runscriptlet(handle->root, pm_install, "post_install", info->version, NULL); } } EVENT(trans, (pmo_upgrade) ? PM_TRANS_EVT_UPGRADE_DONE : PM_TRANS_EVT_ADD_DONE, info, oldpkg); FREEPKG(oldpkg); } /* run ldconfig if it exists */ _alpm_log(PM_LOG_FLOW1, "running \"ldconfig -r %s\"", handle->root); _alpm_ldconfig(handle->root); return(0); } /* vim: set ts=2 sw=2 noet: */