pacman/lib/libalpm/add.c

/*
 *  add.c
 * 
 *  Copyright (c) 2002-2005 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>
#include <zlib.h>
#include <libtar.h>
/* pacman */
#include "util.h"
#include "error.h"
#include "list.h"
#include "cache.h"
#include "rpmvercmp.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(pmdb_t *db, pmtrans_t *trans, char *name)
{
	pmpkg_t *info, *dummy;
	PMList *j;

	ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
	ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
	ASSERT(name != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));

	/* ORE
	load_pkg should be done only if pkg has to be added to the transaction */

	_alpm_log(PM_LOG_FLOW2, "reading %s", name);
	info = pkg_load(name);
	if(info == NULL) {
		/* pm_errno is already set by pkg_load() */
		return(-1);
	}

	/* no additional hyphens in version strings */
	if(strchr(info->version, '-') != strrchr(info->version, '-')) {
		pm_errno = PM_ERR_INVALID_NAME;
		goto error;
	}

	dummy = db_get_pkgfromcache(db, info->name);
	/* only upgrade/install this package if it is already installed and at a lesser version */
	if(trans->flags & PM_TRANS_FLAG_FRESHEN) {
		if(dummy == NULL || rpmvercmp(dummy->version, info->version) >= 0) {
			pm_errno = PM_ERR_PKG_CANT_FRESH;
			goto error;
		}
	}
	/* only install this package if it is not already installed */
	if(trans->type != PM_TRANS_TYPE_UPGRADE) {
		if(dummy) {
			pm_errno = PM_ERR_PKG_INSTALLED;
			goto error;
		}
	}

	/* check if an older version of said package is already in transaction packages.
	 * if so, replace it in the list */
	/* ORE
	we'd better do it before load_pkg. */
	for(j = trans->packages; j; j = j->next) {
		pmpkg_t *pkg = j->data;

		if(strcmp(pkg->name, info->name) == 0) {
			if(rpmvercmp(pkg->version, info->version) < 0) {
				_alpm_log(PM_LOG_WARNING, "replacing older version of %s %s by %s in target list", pkg->name, pkg->version, info->version);
				FREEPKG(j->data);
				j->data = info;
				return(0);
			} else {
				pm_errno = PM_ERR_TRANS_DUP_TARGET;
				goto error;
			}
		}
	}

	/* add the package to the transaction */
	trans->packages = pm_list_add(trans->packages, info);

	return(0);

error:
	FREEPKG(info);
	return(-1);
}

int add_prepare(pmdb_t *db, pmtrans_t *trans, PMList **data)
{
	PMList *lp;

	*data = NULL;

	ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
	ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
	ASSERT(data != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));

	/* Check dependencies
	 */

	/* ORE ???
	No need to check deps if pacman_add was called during a sync:
	it is already done in pacman_sync */
	if(!(trans->flags & PM_TRANS_FLAG_NODEPS)) {
		PMList *j;

		TRANS_CB(trans, PM_TRANS_EVT_DEPS_START, NULL, NULL);

		_alpm_log(PM_LOG_FLOW1, "looking for conflicts or unsatisfied dependencies");
		lp = checkdeps(db, trans->type, trans->packages);
		if(lp != NULL) {
			int errorout = 0;

			/* look for unsatisfied dependencies */
			_alpm_log(PM_LOG_FLOW2, "looking for unsatisfied dependencies");
			for(j = lp; j; j = j->next) {
				pmdepmissing_t* miss = j->data;

				if(miss->type == PM_DEP_DEPEND || miss->type == PM_DEP_REQUIRED) {
					if(!errorout) {
						errorout = 1;
					}
					if((miss = (pmdepmissing_t *)malloc(sizeof(pmdepmissing_t))) == NULL) {
						FREELIST(lp);
						/* ORE, needed or not ?
						FREELIST(*data);*/
						RET_ERR(PM_ERR_MEMORY, -1);
					}
					*miss = *(pmdepmissing_t*)j->data;
					*data = pm_list_add(*data, miss);
				}
			}
			if(errorout) {
				FREELIST(lp);
				RET_ERR(PM_ERR_UNSATISFIED_DEPS, -1);
			}

			/* no unsatisfied deps, so look for conflicts */
			_alpm_log(PM_LOG_FLOW2, "looking for conflicts");
			for(j = lp; j; j = j->next) {
				pmdepmissing_t* miss = (pmdepmissing_t *)j->data;
				if(miss->type == PM_DEP_CONFLICT) {
					if(!errorout) {
						errorout = 1;
					}
					MALLOC(miss, sizeof(pmdepmissing_t));
					*miss = *(pmdepmissing_t*)j->data;
					*data = pm_list_add(*data, miss);
				}
			}
			if(errorout) {
				FREELIST(lp);
				RET_ERR(PM_ERR_CONFLICTING_DEPS, -1);
			}
			FREELIST(lp);
		}

		/* 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;

		TRANS_CB(trans, PM_TRANS_EVT_DEPS_DONE, NULL, NULL);
	}

	/* Check for file conflicts
	 */
	if(!(trans->flags & PM_TRANS_FLAG_FORCE)) {
		TRANS_CB(trans, PM_TRANS_EVT_CONFLICTS_START, NULL, NULL);

		_alpm_log(PM_LOG_FLOW1, "looking for file conflicts");
		lp = db_find_conflicts(db, trans->packages, handle->root);
		if(lp != NULL) {
			*data = lp;
			RET_ERR(PM_ERR_FILE_CONFLICTS, -1);
		}

		TRANS_CB(trans, PM_TRANS_EVT_CONFLICTS_DONE, NULL, NULL);
	}

	return(0);
}

int add_commit(pmdb_t *db, pmtrans_t *trans)
{
	int i, ret = 0, errors = 0;
	TAR *tar = NULL;
	char expath[PATH_MAX];
	time_t t;
	pmpkg_t *info = NULL;
	PMList *targ, *lp;

	ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
	ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_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 *oldpkg = NULL;
		info = (pmpkg_t *)targ->data;
		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) {
			if(pkg_isin(info, db_get_pkgcache(db))) {
				TRANS_CB(trans, PM_TRANS_EVT_UPGRADE_START, info, NULL);
				_alpm_log(PM_LOG_FLOW1, "upgrading package %s-%s", info->name, info->version);

				/* we'll need the full record for backup checks later */
				/* ORE
				in fact, there's only a need for "backup" and "md5sum" fields, so
				we should only copy these 2 ones from info, and thus save a call
				to db_scan(ALL) */
				oldpkg = db_scan(db, info->name, INFRQ_ALL);

				/* 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");
					/* ORE
					set flags to something, but what (nodeps?) ??? */
					tr = trans_new();
					if(tr == NULL) {
						RET_ERR(PM_ERR_TRANS_ABORT, -1);
					}
					if(trans_init(tr, PM_TRANS_TYPE_UPGRADE, 0, NULL) == -1) {
						FREETRANS(tr);
						RET_ERR(PM_ERR_TRANS_ABORT, -1);
					}
					/* copy over the install reason */
					/* ORE?
					info->reason = oldpkg->reason; */
					if(remove_loadtarget(db, tr, info->name) == -1) {
						FREETRANS(tr);
						RET_ERR(PM_ERR_TRANS_ABORT, -1);
					}
					if(remove_commit(db, tr) == -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) {
			TRANS_CB(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);
			}
		}

		/* Add the package to the database */
		t = time(NULL);

		/* Update the requiredby field by scaning 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 = NULL;
			PMList *tmppm = NULL;

			/* ORE
			is it useful to call db_scan(DEPENDS)?
			depends info are already stored in the cache... */
			tmpp = db_scan(db, ((pmpkg_t *)lp->data)->name, INFRQ_DEPENDS);
			if(tmpp == NULL) {
				continue;
			}
			for(tmppm = tmpp->depends; tmppm; tmppm = tmppm->next) {
				pmdepend_t depend;
				splitdep(tmppm->data, &depend);
				if(tmppm->data && !strcmp(depend.name, info->name)) {
					info->requiredby = pm_list_add(info->requiredby, strdup(tmpp->name));
					continue;
				}
			}
		}

		_alpm_log(PM_LOG_FLOW1, "adding database entry %s-%s", info->name, info->version);
		/* Figure out whether this package was installed explicitly by the user
		 * or installed as a dependency for another package
		 */
		info->reason = PM_PKG_REASON_EXPLICIT;
		/* ORE
		only relevant for sync operations?
		usage of info->data should be ok for TRANS_TYPE_ADD, but wrong for
		TRANS_TYPE_SYNC
		if(pm_list_is_strin(trans->targets, info->data) || pmo_d_resolve) {
			info->reason = PM_PKG_REASON_DEPEND;
		}*/
		/* make an install date (in UTC) */
		STRNCPY(info->installdate, asctime(gmtime(&t)), sizeof(info->installdate));
		if(db_write(db, info, INFRQ_ALL)) {
			_alpm_log(PM_LOG_ERROR, "could not update database entry %s/%s-%s", db->treename, info->name, info->version);
			alpm_logaction(NULL, "error updating database for %s-%s!", info->name, info->version);
			RET_ERR(PM_ERR_DB_WRITE, -1);
		}

		/* ORE
		in case of an installation, then add info in the pkgcache
		in case of an upgrade, then replace the existing one (or just add because
		trans_remove should already has removed it? */

		/* update dependency packages' REQUIREDBY fields */
		_alpm_log(PM_LOG_FLOW2, "updating dependency packages 'requiredby' fields");
		for(lp = info->depends; lp; lp = lp->next) {
			pmpkg_t *depinfo = NULL;
			pmdepend_t depend;

			if(splitdep(lp->data, &depend)) {
				continue;
			}

			/* ORE
			same thing here: we should browse the cache instead of using db_scan */
			depinfo = db_scan(db, depend.name, INFRQ_DESC|INFRQ_DEPENDS);
			if(depinfo == NULL) {
				/* look for a provides package */
				/* ORE
				_alpm_db_whatprovides() should return a list of pointer to pkg from the
				cache, thus eliminating the need for db_scan(DEPENDS) */
				PMList *provides = _alpm_db_whatprovides(db, depend.name);
				if(provides) {
					/* use the first one */
					depinfo = db_scan(db, ((pmpkg_t *)provides->data)->name, INFRQ_DESC|INFRQ_DEPENDS);
					FREELISTPTR(provides);
					if(depinfo == NULL) {
						/* wtf */
						continue;
					}
				} else {
					continue;
				}
			}
			/* ORE
			if depinfo points on a package from the cache, the cache will be updated
			automatically here! */
			depinfo->requiredby = pm_list_add(depinfo->requiredby, strdup(info->name));
			_alpm_log(PM_LOG_DEBUG, "updating 'requiredby' field for package %s", depinfo->name);
			if(db_write(db, depinfo, INFRQ_DEPENDS)) {
				_alpm_log(PM_LOG_ERROR, "could not update 'requiredby' database entry %s/%s-%s", db->treename, depinfo->name, depinfo->version);
			}
			FREEPKG(depinfo);
		}

		/* 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);
		}
		_alpm_log(PM_LOG_FLOW1, "extracting files");
		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(!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 */
						if((md5_orig = _alpm_needbackup(pathname, oldpkg->backup)) != 0) {
							nb = 1;
						}
					}
				}
			}

			if(nb) {
				char *temp;
				char *md5_local, *md5_pkg;

				md5_local = MDFile(expath);
				/* extract the package's version to a temporary file and md5 it */
				temp = strdup("/tmp/alpm_XXXXXX");
				mkstemp(temp);
				if(tar_extract_file(tar, temp)) {
					alpm_logaction("could not extract %s: %s", pathname, strerror(errno));
					errors++;
					continue;
				}
				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 *fn;
					char *file = lp->data;

					if(!file) continue;
					if(!strcmp(file, pathname)) {
						/* 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 {
						char newpath[PATH_MAX];
						_alpm_log(PM_LOG_DEBUG, " action: saving current file and installing new one");
						installnew = 1;
						snprintf(newpath, PATH_MAX, "%s.pacsave", 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));
						} else {
							_alpm_log(PM_LOG_WARNING, "%s saved as %s.pacsave", pathname, pathname);
							alpm_logaction("warning: %s saved as %s", expath, newpath);
						}
					}

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

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

		if(pmo_upgrade) {
			TRANS_CB(trans, PM_TRANS_EVT_UPGRADE_DONE, info, NULL);
			alpm_logaction("upgraded %s (%s -> %s)", info->name,
				oldpkg ? oldpkg->version : NULL, info->version);
		} else {
			TRANS_CB(trans, PM_TRANS_EVT_ADD_DONE, info, NULL);
			alpm_logaction("installed %s (%s)", info->name, info->version);
		}

		FREEPKG(oldpkg);
	}

	/* run ldconfig if it exists */
	_alpm_log(PM_LOG_FLOW1, "running \"ldconfig -r %s\"", handle->root);
	_alpm_ldconfig(handle->root);

	/* cache needs to be rebuilt */
	db_free_pkgcache(db);

	return(0);
}

/* vim: set ts=2 sw=2 noet: */