moparisthebest/pacman
1
0
Fork 0
mirror of https://github.com/moparisthebest/pacman synced 2024-12-23 00:08:50 -05:00
Code Issues Releases Wiki Activity

Big commit this time:

Browse Source 
* Moved entirely to alpm_pkg_get_* accessors, to read data on demand
* Mostly removed the INFRQ_ parameters from outside the be_files backend (making
  the backend more extensible in the long run)
* packages created from _alpm_db_scan now have the db and origin set (making
  accessors actually work for these packages)
* removed _alpm_db_ensure_pkgcache

* totally revamped the _alpm_checkconflicts function, making it cleaner and
  easier to read (and thus fix in the long run) - maintainable code ftw
  NOTE: feel free to rename the functions... I couldn't think of anything better

* removed an extra loop in sync.c:find_replacements - no sense in looping over
  an entire DB while strcmp'ing the name, when we have get_pkgfromcache

Other:
* package struct "license" -> "licenses"
* Created _alpm_sync_find (duplicate code in some places, find_pkginsync
* Minor const correctness changes along the way
* fixed a couple extra '/' pathing issues (non-issues really)
* removed a duplicate pkg_cmp function
This commit is contained in:
Aaron Griffin 2007-03-03 08:13:59 +00:00
parent a0dbade774
commit 7f5dada885
24 changed files with 657 additions and 578 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
lib/libalpm/add.c
View File

@ -260,7 +260,7 @@ int _alpm_add_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
_alpm_log(PM_LOG_DEBUG, _("cleaning up")); _alpm_log(PM_LOG_DEBUG, _("cleaning up"));
for (lp=trans->packages; lp!=NULL; lp=lp->next) { for (lp=trans->packages; lp!=NULL; lp=lp->next) {
info=(pmpkg_t *)lp->data; info=(pmpkg_t *)lp->data;
for (rmlist=info->removes; rmlist!=NULL; rmlist=rmlist->next) { for (rmlist = alpm_pkg_get_removes(info); rmlist; rmlist = rmlist->next) {
snprintf(rm_fname, PATH_MAX, "%s%s", handle->root, (char *)rmlist->data); snprintf(rm_fname, PATH_MAX, "%s%s", handle->root, (char *)rmlist->data);
remove(rm_fname); remove(rm_fname);
} }
@ -354,7 +354,7 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
newpkg->reason = alpm_pkg_get_reason(local); newpkg->reason = alpm_pkg_get_reason(local);
/* pre_upgrade scriptlet */ /* pre_upgrade scriptlet */
if(newpkg->scriptlet && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) { if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
_alpm_runscriptlet(handle->root, newpkg->data, "pre_upgrade", newpkg->version, oldpkg->version, trans); _alpm_runscriptlet(handle->root, newpkg->data, "pre_upgrade", newpkg->version, oldpkg->version, trans);
} }
} else { } else {
@ -364,7 +364,7 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
_alpm_log(PM_LOG_DEBUG, _("adding package %s-%s"), newpkg->name, newpkg->version); _alpm_log(PM_LOG_DEBUG, _("adding package %s-%s"), newpkg->name, newpkg->version);
/* pre_install scriptlet */ /* pre_install scriptlet */
if(newpkg->scriptlet && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) { if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
_alpm_runscriptlet(handle->root, newpkg->data, "pre_install", newpkg->version, NULL, trans); _alpm_runscriptlet(handle->root, newpkg->data, "pre_install", newpkg->version, NULL, trans);
} }
} }
@ -400,9 +400,10 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
* old, we cover all bases, including backup=() locations changing hands. * old, we cover all bases, including backup=() locations changing hands.
* But is this viable? */ * But is this viable? */
alpm_list_t *old_noupgrade = alpm_list_strdup(handle->noupgrade); alpm_list_t *old_noupgrade = alpm_list_strdup(handle->noupgrade);
for(b = newpkg->backup; b; b = b->next) { for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
_alpm_log(PM_LOG_DEBUG, _("adding %s to the NoUpgrade array temporarilly"), (char *)b->data); const char *backup = b->data;
handle->noupgrade = alpm_list_add(handle->noupgrade, strdup(b->data)); _alpm_log(PM_LOG_DEBUG, _("adding %s to the NoUpgrade array temporarilly"), backup);
handle->noupgrade = alpm_list_add(handle->noupgrade, strdup(backup));
} }
int ret = _alpm_remove_commit(tr, db); int ret = _alpm_remove_commit(tr, db);
@ -491,7 +492,7 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
/* if a file is in NoExtract then we never extract it */ /* if a file is in NoExtract then we never extract it */
if(alpm_list_find_str(handle->noextract, entryname)) { if(alpm_list_find_str(handle->noextract, entryname)) {
_alpm_log(PM_LOG_DEBUG, _("%s is in NoExtract, skipping extraction"), entryname); _alpm_log(PM_LOG_DEBUG, _("%s is in NoExtract, skipping extraction"), entryname);
alpm_logaction(_("notice: %s is in NoExtract -- skipping extraction"), entryname); alpm_logaction(_("%s is in NoExtract, skipping extraction"), entryname);
archive_read_data_skip(archive); archive_read_data_skip(archive);
continue; continue;
} }
@ -508,10 +509,10 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
/* it does, is it a backup=() file? /* it does, is it a backup=() file?
* always check the newpkg first, so when we do add a backup=() file, * always check the newpkg first, so when we do add a backup=() file,
* we don't have to wait a full upgrade cycle */ * we don't have to wait a full upgrade cycle */
needbackup = alpm_list_find_str(newpkg->backup, entryname); needbackup = alpm_list_find_str(alpm_pkg_get_backup(newpkg), entryname);
if(is_upgrade) { if(is_upgrade) {
hash_orig = _alpm_needbackup(entryname, oldpkg->backup); hash_orig = _alpm_needbackup(entryname, alpm_pkg_get_backup(oldpkg));
if(hash_orig) { if(hash_orig) {
needbackup = 1; needbackup = 1;
} }
@ -561,9 +562,9 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
hash_pkg = _alpm_SHAFile(tempfile); hash_pkg = _alpm_SHAFile(tempfile);
} }
/* append the new md5 or sha1 hash to it's respective entry in newpkg->backup /* append the new md5 or sha1 hash to it's respective entry in newpkg's backup
* (it will be the new orginal) */ * (it will be the new orginal) */
for(lp = newpkg->backup; lp; lp = lp->next) { for(lp = alpm_pkg_get_backup(newpkg); lp; lp = lp->next) {
if(!lp->data || strcmp(lp->data, entryname) != 0) { if(!lp->data || strcmp(lp->data, entryname) != 0) {
continue; continue;
} }
@ -699,8 +700,8 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
errors++; errors++;
} }
/* calculate an hash if this is in newpkg->backup */ /* calculate an hash if this is in newpkg's backup */
for(lp = newpkg->backup; lp; lp = lp->next) { for(lp = alpm_pkg_get_backup(newpkg); lp; lp = lp->next) {
char *backup = NULL, *hash = NULL; char *backup = NULL, *hash = NULL;
int backup_len = strlen(lp->data) + 2; /* tab char and null byte */ int backup_len = strlen(lp->data) + 2; /* tab char and null byte */
@ -760,7 +761,8 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
for(prov = provdiff; prov; prov = prov->next) { for(prov = provdiff; prov; prov = prov->next) {
const char *provname = prov->data; const char *provname = prov->data;
_alpm_log(PM_LOG_DEBUG, _("provision '%s' has been removed from package %s (%s => %s)"), _alpm_log(PM_LOG_DEBUG, _("provision '%s' has been removed from package %s (%s => %s)"),
provname, oldpkg->name, oldpkg->version, newpkg->version); provname, alpm_pkg_get_name(oldpkg),
alpm_pkg_get_version(oldpkg), alpm_pkg_get_version(newpkg));
alpm_list_t *p = _alpm_db_whatprovides(handle->db_local, provname); alpm_list_t *p = _alpm_db_whatprovides(handle->db_local, provname);
if(p) { if(p) {
@ -769,15 +771,18 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
* provision, we'll use the FIRST for now. * provision, we'll use the FIRST for now.
* TODO figure out a way to find a "correct" provision */ * TODO figure out a way to find a "correct" provision */
pmpkg_t *provpkg = p->data; pmpkg_t *provpkg = p->data;
_alpm_log(PM_LOG_DEBUG, _("updating '%s' due to provision change (%s)"), provpkg->name, provname); const char *pkgname = alpm_pkg_get_name(provpkg);
_alpm_log(PM_LOG_DEBUG, _("updating '%s' due to provision change (%s)"), pkgname, provname);
_alpm_pkg_update_requiredby(provpkg); _alpm_pkg_update_requiredby(provpkg);
if(_alpm_db_write(db, provpkg, INFRQ_DEPENDS)) { if(_alpm_db_write(db, provpkg, INFRQ_DEPENDS)) {
_alpm_log(PM_LOG_ERROR, _("could not update provision '%s' from '%s'"), provname, provpkg->name); _alpm_log(PM_LOG_ERROR, _("could not update provision '%s' from '%s'"), provname, pkgname);
alpm_logaction(_("could not update provision '%s' from '%s'"), provname, provpkg->name); alpm_logaction(_("could not update provision '%s' from '%s'"), provname, pkgname);
RET_ERR(PM_ERR_DB_WRITE, -1); RET_ERR(PM_ERR_DB_WRITE, -1);
} }
} }
} }
alpm_list_free(provdiff);
/* make an install date (in UTC) */ /* make an install date (in UTC) */
time_t t = time(NULL); time_t t = time(NULL);
@ -790,31 +795,36 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
if(_alpm_db_write(db, newpkg, INFRQ_ALL)) { if(_alpm_db_write(db, newpkg, INFRQ_ALL)) {
_alpm_log(PM_LOG_ERROR, _("could not update database entry %s-%s"), _alpm_log(PM_LOG_ERROR, _("could not update database entry %s-%s"),
newpkg->name, newpkg->version); alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
alpm_logaction(_("could not update database entry %s-%s"), alpm_logaction(_("could not update database entry %s-%s"),
newpkg->name, newpkg->version); alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
RET_ERR(PM_ERR_DB_WRITE, -1); RET_ERR(PM_ERR_DB_WRITE, -1);
} }
if(_alpm_db_add_pkgincache(db, newpkg) == -1) { if(_alpm_db_add_pkgincache(db, newpkg) == -1) {
_alpm_log(PM_LOG_ERROR, _("could not add entry '%s' in cache"), newpkg->name); _alpm_log(PM_LOG_ERROR, _("could not add entry '%s' in cache"),
alpm_pkg_get_name(newpkg));
} }
/* update dependency packages' REQUIREDBY fields */ /* update dependency packages' REQUIREDBY fields */
_alpm_trans_update_depends(trans, newpkg); _alpm_trans_update_depends(trans, newpkg);
PROGRESS(trans, (is_upgrade ? PM_TRANS_PROGRESS_UPGRADE_START : PM_TRANS_PROGRESS_ADD_START), PROGRESS(trans, (is_upgrade ? PM_TRANS_PROGRESS_UPGRADE_START : PM_TRANS_PROGRESS_ADD_START),
newpkg->name, 100, pkg_count, (pkg_count - targ_count +1)); alpm_pkg_get_name(newpkg), 100, pkg_count, (pkg_count - targ_count +1));
EVENT(trans, PM_TRANS_EVT_EXTRACT_DONE, NULL, NULL); EVENT(trans, PM_TRANS_EVT_EXTRACT_DONE, NULL, NULL);
/* run the post-install script if it exists */ /* run the post-install script if it exists */
if(newpkg->scriptlet && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) { if(alpm_pkg_has_scriptlet(newpkg) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
char pm_install[PATH_MAX]; char pm_install[PATH_MAX];
snprintf(pm_install, PATH_MAX, "%s%s/%s/%s-%s/install", handle->root, handle->dbpath, db->treename, newpkg->name, newpkg->version); snprintf(pm_install, PATH_MAX, "%s%s/%s/%s-%s/install", handle->root, handle->dbpath, db->treename,
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
if(is_upgrade) { if(is_upgrade) {
_alpm_runscriptlet(handle->root, pm_install, "post_upgrade", newpkg->version, oldpkg ? oldpkg->version : NULL, trans); _alpm_runscriptlet(handle->root, pm_install, "post_upgrade",
alpm_pkg_get_version(newpkg), oldpkg ? alpm_pkg_get_version(oldpkg) : NULL,
trans);
} else { } else {
_alpm_runscriptlet(handle->root, pm_install, "post_install", newpkg->version, NULL, trans); _alpm_runscriptlet(handle->root, pm_install, "post_install",
alpm_pkg_get_version(newpkg), NULL, trans);
} }
} }

106
lib/libalpm/alpm.c
View File

@ -302,13 +302,12 @@ int SYMEXPORT alpm_db_update(int force, pmdb_t *db)
snprintf(path, PATH_MAX, "%s%s/%s" PM_EXT_DB, handle->root, handle->dbpath, db->treename); snprintf(path, PATH_MAX, "%s%s/%s" PM_EXT_DB, handle->root, handle->dbpath, db->treename);
/* remove the old dir */ /* remove the old dir */
_alpm_log(PM_LOG_DEBUG, _("flushing database %s/%s"), handle->dbpath, db->treename); _alpm_log(PM_LOG_DEBUG, _("flushing database %s%s"), handle->dbpath, db->treename);
for(lp = _alpm_db_get_pkgcache(db, INFRQ_BASE); lp; lp = lp->next) { for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
if(_alpm_db_remove(db, lp->data) == -1) { pmpkg_t *pkg = lp->data;
if(lp->data) { if(pkg && _alpm_db_remove(db, pkg) == -1) {
_alpm_log(PM_LOG_ERROR, _("could not remove database entry %s/%s"), db->treename, _alpm_log(PM_LOG_ERROR, _("could not remove database entry %s%s"), db->treename,
((pmpkg_t *)lp->data)->name); alpm_pkg_get_name(pkg));
}
RET_ERR(PM_ERR_DB_REMOVE, -1); RET_ERR(PM_ERR_DB_REMOVE, -1);
} }
} }
@ -354,7 +353,7 @@ alpm_list_t SYMEXPORT *alpm_db_getpkgcache(pmdb_t *db)
ASSERT(handle != NULL, return(NULL)); ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL)); ASSERT(db != NULL, return(NULL));
return(_alpm_db_get_pkgcache(db, INFRQ_BASE)); return(_alpm_db_get_pkgcache(db));
} }
/** Get the list of packages that a package provides /** Get the list of packages that a package provides
@ -472,21 +471,21 @@ int alpm_pkg_checksha1sum(pmpkg_t *pkg)
snprintf(path, PATH_MAX, "%s%s/%s-%s" PM_EXT_PKG, snprintf(path, PATH_MAX, "%s%s/%s-%s" PM_EXT_PKG,
handle->root, handle->cachedir, handle->root, handle->cachedir,
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
sha1sum = _alpm_SHAFile(path); sha1sum = _alpm_SHAFile(path);
if(sha1sum == NULL) { if(sha1sum == NULL) {
_alpm_log(PM_LOG_ERROR, _("could not get sha1sum for package %s-%s"), _alpm_log(PM_LOG_ERROR, _("could not get sha1sum for package %s-%s"),
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
pm_errno = PM_ERR_NOT_A_FILE; pm_errno = PM_ERR_NOT_A_FILE;
retval = -1; retval = -1;
} else { } else {
if(strcmp(sha1sum, alpm_pkg_get_sha1sum(pkg)) == 0) { if(strcmp(sha1sum, alpm_pkg_get_sha1sum(pkg)) == 0) {
_alpm_log(PM_LOG_DEBUG, _("sha1sums for package %s-%s match"), _alpm_log(PM_LOG_DEBUG, _("sha1sums for package %s-%s match"),
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
} else { } else {
_alpm_log(PM_LOG_ERROR, _("sha1sums do not match for package %s-%s"), _alpm_log(PM_LOG_ERROR, _("sha1sums do not match for package %s-%s"),
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
pm_errno = PM_ERR_PKG_INVALID; pm_errno = PM_ERR_PKG_INVALID;
retval = -1; retval = -1;
} }
@ -516,21 +515,21 @@ int alpm_pkg_checkmd5sum(pmpkg_t *pkg)
snprintf(path, PATH_MAX, "%s%s/%s-%s" PM_EXT_PKG, snprintf(path, PATH_MAX, "%s%s/%s-%s" PM_EXT_PKG,
handle->root, handle->cachedir, handle->root, handle->cachedir,
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
md5sum = _alpm_MDFile(path); md5sum = _alpm_MDFile(path);
if(md5sum == NULL) { if(md5sum == NULL) {
_alpm_log(PM_LOG_ERROR, _("could not get md5sum for package %s-%s"), _alpm_log(PM_LOG_ERROR, _("could not get md5sum for package %s-%s"),
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
pm_errno = PM_ERR_NOT_A_FILE; pm_errno = PM_ERR_NOT_A_FILE;
retval = -1; retval = -1;
} else { } else {
if(strcmp(md5sum, alpm_pkg_get_md5sum(pkg)) == 0) { if(strcmp(md5sum, alpm_pkg_get_md5sum(pkg)) == 0) {
_alpm_log(PM_LOG_DEBUG, _("md5sums for package %s-%s match"), _alpm_log(PM_LOG_DEBUG, _("md5sums for package %s-%s match"),
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
} else { } else {
_alpm_log(PM_LOG_ERROR, _("md5sums do not match for package %s-%s"), _alpm_log(PM_LOG_ERROR, _("md5sums do not match for package %s-%s"),
pkg->name, pkg->version); alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
pm_errno = PM_ERR_PKG_INVALID; pm_errno = PM_ERR_PKG_INVALID;
retval = -1; retval = -1;
} }
@ -1071,9 +1070,8 @@ int SYMEXPORT alpm_parse_config(char *file, alpm_cb_db_register callback, const
* solution made for -Qu operation */ * solution made for -Qu operation */
alpm_list_t *alpm_get_upgrades() alpm_list_t *alpm_get_upgrades()
{ {
int found = 0;
alpm_list_t *syncpkgs = NULL; alpm_list_t *syncpkgs = NULL;
alpm_list_t *i, *j, *k; alpm_list_t *i, *j, *k, *m;
ALPM_LOG_FUNC; ALPM_LOG_FUNC;
@ -1081,36 +1079,35 @@ alpm_list_t *alpm_get_upgrades()
/* check for "recommended" package replacements */ /* check for "recommended" package replacements */
_alpm_log(PM_LOG_DEBUG, _("checking for package replacements")); _alpm_log(PM_LOG_DEBUG, _("checking for package replacements"));
for(i = handle->dbs_sync; i; i = i->next) { for(i = handle->dbs_sync; i; i = i->next) {
for(j = _alpm_db_get_pkgcache(i->data, INFRQ_DESC); j; j = j->next) { for(j = _alpm_db_get_pkgcache(i->data); j; j = j->next) {
pmpkg_t *spkg = j->data; pmpkg_t *spkg = j->data;
for(k = spkg->replaces; k; k = k->next) {
alpm_list_t *m; for(k = alpm_pkg_get_replaces(spkg); k; k = k->next) {
for(m = _alpm_db_get_pkgcache(handle->db_local, INFRQ_BASE); m; m = m->next) {
for(m = _alpm_db_get_pkgcache(handle->db_local); m; m = m->next) {
pmpkg_t *lpkg = m->data; pmpkg_t *lpkg = m->data;
if(strcmp(k->data, lpkg->name) == 0) {
_alpm_log(PM_LOG_DEBUG, _("checking replacement '%s' for package '%s'"), k->data, spkg->name); if(strcmp(k->data, alpm_pkg_get_name(lpkg)) == 0) {
if(alpm_list_find_str(handle->ignorepkg, lpkg->name)) { _alpm_log(PM_LOG_DEBUG, _("checking replacement '%s' for package '%s'"), k->data,
alpm_pkg_get_name(spkg));
if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(lpkg))) {
_alpm_log(PM_LOG_WARNING, _("%s-%s: ignoring package upgrade (to be replaced by %s-%s)"), _alpm_log(PM_LOG_WARNING, _("%s-%s: ignoring package upgrade (to be replaced by %s-%s)"),
lpkg->name, lpkg->version, spkg->name, spkg->version); alpm_pkg_get_name(lpkg), alpm_pkg_get_version(lpkg),
alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
} else { } else {
/* assume all replaces=() packages are accepted */ /* assume all replaces=() packages are accepted */
pmsyncpkg_t *sync = NULL; pmsyncpkg_t *sync = NULL;
pmpkg_t *dummy = _alpm_pkg_new(lpkg->name, NULL); pmpkg_t *dummy = _alpm_pkg_new(alpm_pkg_get_name(lpkg), NULL);
if(dummy == NULL) { if(dummy == NULL) {
pm_errno = PM_ERR_MEMORY; pm_errno = PM_ERR_MEMORY;
goto error; goto error;
} }
dummy->requiredby = alpm_list_strdup(lpkg->requiredby); dummy->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(lpkg));
/* check if spkg->name is already in the packages list. */
alpm_list_t *s;
for(s = syncpkgs; s && !found; s = s->next) {
sync = i->data;
if(sync && !strcmp(sync->pkg->name, spkg->name)) {
found = 1;
}
}
if(found) { pmsyncpkg_t *syncpkg;
syncpkg = _alpm_sync_find(syncpkgs, alpm_pkg_get_name(spkg));
if(syncpkg) {
/* found it -- just append to the replaces list */ /* found it -- just append to the replaces list */
sync->data = alpm_list_add(sync->data, dummy); sync->data = alpm_list_add(sync->data, dummy);
} else { } else {
@ -1125,7 +1122,8 @@ alpm_list_t *alpm_get_upgrades()
syncpkgs = alpm_list_add(syncpkgs, sync); syncpkgs = alpm_list_add(syncpkgs, sync);
} }
_alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (to be replaced by %s-%s)"), _alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (to be replaced by %s-%s)"),
lpkg->name, lpkg->version, spkg->name, spkg->version); alpm_pkg_get_name(lpkg), alpm_pkg_get_version(lpkg),
alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
} }
break; break;
} }
@ -1135,17 +1133,17 @@ alpm_list_t *alpm_get_upgrades()
} }
/* now do normal upgrades */ /* now do normal upgrades */
for(i = _alpm_db_get_pkgcache(handle->db_local, INFRQ_BASE); i; i = i->next) { for(i = _alpm_db_get_pkgcache(handle->db_local); i; i = i->next) {
int replace=0; int replace=0;
pmpkg_t *local = i->data; pmpkg_t *local = i->data;
pmpkg_t *spkg = NULL; pmpkg_t *spkg = NULL;
pmsyncpkg_t *sync; pmsyncpkg_t *sync;
for(j = handle->dbs_sync; !spkg && j; j = j->next) { for(j = handle->dbs_sync; !spkg && j; j = j->next) {
spkg = _alpm_db_get_pkgfromcache(j->data, local->name); spkg = _alpm_db_get_pkgfromcache(j->data, alpm_pkg_get_name(local));
} }
if(spkg == NULL) { if(spkg == NULL) {
_alpm_log(PM_LOG_DEBUG, _("'%s' not found in sync db -- skipping"), local->name); _alpm_log(PM_LOG_DEBUG, _("'%s' not found in sync db -- skipping"), alpm_pkg_get_name(local));
continue; continue;
} }
@ -1153,32 +1151,28 @@ alpm_list_t *alpm_get_upgrades()
for(j = syncpkgs; j && !replace; j=j->next) { for(j = syncpkgs; j && !replace; j=j->next) {
sync = j->data; sync = j->data;
if(sync->type == PM_SYNC_TYPE_REPLACE) { if(sync->type == PM_SYNC_TYPE_REPLACE) {
if(_alpm_pkg_find(spkg->name, sync->data)) { if(_alpm_pkg_find(alpm_pkg_get_name(spkg), sync->data)) {
replace=1; replace=1;
} }
} }
} }
if(replace) { if(replace) {
_alpm_log(PM_LOG_DEBUG, _("'%s' is already elected for removal -- skipping"), _alpm_log(PM_LOG_DEBUG, _("'%s' is already elected for removal -- skipping"),
local->name); alpm_pkg_get_name(local));
continue; continue;
} }
if(alpm_pkg_compare_versions(local, spkg)) { if(alpm_pkg_compare_versions(local, spkg)) {
_alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (%s => %s)"), _alpm_log(PM_LOG_DEBUG, _("%s elected for upgrade (%s => %s)"),
local->name, local->version, local->version, spkg->version); alpm_pkg_get_name(local), alpm_pkg_get_version(local),
alpm_list_t *s; alpm_pkg_get_version(spkg));
pmsyncpkg_t *sync = NULL;
found = 0;
for(s = syncpkgs; s && !found; s = s->next) {
sync = s->data;
if(sync && strcmp(sync->pkg->name, local->name) == 0) {
found = 1;
}
}
if(!found) { pmsyncpkg_t *syncpkg;
pmpkg_t *dummy = _alpm_pkg_new(local->name, local->version); syncpkg = _alpm_sync_find(syncpkgs, alpm_pkg_get_name(local));
if(!syncpkg) {
pmpkg_t *dummy = _alpm_pkg_new(alpm_pkg_get_name(local),
alpm_pkg_get_version(local));
if(dummy == NULL) { if(dummy == NULL) {
goto error; goto error;
} }

2
lib/libalpm/alpm.h
View File

@ -343,7 +343,7 @@ typedef void (*alpm_trans_cb_conv)(pmtransconv_t, void *, void *,
void *, int *); void *, int *);
/* Transaction Progress callback */ /* Transaction Progress callback */
typedef void (*alpm_trans_cb_progress)(pmtransprog_t, char *, int, int, int); typedef void (*alpm_trans_cb_progress)(pmtransprog_t, const char *, int, int, int);
pmtranstype_t alpm_trans_get_type(); pmtranstype_t alpm_trans_get_type();
unsigned int alpm_trans_get_flags(); unsigned int alpm_trans_get_flags();

2
lib/libalpm/alpm_list.c
View File

@ -236,7 +236,7 @@ alpm_list_t* alpm_list_msort(alpm_list_t *list, int n, alpm_list_fn_cmp fn)
* @param data output parameter containing the data member of the item removed * @param data output parameter containing the data member of the item removed
* @return the resultant list, or NULL on failure * @return the resultant list, or NULL on failure
*/ */
alpm_list_t *alpm_list_remove(alpm_list_t *haystack, void *needle, alpm_list_fn_cmp fn, void **data) alpm_list_t *alpm_list_remove(alpm_list_t *haystack, const void *needle, alpm_list_fn_cmp fn, void **data)
{ /* TODO I modified this to remove ALL matching items. Do we need a remove_first? */ { /* TODO I modified this to remove ALL matching items. Do we need a remove_first? */
alpm_list_t *i = haystack, *tmp = NULL; alpm_list_t *i = haystack, *tmp = NULL;

2
lib/libalpm/alpm_list.h
View File

@ -48,7 +48,7 @@ alpm_list_t *alpm_list_add(alpm_list_t *list, void *data);
alpm_list_t *alpm_list_add_sorted(alpm_list_t *list, void *data, alpm_list_fn_cmp fn); alpm_list_t *alpm_list_add_sorted(alpm_list_t *list, void *data, alpm_list_fn_cmp fn);
alpm_list_t *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, alpm_list_fn_cmp fn); alpm_list_t *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, alpm_list_fn_cmp fn);
alpm_list_t *alpm_list_msort(alpm_list_t *list, int n, alpm_list_fn_cmp fn); alpm_list_t *alpm_list_msort(alpm_list_t *list, int n, alpm_list_fn_cmp fn);
alpm_list_t *alpm_list_remove(alpm_list_t *haystack, void *needle, alpm_list_fn_cmp fn, void **data); alpm_list_t *alpm_list_remove(alpm_list_t *haystack, const void *needle, alpm_list_fn_cmp fn, void **data);
alpm_list_t *alpm_list_remove_node(alpm_list_t *node); alpm_list_t *alpm_list_remove_node(alpm_list_t *node);
alpm_list_t *alpm_list_remove_dupes(alpm_list_t *list); alpm_list_t *alpm_list_remove_dupes(alpm_list_t *list);
alpm_list_t *alpm_list_strdup(alpm_list_t *list); alpm_list_t *alpm_list_strdup(alpm_list_t *list);

17
lib/libalpm/be_files.c
View File

@ -106,7 +106,7 @@ void _alpm_db_rewind(pmdb_t *db)
rewinddir(db->handle); rewinddir(db->handle);
} }
pmpkg_t *_alpm_db_scan(pmdb_t *db, const char *target, pmdbinfrq_t inforeq) pmpkg_t *_alpm_db_scan(pmdb_t *db, const char *target)
{ {
struct dirent *ent = NULL; struct dirent *ent = NULL;
struct stat sbuf; struct stat sbuf;
@ -183,9 +183,14 @@ pmpkg_t *_alpm_db_scan(pmdb_t *db, const char *target, pmdbinfrq_t inforeq)
_alpm_log(PM_LOG_ERROR, _("invalid name for dabatase entry '%s'"), ent->d_name); _alpm_log(PM_LOG_ERROR, _("invalid name for dabatase entry '%s'"), ent->d_name);
return(NULL); return(NULL);
} }
if(_alpm_db_read(db, pkg, inforeq) == -1) {
/* explicitly read with only 'BASE' data, accessors will handle the rest */
if(_alpm_db_read(db, pkg, INFRQ_BASE) == -1) {
/* TODO removed corrupt entry from the FS here */ /* TODO removed corrupt entry from the FS here */
FREEPKG(pkg); FREEPKG(pkg);
} else {
pkg->data = db;
pkg->origin = PKG_FROM_CACHE;
} }
} }
@ -298,7 +303,7 @@ int _alpm_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
_alpm_strtrim(info->url); _alpm_strtrim(info->url);
} else if(!strcmp(line, "%LICENSE%")) { } else if(!strcmp(line, "%LICENSE%")) {
while(fgets(line, 512, fp) && strlen(_alpm_strtrim(line))) { while(fgets(line, 512, fp) && strlen(_alpm_strtrim(line))) {
info->license = alpm_list_add(info->license, strdup(line)); info->licenses = alpm_list_add(info->licenses, strdup(line));
} }
} else if(!strcmp(line, "%ARCH%")) { } else if(!strcmp(line, "%ARCH%")) {
if(fgets(info->arch, sizeof(info->arch), fp) == NULL) { if(fgets(info->arch, sizeof(info->arch), fp) == NULL) {
@ -527,9 +532,9 @@ int _alpm_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
fprintf(fp, "%%URL%%\n" fprintf(fp, "%%URL%%\n"
"%s\n\n", info->url); "%s\n\n", info->url);
} }
if(info->license) { if(info->licenses) {
fputs("%LICENSE%\n", fp); fputs("%LICENSE%\n", fp);
for(lp = info->license; lp; lp = lp->next) { for(lp = info->licenses; lp; lp = lp->next) {
fprintf(fp, "%s\n", (char *)lp->data); fprintf(fp, "%s\n", (char *)lp->data);
} }
fprintf(fp, "\n"); fprintf(fp, "\n");
@ -687,7 +692,7 @@ int _alpm_db_remove(pmdb_t *db, pmpkg_t *info)
RET_ERR(PM_ERR_DB_NULL, -1); RET_ERR(PM_ERR_DB_NULL, -1);
} }
snprintf(path, PATH_MAX, "%s/%s-%s", db->path, info->name, info->version); snprintf(path, PATH_MAX, "%s%s-%s", db->path, info->name, info->version);
if(_alpm_rmrf(path) == -1) { if(_alpm_rmrf(path) == -1) {
return(-1); return(-1);
} }

82
lib/libalpm/cache.c
View File

@ -41,12 +41,10 @@
/* Returns a new package cache from db. /* Returns a new package cache from db.
* It frees the cache if it already exists. * It frees the cache if it already exists.
*/ */
int _alpm_db_load_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel) int _alpm_db_load_pkgcache(pmdb_t *db)
{ {
pmpkg_t *info; pmpkg_t *info;
int count = 0; int count = 0;
/* The group cache needs INFRQ_DESC as well */
/* pmdbinfrq_t infolevel = INFRQ_DEPENDS | INFRQ_DESC;*/
ALPM_LOG_FUNC; ALPM_LOG_FUNC;
@ -56,12 +54,13 @@ int _alpm_db_load_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel)
_alpm_db_free_pkgcache(db); _alpm_db_free_pkgcache(db);
_alpm_log(PM_LOG_DEBUG, _("loading package cache (infolevel=%#x) for repository '%s'"), _alpm_log(PM_LOG_DEBUG, _("loading package cache for repository '%s'"),
infolevel, db->treename); db->treename);
_alpm_db_rewind(db); _alpm_db_rewind(db);
while((info = _alpm_db_scan(db, NULL, infolevel)) != NULL) { while((info = _alpm_db_scan(db, NULL)) != NULL) {
_alpm_log(PM_LOG_FUNCTION, _("adding '%s' to package cache for db '%s'"), info->name, db->treename); _alpm_log(PM_LOG_FUNCTION, _("adding '%s' to package cache for db '%s'"),
alpm_pkg_get_name(info), db->treename);
info->origin = PKG_FROM_CACHE; info->origin = PKG_FROM_CACHE;
info->data = db; info->data = db;
/* add to the collection */ /* add to the collection */
@ -91,7 +90,7 @@ void _alpm_db_free_pkgcache(pmdb_t *db)
} }
} }
alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel) alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
{ {
ALPM_LOG_FUNC; ALPM_LOG_FUNC;
@ -99,46 +98,18 @@ alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel)
return(NULL); return(NULL);
} }
if(db->pkgcache == NULL) { if(!db->pkgcache) {
_alpm_db_load_pkgcache(db, infolevel); _alpm_db_load_pkgcache(db);
} }
_alpm_db_ensure_pkgcache(db, infolevel); /* hmmm, still NULL ?*/
if(!db->pkgcache) { if(!db->pkgcache) {
_alpm_log(PM_LOG_DEBUG, _("error: pkgcache is NULL for db '%s'"), db->treename); _alpm_log(PM_LOG_DEBUG, _("error: pkgcache is NULL for db '%s'"), db->treename);
} }
return(db->pkgcache); return(db->pkgcache);
} }
int _alpm_db_ensure_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel)
{
int reloaded = 0;
/* for each pkg, check and reload if the requested
* info is not already cached
*/
ALPM_LOG_FUNC;
alpm_list_t *p;
for(p = db->pkgcache; p; p = p->next) {
pmpkg_t *pkg = (pmpkg_t *)p->data;
if(infolevel != INFRQ_BASE && !(pkg->infolevel & infolevel)) {
if(_alpm_db_read(db, pkg, infolevel) == -1) {
/* TODO should we actually remove from the filesystem here as well? */
_alpm_db_remove_pkgfromcache(db, pkg);
} else {
reloaded = 1;
}
}
}
if(reloaded) {
_alpm_log(PM_LOG_DEBUG, _("package cache reloaded (infolevel=%#x) for repository '%s'"),
infolevel, db->treename);
}
return(0);
}
int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg) int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
{ {
pmpkg_t *newpkg; pmpkg_t *newpkg;
@ -153,7 +124,8 @@ int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
if(newpkg == NULL) { if(newpkg == NULL) {
return(-1); return(-1);
} }
_alpm_log(PM_LOG_DEBUG, _("adding entry '%s' in '%s' cache"), newpkg->name, db->treename); _alpm_log(PM_LOG_DEBUG, _("adding entry '%s' in '%s' cache"),
alpm_pkg_get_name(newpkg), db->treename);
db->pkgcache = alpm_list_add_sorted(db->pkgcache, newpkg, _alpm_pkg_cmp); db->pkgcache = alpm_list_add_sorted(db->pkgcache, newpkg, _alpm_pkg_cmp);
_alpm_db_free_grpcache(db); _alpm_db_free_grpcache(db);
@ -172,14 +144,18 @@ int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
return(-1); return(-1);
} }
_alpm_log(PM_LOG_DEBUG, _("removing entry '%s' from '%s' cache"),
alpm_pkg_get_name(pkg), db->treename);
db->pkgcache = alpm_list_remove(db->pkgcache, pkg, _alpm_pkg_cmp, &vdata); db->pkgcache = alpm_list_remove(db->pkgcache, pkg, _alpm_pkg_cmp, &vdata);
data = vdata; data = vdata;
if(data == NULL) { if(data == NULL) {
/* package not found */ /* package not found */
_alpm_log(PM_LOG_DEBUG, _("cannot remove entry '%s' from '%s' cache: not found"),
alpm_pkg_get_name(pkg), db->treename);
return(-1); return(-1);
} }
_alpm_log(PM_LOG_DEBUG, _("removing entry '%s' from '%s' cache"), pkg->name, db->treename);
FREEPKG(data); FREEPKG(data);
_alpm_db_free_grpcache(db); _alpm_db_free_grpcache(db);
@ -195,7 +171,7 @@ pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
return(NULL); return(NULL);
} }
alpm_list_t *pkgcache = _alpm_db_get_pkgcache(db, INFRQ_BASE); alpm_list_t *pkgcache = _alpm_db_get_pkgcache(db);
if(!pkgcache) { if(!pkgcache) {
_alpm_log(PM_LOG_DEBUG, _("error: failed to get '%s' from NULL pkgcache"), target); _alpm_log(PM_LOG_DEBUG, _("error: failed to get '%s' from NULL pkgcache"), target);
return(NULL); return(NULL);
@ -217,21 +193,26 @@ int _alpm_db_load_grpcache(pmdb_t *db)
} }
if(db->pkgcache == NULL) { if(db->pkgcache == NULL) {
_alpm_db_load_pkgcache(db, INFRQ_DESC); _alpm_db_load_pkgcache(db);
} }
_alpm_log(PM_LOG_DEBUG, _("loading group cache for repository '%s'"), db->treename); _alpm_log(PM_LOG_DEBUG, _("loading group cache for repository '%s'"), db->treename);
for(lp = _alpm_db_get_pkgcache(db, INFRQ_DESC); lp; lp = lp->next) { for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
alpm_list_t *i; alpm_list_t *i;
pmpkg_t *pkg = lp->data; pmpkg_t *pkg = lp->data;
for(i = pkg->groups; i; i = i->next) { for(i = alpm_pkg_get_groups(pkg); i; i = i->next) {
if(!alpm_list_find_str(db->grpcache, i->data)) { if(!alpm_list_find_str(db->grpcache, i->data)) {
pmgrp_t *grp = _alpm_grp_new(); pmgrp_t *grp = _alpm_grp_new();
STRNCPY(grp->name, (char *)i->data, GRP_NAME_LEN); strncpy(grp->name, i->data, GRP_NAME_LEN);
grp->packages = alpm_list_add_sorted(grp->packages, pkg->name, _alpm_grp_cmp); grp->name[GRP_NAME_LEN-1] = '\0';
grp->packages = alpm_list_add_sorted(grp->packages,
/* gross signature forces us to
* discard const */
(void *)alpm_pkg_get_name(pkg),
_alpm_grp_cmp);
db->grpcache = alpm_list_add_sorted(db->grpcache, grp, _alpm_grp_cmp); db->grpcache = alpm_list_add_sorted(db->grpcache, grp, _alpm_grp_cmp);
} else { } else {
alpm_list_t *j; alpm_list_t *j;
@ -240,8 +221,9 @@ int _alpm_db_load_grpcache(pmdb_t *db)
pmgrp_t *grp = j->data; pmgrp_t *grp = j->data;
if(strcmp(grp->name, i->data) == 0) { if(strcmp(grp->name, i->data) == 0) {
if(!alpm_list_find_str(grp->packages, pkg->name)) { const char *pkgname = alpm_pkg_get_name(pkg);
grp->packages = alpm_list_add_sorted(grp->packages, (char *)pkg->name, _alpm_grp_cmp); if(!alpm_list_find_str(grp->packages, pkgname)) {
grp->packages = alpm_list_add_sorted(grp->packages, (void *)pkgname, _alpm_grp_cmp);
} }
} }
} }

4
lib/libalpm/cache.h
View File

@ -27,11 +27,11 @@
#include "package.h" #include "package.h"
/* packages */ /* packages */
int _alpm_db_load_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel); int _alpm_db_load_pkgcache(pmdb_t *db);
void _alpm_db_free_pkgcache(pmdb_t *db); void _alpm_db_free_pkgcache(pmdb_t *db);
int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg); int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg);
int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg); int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg);
alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel); alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db);
int _alpm_db_ensure_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel); int _alpm_db_ensure_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel);
pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target); pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target);
/* groups */ /* groups */

343
lib/libalpm/conflict.c
View File

@ -46,16 +46,191 @@
#include "deps.h" #include "deps.h"
#include "conflict.h" #include "conflict.h"
/** See if potential conflict 'name' matches package 'pkg'
* @param target the name of the parent package we're checking
* @param depname the name of the dependency we're checking
* @param pkg the package to check
* @param conflict the name of the possible conflict
* @return A depmissing struct indicating the conflict
* @note The first two paramters are here to simplify the addition
* of new 'depmiss' objects
*
* TODO WTF is a 'depmissing' doing indicating a conflict??
*/
static pmdepmissing_t *does_conflict(const char *target, const char *depname,
pmpkg_t *pkg, const char *conflict)
{
alpm_list_t *i;
/* check the actual package name, easy */
if(strcmp(alpm_pkg_get_name(pkg), conflict) == 0) {
_alpm_log(PM_LOG_DEBUG, _(" found conflict '%s' : package '%s'"), conflict, target);
return(_alpm_depmiss_new(target, PM_DEP_TYPE_CONFLICT,
PM_DEP_MOD_ANY, depname, NULL));
} else {
/* check what this package provides, harder */
for(i = alpm_pkg_get_provides(pkg); i; i = i->next) {
const char *provision = i->data;
if(strcmp(provision, conflict) == 0) {
_alpm_log(PM_LOG_DEBUG, _(" found conflict '%s' : package '%s' provides '%s'"),
conflict, target, provision);
return(_alpm_depmiss_new(target, PM_DEP_TYPE_CONFLICT,
PM_DEP_MOD_ANY, depname, NULL));
}
}
}
return(NULL); /* not a conflict */
}
static alpm_list_t *chk_pkg_vs_db(alpm_list_t *baddeps, pmpkg_t *pkg, pmdb_t *db)
{
pmdepmissing_t *miss = NULL;
const char *pkgname;
alpm_list_t *i, *j;
pkgname = alpm_pkg_get_name(pkg);
for(i = alpm_pkg_get_conflicts(pkg); i; i = i->next) {
const char *conflict = i->data;
if(strcmp(pkgname, conflict) == 0) {
/* a package cannot conflict with itself -- that's just not nice */
_alpm_log(PM_LOG_DEBUG, _("package '%s' conflicts with itself - packaging error"),
pkgname);
continue;
}
/* CHECK 1: check targets against database */
_alpm_log(PM_LOG_DEBUG, _("checkconflicts: target '%s' vs db"), pkgname);
for(j = _alpm_db_get_pkgcache(db); j; j = j->next) {
pmpkg_t *dbpkg = j->data;
if(strcmp(alpm_pkg_get_name(dbpkg), pkgname) == 0) {
/* skip the package we're currently processing */
continue;
}
miss = does_conflict(pkgname, alpm_pkg_get_name(dbpkg), dbpkg, conflict);
if(miss && !_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
}
}
return(baddeps);
}
static alpm_list_t *chk_pkg_vs_targets(alpm_list_t *baddeps,
pmpkg_t *pkg, pmdb_t *db,
alpm_list_t *targets)
{
pmdepmissing_t *miss = NULL;
const char *pkgname;
alpm_list_t *i, *j;
pkgname = alpm_pkg_get_name(pkg);
for(i = alpm_pkg_get_conflicts(pkg); i; i = i->next) {
const char *conflict = i->data;
if(strcmp(pkgname, conflict) == 0) {
/* a package cannot conflict with itself -- that's just not nice */
_alpm_log(PM_LOG_DEBUG, _("package '%s' conflicts with itself - packaging error"),
pkgname);
continue;
}
/* CHECK 2: check targets against targets */
_alpm_log(PM_LOG_DEBUG, _("checkconflicts: target '%s' vs all targets"), pkgname);
for(j = targets; j; j = j->next) {
const char *targetname;
pmpkg_t *target = j->data;
targetname = alpm_pkg_get_name(target);
if(strcmp(targetname, pkgname) == 0) {
/* skip the package we're currently processing */
continue;
}
miss = does_conflict(pkgname, targetname, target, conflict);
if(miss && !_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
}
}
return(baddeps);
}
static alpm_list_t *chk_db_vs_targets(alpm_list_t *baddeps, pmpkg_t *pkg,
pmdb_t *db, alpm_list_t *targets)
{
pmdepmissing_t *miss = NULL;
const char *pkgname;
alpm_list_t *i, *j;
pkgname = alpm_pkg_get_name(pkg);
_alpm_log(PM_LOG_DEBUG, _("checkconflicts: db vs target '%s'"), pkgname);
for(i = _alpm_db_get_pkgcache(db); i; i = i->next) {
alpm_list_t *conflicts = NULL;
const char *dbpkgname;
pmpkg_t *dbpkg = i->data;
dbpkgname = alpm_pkg_get_name(dbpkg);
if(strcmp(dbpkgname, pkgname) == 0) {
/* skip the package we're currently processing */
continue;
}
/* is this db package in the targets? if so use the
* new package's conflict list to pick up new changes */
int use_newconflicts = 0;
for(j = targets; j; j = j->next) {
pmpkg_t *targ = j->data;
if(strcmp(alpm_pkg_get_name(targ), dbpkgname) == 0) {
_alpm_log(PM_LOG_DEBUG, _("target '%s' is also in target list, using NEW conflicts"),
dbpkgname);
conflicts = alpm_pkg_get_conflicts(targ);
use_newconflicts = 1;
break;
}
}
/* if we didn't find newer conflicts, use the original list */
if(!use_newconflicts) {
conflicts = alpm_pkg_get_conflicts(dbpkg);
}
for(j = conflicts; j; j = j->next) {
const char *conflict = j->data;
miss = does_conflict(pkgname, dbpkgname, pkg, conflict);
if(miss && !_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
}
}
return(baddeps);
}
/* Returns a alpm_list_t* of pmdepmissing_t pointers. /* Returns a alpm_list_t* of pmdepmissing_t pointers.
* *
* conflicts are always name only * conflicts are always name only
*/ */
alpm_list_t *_alpm_checkconflicts(pmdb_t *db, alpm_list_t *packages) alpm_list_t *_alpm_checkconflicts(pmdb_t *db, alpm_list_t *packages)
{ {
pmpkg_t *info = NULL; alpm_list_t *i, *baddeps = NULL;
alpm_list_t *i, *j, *k;
alpm_list_t *baddeps = NULL;
pmdepmissing_t *miss = NULL;
ALPM_LOG_FUNC; ALPM_LOG_FUNC;
@ -64,150 +239,25 @@ alpm_list_t *_alpm_checkconflicts(pmdb_t *db, alpm_list_t *packages)
} }
for(i = packages; i; i = i->next) { for(i = packages; i; i = i->next) {
pmpkg_t *tp = i->data; pmpkg_t *pkg = i->data;
if(tp == NULL) { if(pkg == NULL) {
continue; continue;
} }
for(j = tp->conflicts; j; j = j->next) { baddeps = chk_pkg_vs_db(baddeps, pkg, db);
if(!strcmp(tp->name, j->data)) { baddeps = chk_pkg_vs_targets(baddeps, pkg, db, packages);
/* a package cannot conflict with itself -- that's just not nice */ baddeps = chk_db_vs_targets(baddeps, pkg, db, packages);
continue;
} }
/* CHECK 1: check targets against database */
_alpm_log(PM_LOG_DEBUG, _("checkconflicts: targ '%s' vs db"), tp->name);
for(k = _alpm_db_get_pkgcache(db, INFRQ_DEPENDS); k; k = k->next) {
pmpkg_t *dp = (pmpkg_t *)k->data;
if(!strcmp(dp->name, tp->name)) {
/* a package cannot conflict with itself -- that's just not nice */
continue;
}
if(!strcmp(j->data, dp->name)) {
/* conflict */
_alpm_log(PM_LOG_DEBUG, _("targs vs db: found %s as a conflict for %s"),
dp->name, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_CONFLICT, PM_DEP_MOD_ANY, dp->name, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
} else {
/* see if dp provides something in tp's conflict list */
alpm_list_t *m;
for(m = dp->provides; m; m = m->next) {
if(!strcmp(m->data, j->data)) {
/* confict */
_alpm_log(PM_LOG_DEBUG, _("targs vs db: found %s as a conflict for %s"),
dp->name, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_CONFLICT, PM_DEP_MOD_ANY, dp->name, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
}
}
}
}
/* CHECK 2: check targets against targets */
_alpm_log(PM_LOG_DEBUG, _("checkconflicts: targ '%s' vs targs"), tp->name);
for(k = packages; k; k = k->next) {
pmpkg_t *otp = (pmpkg_t *)k->data;
if(!strcmp(otp->name, tp->name)) {
/* a package cannot conflict with itself -- that's just not nice */
continue;
}
if(!strcmp(otp->name, (char *)j->data)) {
/* otp is listed in tp's conflict list */
_alpm_log(PM_LOG_DEBUG, _("targs vs targs: found %s as a conflict for %s"),
otp->name, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_CONFLICT, PM_DEP_MOD_ANY, otp->name, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
} else {
/* see if otp provides something in tp's conflict list */
alpm_list_t *m;
for(m = otp->provides; m; m = m->next) {
if(!strcmp(m->data, j->data)) {
_alpm_log(PM_LOG_DEBUG, _("targs vs targs: found %s as a conflict for %s"),
otp->name, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_CONFLICT, PM_DEP_MOD_ANY, otp->name, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
}
}
}
}
}
/* CHECK 3: check database against targets */
_alpm_log(PM_LOG_DEBUG, _("checkconflicts: db vs targ '%s'"), tp->name);
for(k = _alpm_db_get_pkgcache(db, INFRQ_DEPENDS); k; k = k->next) {
alpm_list_t *conflicts = NULL;
int usenewconflicts = 0;
info = k->data; for(i = baddeps; i; i = i->next) {
if(!strcmp(info->name, tp->name)) { pmdepmissing_t *miss = i->data;
/* a package cannot conflict with itself -- that's just not nice */ _alpm_log(PM_LOG_DEBUG, _("\tCONFLICTS:: %s conflicts with %s"), miss->target, miss->depend.name);
continue;
}
/* If this package (*info) is also in our packages alpm_list_t, use the
* conflicts list from the new package, not the old one (*info)
*/
for(j = packages; j; j = j->next) {
pmpkg_t *pkg = j->data;
if(!strcmp(pkg->name, info->name)) {
/* Use the new, to-be-installed package's conflicts */
conflicts = pkg->conflicts;
usenewconflicts = 1;
}
}
if(!usenewconflicts) {
/* Use the old package's conflicts, it's the only set we have */
conflicts = info->conflicts;
}
for(j = conflicts; j; j = j->next) {
if(!strcmp((char *)j->data, tp->name)) {
_alpm_log(PM_LOG_DEBUG, _("db vs targs: found %s as a conflict for %s"),
info->name, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_CONFLICT, PM_DEP_MOD_ANY, info->name, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
} else {
/* see if the db package conflicts with something we provide */
alpm_list_t *m;
for(m = conflicts; m; m = m->next) {
alpm_list_t *n;
for(n = tp->provides; n; n = n->next) {
if(!strcmp(m->data, n->data)) {
_alpm_log(PM_LOG_DEBUG, _("db vs targs: found %s as a conflict for %s"),
info->name, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_CONFLICT, PM_DEP_MOD_ANY, info->name, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
FREE(miss);
}
}
}
}
}
}
}
} }
return(baddeps); return(baddeps);
} }
/* Returns a alpm_list_t* of file conflicts. /* Returns a alpm_list_t* of file conflicts.
* Hooray for set-intersects! * Hooray for set-intersects!
* Pre-condition: both lists are sorted! * Pre-condition: both lists are sorted!
@ -288,8 +338,8 @@ static alpm_list_t *chk_filedifference(alpm_list_t *filesA, alpm_list_t *filesB)
* functionality that was done inline. * functionality that was done inline.
*/ */
static alpm_list_t *add_fileconflict(alpm_list_t *conflicts, static alpm_list_t *add_fileconflict(alpm_list_t *conflicts,
pmconflicttype_t type, char *filestr, char* name1, pmconflicttype_t type, const char *filestr,
char* name2) const char* name1, const char* name2)
{ {
pmconflict_t *conflict = malloc(sizeof(pmconflict_t)); pmconflict_t *conflict = malloc(sizeof(pmconflict_t));
if(conflict == NULL) { if(conflict == NULL) {
@ -349,15 +399,16 @@ alpm_list_t *_alpm_db_find_conflicts(pmdb_t *db, pmtrans_t *trans, char *root)
if(!p2) { if(!p2) {
continue; continue;
} }
_alpm_log(PM_LOG_DEBUG, "searching for file conflicts: %s and %s", p1->name, p2->name); _alpm_log(PM_LOG_DEBUG, "searching for file conflicts: %s and %s",
tmpfiles = chk_fileconflicts(p1->files, p2->files); alpm_pkg_get_name(p1), alpm_pkg_get_name(p2));
tmpfiles = chk_fileconflicts(alpm_pkg_get_files(p1), alpm_pkg_get_files(p2));
if(tmpfiles) { if(tmpfiles) {
char path[PATH_MAX]; char path[PATH_MAX];
for(k = tmpfiles; k; k = k->next) { for(k = tmpfiles; k; k = k->next) {
snprintf(path, PATH_MAX, "%s%s", root, (char *)k->data); snprintf(path, PATH_MAX, "%s%s", root, (char *)k->data);
conflicts = add_fileconflict(conflicts, PM_CONFLICT_TYPE_TARGET, conflicts = add_fileconflict(conflicts, PM_CONFLICT_TYPE_TARGET, path,
path, p1->name, p2->name); alpm_pkg_get_name(p1), alpm_pkg_get_name(p2));
} }
alpm_list_free_inner(tmpfiles, &free); alpm_list_free_inner(tmpfiles, &free);
alpm_list_free(tmpfiles); alpm_list_free(tmpfiles);
@ -373,10 +424,10 @@ alpm_list_t *_alpm_db_find_conflicts(pmdb_t *db, pmtrans_t *trans, char *root)
* is not currently installed, then simply stat the whole filelist */ * is not currently installed, then simply stat the whole filelist */
if(dbpkg) { if(dbpkg) {
/* older ver of package currently installed */ /* older ver of package currently installed */
tmpfiles = chk_filedifference(p1->files, alpm_pkg_get_files(dbpkg)); tmpfiles = chk_filedifference(alpm_pkg_get_files(p1), alpm_pkg_get_files(dbpkg));
} else { } else {
/* no version of package currently installed */ /* no version of package currently installed */
tmpfiles = alpm_list_strdup(p1->files); tmpfiles = alpm_list_strdup(alpm_pkg_get_files(p1));
} }
/* loop over each file to be installed */ /* loop over each file to be installed */

16
lib/libalpm/db.c
View File

@ -71,7 +71,7 @@ pmdb_t *_alpm_db_new(const char *root, const char *dbpath, const char *treename)
FREE(db); FREE(db);
RET_ERR(PM_ERR_MEMORY, NULL); RET_ERR(PM_ERR_MEMORY, NULL);
} }
sprintf(db->path, "%s%s%s", root, dbpath, treename); sprintf(db->path, "%s%s%s/", root, dbpath, treename);
STRNCPY(db->treename, treename, PATH_MAX); STRNCPY(db->treename, treename, PATH_MAX);
@ -115,23 +115,23 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, alpm_list_t *needles)
RET_ERR(PM_ERR_INVALID_REGEX, NULL); RET_ERR(PM_ERR_INVALID_REGEX, NULL);
} }
for(j = _alpm_db_get_pkgcache(db, INFRQ_DESC|INFRQ_DEPENDS); j; j = j->next) { for(j = _alpm_db_get_pkgcache(db); j; j = j->next) {
pmpkg_t *pkg = j->data; pmpkg_t *pkg = j->data;
char *matched = NULL; const char *matched = NULL;
/* check name */ /* check name */
if (regexec(&reg, pkg->name, 0, 0, 0) == 0) { if (regexec(&reg, alpm_pkg_get_name(pkg), 0, 0, 0) == 0) {
matched = pkg->name; matched = alpm_pkg_get_name(pkg);
} }
/* check desc */ /* check desc */
else if (regexec(&reg, pkg->desc, 0, 0, 0) == 0) { else if (regexec(&reg, alpm_pkg_get_desc(pkg), 0, 0, 0) == 0) {
matched = pkg->desc; matched = alpm_pkg_get_desc(pkg);
} }
/* check provides */ /* check provides */
/* TODO: should we be doing this, and should we print something /* TODO: should we be doing this, and should we print something
* differently when we do match it since it isn't currently printed? */ * differently when we do match it since it isn't currently printed? */
else { else {
for(k = pkg->provides; k; k = k->next) { for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
if (regexec(&reg, k->data, 0, 0, 0) == 0) { if (regexec(&reg, k->data, 0, 0, 0) == 0) {
matched = k->data; matched = k->data;
break; break;

2
lib/libalpm/db.h
View File

@ -58,7 +58,7 @@ int _alpm_db_install(pmdb_t *db, const char *dbfile);
int _alpm_db_open(pmdb_t *db); int _alpm_db_open(pmdb_t *db);
void _alpm_db_close(pmdb_t *db); void _alpm_db_close(pmdb_t *db);
void _alpm_db_rewind(pmdb_t *db); void _alpm_db_rewind(pmdb_t *db);
pmpkg_t *_alpm_db_scan(pmdb_t *db, const char *target, pmdbinfrq_t inforeq); pmpkg_t *_alpm_db_scan(pmdb_t *db, const char *target);
int _alpm_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq); int _alpm_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq);
int _alpm_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq); int _alpm_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq);
int _alpm_db_remove(pmdb_t *db, pmpkg_t *info); int _alpm_db_remove(pmdb_t *db, pmpkg_t *info);

108
lib/libalpm/deps.c
View File

@ -136,8 +136,8 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, pmtranstype_t mode)
numscans++; numscans++;
/* run thru targets, moving up packages as necessary */ /* run thru targets, moving up packages as necessary */
for(i = newtargs; i; i = i->next) { for(i = newtargs; i; i = i->next) {
pmpkg_t *p = (pmpkg_t*)i->data; pmpkg_t *p = i->data;
_alpm_log(PM_LOG_DEBUG, "sorting %s", p->name); _alpm_log(PM_LOG_DEBUG, " sorting %s", alpm_pkg_get_name(p));
for(j = alpm_pkg_get_depends(p); j; j = j->next) { for(j = alpm_pkg_get_depends(p); j; j = j->next) {
pmdepend_t dep; pmdepend_t dep;
pmpkg_t *q = NULL; pmpkg_t *q = NULL;
@ -148,17 +148,19 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, pmtranstype_t mode)
* move it up above p * move it up above p
*/ */
for(k = i->next; k; k = k->next) { for(k = i->next; k; k = k->next) {
q = (pmpkg_t *)k->data; q = k->data;
if(!strcmp(dep.name, q->name)) { const char *qname = alpm_pkg_get_name(q);
if(!_alpm_pkg_find(q->name, tmptargs)) { if(!strcmp(dep.name, qname)) {
if(!_alpm_pkg_find(qname, tmptargs)) {
change = 1; change = 1;
tmptargs = alpm_list_add(tmptargs, q); tmptargs = alpm_list_add(tmptargs, q);
} }
break; break;
} }
for(l = q->provides; l; l = l->next) { for(l = alpm_pkg_get_provides(q); l; l = l->next) {
if(!strcmp(dep.name, (char*)l->data)) { const char *provname = l->data;
if(!_alpm_pkg_find((char*)l->data, tmptargs)) { if(!strcmp(dep.name, provname)) {
if(!_alpm_pkg_find(provname, tmptargs)) {
change = 1; change = 1;
tmptargs = alpm_list_add(tmptargs, q); tmptargs = alpm_list_add(tmptargs, q);
} }
@ -167,7 +169,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, pmtranstype_t mode)
} }
} }
} }
if(!_alpm_pkg_find(p->name, tmptargs)) { if(!_alpm_pkg_find(alpm_pkg_get_name(p), tmptargs)) {
tmptargs = alpm_list_add(tmptargs, p); tmptargs = alpm_list_add(tmptargs, p);
} }
} }
@ -221,8 +223,9 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
continue; continue;
} }
if((oldpkg = _alpm_db_get_pkgfromcache(db, newpkg->name)) == NULL) { if((oldpkg = _alpm_db_get_pkgfromcache(db, alpm_pkg_get_name(newpkg))) == NULL) {
_alpm_log(PM_LOG_DEBUG, _("cannot find package installed '%s'"), newpkg->name); _alpm_log(PM_LOG_DEBUG, _("cannot find package installed '%s'"),
alpm_pkg_get_name(newpkg));
continue; continue;
} }
for(j = alpm_pkg_get_requiredby(oldpkg); j; j = j->next) { for(j = alpm_pkg_get_requiredby(oldpkg); j; j = j->next) {
@ -232,7 +235,7 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
/* hmmm... package isn't installed.. */ /* hmmm... package isn't installed.. */
continue; continue;
} }
if(_alpm_pkg_find(p->name, packages)) { if(_alpm_pkg_find(alpm_pkg_get_name(p), packages)) {
/* this package also in the upgrade list, so don't worry about it */ /* this package also in the upgrade list, so don't worry about it */
continue; continue;
} }
@ -250,7 +253,7 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
if(_alpm_depcmp(pkg, &depend)) { if(_alpm_depcmp(pkg, &depend)) {
_alpm_log(PM_LOG_DEBUG, _("checkdeps: dependency '%s' has moved from '%s' to '%s'"), _alpm_log(PM_LOG_DEBUG, _("checkdeps: dependency '%s' has moved from '%s' to '%s'"),
depend.name, oldpkg->name, pkg->name); depend.name, alpm_pkg_get_name(oldpkg), alpm_pkg_get_name(pkg));
satisfied = 1; satisfied = 1;
break; break;
} }
@ -259,17 +262,17 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
if(!satisfied) { if(!satisfied) {
/* worst case... check installed packages to see if anything else /* worst case... check installed packages to see if anything else
* satisfies this... */ * satisfies this... */
for(l = _alpm_db_get_pkgcache(db, INFRQ_DEPENDS); l; l = l->next) { for(l = _alpm_db_get_pkgcache(db); l; l = l->next) {
pmpkg_t *pkg = l->data; pmpkg_t *pkg = l->data;
if(strcmp(pkg->name, oldpkg->name) == 0) { if(strcmp(alpm_pkg_get_name(pkg), alpm_pkg_get_name(oldpkg)) == 0) {
/* well, we know this one succeeds, but we're removing it... skip it */ /* well, we know this one succeeds, but we're removing it... skip it */
continue; continue;
} }
if(_alpm_depcmp(pkg, &depend)) { if(_alpm_depcmp(pkg, &depend)) {
_alpm_log(PM_LOG_DEBUG, _("checkdeps: dependency '%s' satisfied by installed package '%s'"), _alpm_log(PM_LOG_DEBUG, _("checkdeps: dependency '%s' satisfied by installed package '%s'"),
depend.name, pkg->name); depend.name, alpm_pkg_get_name(pkg));
satisfied = 1; satisfied = 1;
break; break;
} }
@ -278,7 +281,7 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
if(!satisfied) { if(!satisfied) {
_alpm_log(PM_LOG_DEBUG, _("checkdeps: updated '%s' won't satisfy a dependency of '%s'"), _alpm_log(PM_LOG_DEBUG, _("checkdeps: updated '%s' won't satisfy a dependency of '%s'"),
oldpkg->name, p->name); alpm_pkg_get_name(oldpkg), alpm_pkg_get_name(p));
miss = _alpm_depmiss_new(p->name, PM_DEP_TYPE_REQUIRED, depend.mod, miss = _alpm_depmiss_new(p->name, PM_DEP_TYPE_REQUIRED, depend.mod,
depend.name, depend.version); depend.name, depend.version);
if(!_alpm_depmiss_isin(miss, baddeps)) { if(!_alpm_depmiss_isin(miss, baddeps)) {
@ -301,28 +304,19 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
continue; continue;
} }
/* ensure package has depends data */ for(j = alpm_pkg_get_depends(tp); j; j = j->next) {
pmdb_t *pkgdb = tp->data;
_alpm_db_read(pkgdb, tp, INFRQ_DEPENDS);
if(!tp->depends) {
_alpm_log(PM_LOG_DEBUG, _("no dependencies for target '%s'"), tp->name);
}
for(j = tp->depends; j; j = j->next) {
/* split into name/version pairs */ /* split into name/version pairs */
_alpm_splitdep((char *)j->data, &depend); _alpm_splitdep((char *)j->data, &depend);
found = 0; found = 0;
/* check database for literal packages */ /* check database for literal packages */
for(k = _alpm_db_get_pkgcache(db, INFRQ_DESC|INFRQ_DEPENDS); for(k = _alpm_db_get_pkgcache(db); k && !found; k = k->next) {
k && !found; k = k->next) {
pmpkg_t *p = (pmpkg_t *)k->data; pmpkg_t *p = (pmpkg_t *)k->data;
found = _alpm_depcmp(p, &depend); found = _alpm_depcmp(p, &depend);
} }
/* check database for provides matches */ /* check database for provides matches */
if(!found) { if(!found) {
alpm_list_t *m; alpm_list_t *m;
k = _alpm_db_whatprovides(db, depend.name); for(m = _alpm_db_whatprovides(db, depend.name); m && !found; m = m->next) {
for(m = k; m && !found; m = m->next) {
/* look for a match that isn't one of the packages we're trying /* look for a match that isn't one of the packages we're trying
* to install. this way, if we match against a to-be-installed * to install. this way, if we match against a to-be-installed
* package, we'll defer to the NEW one, not the one already * package, we'll defer to the NEW one, not the one already
@ -332,7 +326,7 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
int skip = 0; int skip = 0;
for(n = packages; n && !skip; n = n->next) { for(n = packages; n && !skip; n = n->next) {
pmpkg_t *ptp = n->data; pmpkg_t *ptp = n->data;
if(!strcmp(ptp->name, p->name)) { if(strcmp(alpm_pkg_get_name(ptp), alpm_pkg_get_name(p)) == 0) {
skip = 1; skip = 1;
} }
} }
@ -346,14 +340,14 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
} }
/* check other targets */ /* check other targets */
for(k = packages; k && !found; k = k->next) { for(k = packages; k && !found; k = k->next) {
pmpkg_t *p = (pmpkg_t *)k->data; pmpkg_t *p = k->data;
found = _alpm_depcmp(p, &depend); found = _alpm_depcmp(p, &depend);
} }
/* else if still not found... */ /* else if still not found... */
if(!found) { if(!found) {
_alpm_log(PM_LOG_DEBUG, _("missing dependency '%s' for package '%s'"), _alpm_log(PM_LOG_DEBUG, _("missing dependency '%s' for package '%s'"),
depend.name, tp->name); depend.name, alpm_pkg_get_name(tp));
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_DEPEND, depend.mod, miss = _alpm_depmiss_new(alpm_pkg_get_name(tp), PM_DEP_TYPE_DEPEND, depend.mod,
depend.name, depend.version); depend.name, depend.version);
if(!_alpm_depmiss_isin(miss, baddeps)) { if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss); baddeps = alpm_list_add(baddeps, miss);
@ -372,13 +366,13 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
} }
found=0; found=0;
for(j = tp->requiredby; j; j = j->next) { for(j = alpm_pkg_get_requiredby(tp); j; j = j->next) {
/* Search for 'reqname' in packages for removal */ /* Search for 'reqname' in packages for removal */
char *reqname = j->data; char *reqname = j->data;
alpm_list_t *x = NULL; alpm_list_t *x = NULL;
for(x = packages; x; x = x->next) { for(x = packages; x; x = x->next) {
pmpkg_t *xp = x->data; pmpkg_t *xp = x->data;
if(strcmp(reqname, xp->name) == 0) { if(strcmp(reqname, alpm_pkg_get_name(xp)) == 0) {
found = 1; found = 1;
break; break;
} }
@ -394,15 +388,15 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
spkg = k->data; spkg = k->data;
} }
if(spkg) { if(spkg) {
if(alpm_list_find_str(spkg->provides, tp->name)) { if(alpm_list_find_str(alpm_pkg_get_provides(spkg), tp->name)) {
found = 1; found = 1;
} }
} }
} }
if(!found) { if(!found) {
_alpm_log(PM_LOG_DEBUG, _("checkdeps: found %s as required by %s"), _alpm_log(PM_LOG_DEBUG, _("checkdeps: found %s as required by %s"),
reqname, tp->name); reqname, alpm_pkg_get_name(tp));
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_REQUIRED, miss = _alpm_depmiss_new(alpm_pkg_get_name(tp), PM_DEP_TYPE_REQUIRED,
PM_DEP_MOD_ANY, j->data, NULL); PM_DEP_MOD_ANY, j->data, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) { if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss); baddeps = alpm_list_add(baddeps, miss);
@ -468,20 +462,20 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets)
{ {
alpm_list_t *i; alpm_list_t *i;
if(_alpm_pkg_find(pkg->name, targets)) { if(_alpm_pkg_find(alpm_pkg_get_name(pkg), targets)) {
return(0); return(0);
} }
/* see if it was explicitly installed */ /* see if it was explicitly installed */
if(alpm_pkg_get_reason(pkg) == PM_PKG_REASON_EXPLICIT) { if(alpm_pkg_get_reason(pkg) == PM_PKG_REASON_EXPLICIT) {
_alpm_log(PM_LOG_DEBUG, _("excluding %s -- explicitly installed"), pkg->name); _alpm_log(PM_LOG_DEBUG, _("excluding %s -- explicitly installed"), alpm_pkg_get_name(pkg));
return(0); return(0);
} }
/* see if other packages need it */ /* see if other packages need it */
for(i = alpm_pkg_get_requiredby(pkg); i; i = i->next) { for(i = alpm_pkg_get_requiredby(pkg); i; i = i->next) {
pmpkg_t *reqpkg = _alpm_db_get_pkgfromcache(db, i->data); pmpkg_t *reqpkg = _alpm_db_get_pkgfromcache(db, i->data);
if(reqpkg && !_alpm_pkg_find(reqpkg->name, targets)) { if(reqpkg && !_alpm_pkg_find(alpm_pkg_get_name(reqpkg), targets)) {
return(0); return(0);
} }
} }
@ -527,10 +521,9 @@ alpm_list_t *_alpm_removedeps(pmdb_t *db, alpm_list_t *targs)
for(k = provides; k; k = k->next) { for(k = provides; k; k = k->next) {
pmpkg_t *provpkg = k->data; pmpkg_t *provpkg = k->data;
if(can_remove_package(db, provpkg, newtargs)) { if(can_remove_package(db, provpkg, newtargs)) {
pmpkg_t *pkg = _alpm_pkg_new(provpkg->name, provpkg->version); pmpkg_t *pkg = _alpm_pkg_new(alpm_pkg_get_name(provpkg), alpm_pkg_get_version(provpkg));
_alpm_db_read(db, pkg, INFRQ_ALL);
_alpm_log(PM_LOG_DEBUG, _("adding '%s' to the targets"), pkg->name); _alpm_log(PM_LOG_DEBUG, _("adding '%s' to the targets"), alpm_pkg_get_name(pkg));
/* add it to the target list */ /* add it to the target list */
newtargs = alpm_list_add(newtargs, pkg); newtargs = alpm_list_add(newtargs, pkg);
@ -540,9 +533,8 @@ alpm_list_t *_alpm_removedeps(pmdb_t *db, alpm_list_t *targs)
FREELISTPTR(provides); FREELISTPTR(provides);
} else if(can_remove_package(db, dep, newtargs)) { } else if(can_remove_package(db, dep, newtargs)) {
pmpkg_t *pkg = _alpm_pkg_new(dep->name, dep->version); pmpkg_t *pkg = _alpm_pkg_new(dep->name, dep->version);
_alpm_db_read(db, pkg, INFRQ_ALL);
_alpm_log(PM_LOG_DEBUG, _("adding '%s' to the targets"), pkg->name); _alpm_log(PM_LOG_DEBUG, _("adding '%s' to the targets"), alpm_pkg_get_name(pkg));
/* add it to the target list */ /* add it to the target list */
newtargs = alpm_list_add(newtargs, pkg); newtargs = alpm_list_add(newtargs, pkg);
@ -589,10 +581,10 @@ int _alpm_resolvedeps(pmdb_t *local, alpm_list_t *dbs_sync, pmpkg_t *syncpkg,
/* check if one of the packages in *list already provides this dependency */ /* check if one of the packages in *list already provides this dependency */
for(j = list; j && !found; j = j->next) { for(j = list; j && !found; j = j->next) {
pmpkg_t *sp = (pmpkg_t *)j->data; pmpkg_t *sp = j->data;
if(alpm_list_find_str(sp->provides, miss->depend.name)) { if(alpm_list_find_str(alpm_pkg_get_provides(sp), miss->depend.name)) {
_alpm_log(PM_LOG_DEBUG, _("%s provides dependency %s -- skipping"), _alpm_log(PM_LOG_DEBUG, _("%s provides dependency %s -- skipping"),
sp->name, miss->depend.name); alpm_pkg_get_name(sp), miss->depend.name);
found = 1; found = 1;
} }
} }
@ -604,9 +596,11 @@ int _alpm_resolvedeps(pmdb_t *local, alpm_list_t *dbs_sync, pmpkg_t *syncpkg,
/* check literals */ /* check literals */
for(j = dbs_sync; !sync && j; j = j->next) { for(j = dbs_sync; !sync && j; j = j->next) {
sync = _alpm_db_get_pkgfromcache(j->data, miss->depend.name); sync = _alpm_db_get_pkgfromcache(j->data, miss->depend.name);
_alpm_db_read(j->data, sync, INFRQ_DEPENDS);
} }
/*TODO this autoresolves the first 'provides' package... we should fix this
* somehow */
/* check provides */ /* check provides */
if(!sync) {
for(j = dbs_sync; !sync && j; j = j->next) { for(j = dbs_sync; !sync && j; j = j->next) {
alpm_list_t *provides; alpm_list_t *provides;
provides = _alpm_db_whatprovides(j->data, miss->depend.name); provides = _alpm_db_whatprovides(j->data, miss->depend.name);
@ -615,7 +609,9 @@ int _alpm_resolvedeps(pmdb_t *local, alpm_list_t *dbs_sync, pmpkg_t *syncpkg,
} }
FREELISTPTR(provides); FREELISTPTR(provides);
} }
if(sync == NULL) { }
if(!sync) {
_alpm_log(PM_LOG_ERROR, _("cannot resolve dependencies for \"%s\" (\"%s\" is not in the package set)"), _alpm_log(PM_LOG_ERROR, _("cannot resolve dependencies for \"%s\" (\"%s\" is not in the package set)"),
miss->target, miss->depend.name); miss->target, miss->depend.name);
if(data) { if(data) {
@ -631,19 +627,19 @@ int _alpm_resolvedeps(pmdb_t *local, alpm_list_t *dbs_sync, pmpkg_t *syncpkg,
pm_errno = PM_ERR_UNSATISFIED_DEPS; pm_errno = PM_ERR_UNSATISFIED_DEPS;
goto error; goto error;
} }
if(_alpm_pkg_find(sync->name, list)) { if(_alpm_pkg_find(alpm_pkg_get_name(sync), list)) {
/* this dep is already in the target list */ /* this dep is already in the target list */
_alpm_log(PM_LOG_DEBUG, _("dependency %s is already in the target list -- skipping"), _alpm_log(PM_LOG_DEBUG, _("dependency %s is already in the target list -- skipping"),
sync->name); alpm_pkg_get_name(sync));
continue; continue;
} }
if(!_alpm_pkg_find(sync->name, trail)) { if(!_alpm_pkg_find(alpm_pkg_get_name(sync), trail)) {
/* check pmo_ignorepkg and pmo_s_ignore to make sure we haven't pulled in /* check pmo_ignorepkg and pmo_s_ignore to make sure we haven't pulled in
* something we're not supposed to. * something we're not supposed to.
*/ */
int usedep = 1; int usedep = 1;
if(alpm_list_find_str(handle->ignorepkg, sync->name)) { if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(sync))) {
pmpkg_t *dummypkg = _alpm_pkg_new(miss->target, NULL); pmpkg_t *dummypkg = _alpm_pkg_new(miss->target, NULL);
QUESTION(trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, dummypkg, sync, NULL, &usedep); QUESTION(trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, dummypkg, sync, NULL, &usedep);
FREEPKG(dummypkg); FREEPKG(dummypkg);
@ -654,7 +650,7 @@ int _alpm_resolvedeps(pmdb_t *local, alpm_list_t *dbs_sync, pmpkg_t *syncpkg,
goto error; goto error;
} }
_alpm_log(PM_LOG_DEBUG, _("pulling dependency %s (needed by %s)"), _alpm_log(PM_LOG_DEBUG, _("pulling dependency %s (needed by %s)"),
sync->name, syncpkg->name); alpm_pkg_get_name(sync), alpm_pkg_get_name(syncpkg));
list = alpm_list_add(list, sync); list = alpm_list_add(list, sync);
} else { } else {
_alpm_log(PM_LOG_ERROR, _("cannot resolve dependencies for \"%s\""), miss->target); _alpm_log(PM_LOG_ERROR, _("cannot resolve dependencies for \"%s\""), miss->target);

67
lib/libalpm/package.c
View File

@ -82,17 +82,17 @@ pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
} }
memcpy(newpkg, pkg, sizeof(pmpkg_t)); memcpy(newpkg, pkg, sizeof(pmpkg_t));
newpkg->license = alpm_list_strdup(pkg->license); newpkg->licenses = alpm_list_strdup(alpm_pkg_get_licenses(pkg));
/*newpkg->desc_localized = alpm_list_strdup(pkg->desc_localized);*/ /*newpkg->desc_localized = alpm_list_strdup(pkg->desc_localized);*/
newpkg->requiredby = alpm_list_strdup(pkg->requiredby); newpkg->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(pkg));
newpkg->conflicts = alpm_list_strdup(pkg->conflicts); newpkg->conflicts = alpm_list_strdup(alpm_pkg_get_conflicts(pkg));
newpkg->files = alpm_list_strdup(pkg->files); newpkg->files = alpm_list_strdup(alpm_pkg_get_files(pkg));
newpkg->backup = alpm_list_strdup(pkg->backup); newpkg->backup = alpm_list_strdup(alpm_pkg_get_backup(pkg));
newpkg->depends = alpm_list_strdup(pkg->depends); newpkg->depends = alpm_list_strdup(alpm_pkg_get_depends(pkg));
newpkg->removes = alpm_list_strdup(pkg->removes); newpkg->removes = alpm_list_strdup(alpm_pkg_get_removes(pkg));
newpkg->groups = alpm_list_strdup(pkg->groups); newpkg->groups = alpm_list_strdup(alpm_pkg_get_groups(pkg));
newpkg->provides = alpm_list_strdup(pkg->provides); newpkg->provides = alpm_list_strdup(alpm_pkg_get_provides(pkg));
newpkg->replaces = alpm_list_strdup(pkg->replaces); newpkg->replaces = alpm_list_strdup(alpm_pkg_get_replaces(pkg));
/* internal */ /* internal */
newpkg->data = (newpkg->origin == PKG_FROM_FILE) ? strdup(pkg->data) : pkg->data; newpkg->data = (newpkg->origin == PKG_FROM_FILE) ? strdup(pkg->data) : pkg->data;
@ -109,7 +109,7 @@ void _alpm_pkg_free(void *data)
return; return;
} }
FREELIST(pkg->license); FREELIST(pkg->licenses);
/*FREELIST(pkg->desc_localized);*/ /*FREELIST(pkg->desc_localized);*/
FREELIST(pkg->files); FREELIST(pkg->files);
FREELIST(pkg->backup); FREELIST(pkg->backup);
@ -141,28 +141,32 @@ int alpm_pkg_compare_versions(pmpkg_t *local_pkg, pmpkg_t *pkg)
} }
/* compare versions and see if we need to upgrade */ /* compare versions and see if we need to upgrade */
cmp = _alpm_versioncmp(pkg->version, local_pkg->version); cmp = _alpm_versioncmp(alpm_pkg_get_version(pkg), alpm_pkg_get_version(local_pkg));
if(cmp != 0 && pkg->force) { if(cmp != 0 && pkg->force) {
cmp = 1; cmp = 1;
_alpm_log(PM_LOG_WARNING, _("%s: forcing upgrade to version %s"), local_pkg->name, pkg->version); _alpm_log(PM_LOG_WARNING, _("%s: forcing upgrade to version %s"),
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
} else if(cmp < 0) { } else if(cmp < 0) {
/* local version is newer */ /* local version is newer */
pmdb_t *db = pkg->data; pmdb_t *db = pkg->data;
_alpm_log(PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)"), _alpm_log(PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)"),
local_pkg->name, local_pkg->version, db->treename, pkg->version); alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
alpm_db_get_name(db), alpm_pkg_get_version(pkg));
cmp = 0; cmp = 0;
} else if(cmp > 0) { } else if(cmp > 0) {
/* we have an upgrade, make sure we should actually do it */ /* we have an upgrade, make sure we should actually do it */
if(alpm_list_find_str(handle->ignorepkg, pkg->name)) { if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(pkg))) {
/* package should be ignored (IgnorePkg) */ /* package should be ignored (IgnorePkg) */
_alpm_log(PM_LOG_WARNING, _("%s-%s: ignoring package upgrade (%s)"), _alpm_log(PM_LOG_WARNING, _("%s-%s: ignoring package upgrade (%s)"),
local_pkg->name, local_pkg->version, pkg->version); alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
alpm_pkg_get_version(pkg));
cmp = 0; cmp = 0;
} else if(_alpm_pkg_istoonew(pkg)) { } else if(_alpm_pkg_istoonew(pkg)) {
/* package too new (UpgradeDelay) */ /* package too new (UpgradeDelay) */
_alpm_log(PM_LOG_WARNING, _("%s-%s: delaying upgrade of package (%s)"), _alpm_log(PM_LOG_WARNING, _("%s-%s: delaying upgrade of package (%s)"),
local_pkg->name, local_pkg->version, pkg->version); alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
alpm_pkg_get_version(pkg));
cmp = 0; cmp = 0;
} }
} }
@ -174,7 +178,10 @@ int alpm_pkg_compare_versions(pmpkg_t *local_pkg, pmpkg_t *pkg)
*/ */
int _alpm_pkg_cmp(const void *p1, const void *p2) int _alpm_pkg_cmp(const void *p1, const void *p2)
{ {
return(strcmp(((pmpkg_t *)p1)->name, ((pmpkg_t *)p2)->name)); pmpkg_t *pk1 = (pmpkg_t *)p1;
pmpkg_t *pk2 = (pmpkg_t *)p2;
return(strcmp(alpm_pkg_get_name(pk1), alpm_pkg_get_name(pk2)));
} }
/* Parses the package description file for the current package /* Parses the package description file for the current package
@ -240,7 +247,7 @@ static int parse_descfile(const char *descfile, pmpkg_t *info)
} else if(!strcmp(key, "URL")) { } else if(!strcmp(key, "URL")) {
STRNCPY(info->url, ptr, sizeof(info->url)); STRNCPY(info->url, ptr, sizeof(info->url));
} else if(!strcmp(key, "LICENSE")) { } else if(!strcmp(key, "LICENSE")) {
info->license = alpm_list_add(info->license, strdup(ptr)); info->licenses = alpm_list_add(info->licenses, strdup(ptr));
} else if(!strcmp(key, "BUILDDATE")) { } else if(!strcmp(key, "BUILDDATE")) {
STRNCPY(info->builddate, ptr, sizeof(info->builddate)); STRNCPY(info->builddate, ptr, sizeof(info->builddate));
} else if(!strcmp(key, "BUILDTYPE")) { } else if(!strcmp(key, "BUILDTYPE")) {
@ -467,7 +474,7 @@ pmpkg_t *_alpm_pkg_find(const char *needle, alpm_list_t *haystack)
for(lp = haystack; lp; lp = lp->next) { for(lp = haystack; lp; lp = lp->next) {
pmpkg_t *info = lp->data; pmpkg_t *info = lp->data;
if(info && strcmp(info->name, needle) == 0) { if(info && strcmp(alpm_pkg_get_name(info), needle) == 0) {
return(info); return(info);
} }
} }
@ -533,12 +540,12 @@ void _alpm_pkg_update_requiredby(pmpkg_t *pkg)
alpm_list_t *i, *j, *k; alpm_list_t *i, *j, *k;
pmdb_t *localdb = alpm_option_get_localdb(); pmdb_t *localdb = alpm_option_get_localdb();
for(i = _alpm_db_get_pkgcache(localdb, INFRQ_DEPENDS); i; i = i->next) { for(i = _alpm_db_get_pkgcache(localdb); i; i = i->next) {
if(!i->data) { if(!i->data) {
continue; continue;
} }
pmpkg_t *cachepkg = i->data; pmpkg_t *cachepkg = i->data;
for(j = cachepkg->depends; j; j = j->next) { for(j = alpm_pkg_get_depends(cachepkg); j; j = j->next) {
pmdepend_t dep; pmdepend_t dep;
if(!j->data) { if(!j->data) {
continue; continue;
@ -548,19 +555,23 @@ void _alpm_pkg_update_requiredby(pmpkg_t *pkg)
} }
/* check the actual package itself */ /* check the actual package itself */
if(strcmp(dep.name, pkg->name) == 0) { if(strcmp(dep.name, alpm_pkg_get_name(pkg)) == 0) {
_alpm_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s'"), _alpm_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s'"),
cachepkg->name, pkg->name); cachepkg->name, pkg->name);
pkg->requiredby = alpm_list_add(pkg->requiredby, strdup(cachepkg->name)); alpm_list_t *reqs = alpm_pkg_get_requiredby(pkg);
reqs = alpm_list_add(reqs, strdup(alpm_pkg_get_name(cachepkg)));
pkg->requiredby = reqs;
} }
/* check for provisions as well */ /* check for provisions as well */
for(k = pkg->provides; k; k = k->next) { for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
const char *provname = k->data; const char *provname = k->data;
if(strcmp(dep.name, provname) == 0) { if(strcmp(dep.name, provname) == 0) {
_alpm_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s' (provides: %s)"), _alpm_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s' (provides: %s)"),
cachepkg->name, pkg->name, provname); alpm_pkg_get_name(cachepkg), alpm_pkg_get_name(pkg), provname);
pkg->requiredby = alpm_list_add(pkg->requiredby, strdup(cachepkg->name)); alpm_list_t *reqs = alpm_pkg_get_requiredby(pkg);
reqs = alpm_list_add(reqs, strdup(alpm_pkg_get_name(cachepkg)));
pkg->requiredby = reqs;
} }
} }
} }
@ -799,7 +810,7 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_licenses(pmpkg_t *pkg)
if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) { if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
_alpm_db_read(pkg->data, pkg, INFRQ_DESC); _alpm_db_read(pkg->data, pkg, INFRQ_DESC);
} }
return pkg->license; return pkg->licenses;
} }
alpm_list_t SYMEXPORT *alpm_pkg_get_groups(pmpkg_t *pkg) alpm_list_t SYMEXPORT *alpm_pkg_get_groups(pmpkg_t *pkg)

2
lib/libalpm/package.h
View File

@ -71,7 +71,7 @@ struct __pmpkg_t {
time_t date; time_t date;
pmpkgreason_t reason; pmpkgreason_t reason;
/* alpm_list_t *desc_localized;*/ /* alpm_list_t *desc_localized;*/
alpm_list_t *license; alpm_list_t *licenses;
alpm_list_t *replaces; alpm_list_t *replaces;
alpm_list_t *groups; alpm_list_t *groups;
alpm_list_t *files; alpm_list_t *files;

2
lib/libalpm/provide.c
View File

@ -42,7 +42,7 @@ alpm_list_t *_alpm_db_whatprovides(pmdb_t *db, const char *package)
return(NULL); return(NULL);
} }
for(lp = _alpm_db_get_pkgcache(db, INFRQ_DEPENDS); lp; lp = lp->next) { for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
pmpkg_t *info = lp->data; pmpkg_t *info = lp->data;
if(alpm_list_find_str(alpm_pkg_get_provides(info), package)) { if(alpm_list_find_str(alpm_pkg_get_provides(info), package)) {

50
lib/libalpm/remove.c
View File

@ -73,7 +73,7 @@ int _alpm_remove_loadtarget(pmtrans_t *trans, pmdb_t *db, char *name)
RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1); RET_ERR(PM_ERR_TRANS_DUP_TARGET, -1);
} }
if((info = _alpm_db_scan(db, name, INFRQ_ALL)) == NULL) { if((info = _alpm_db_scan(db, name)) == NULL) {
/* Unimportant - just ignore it if we can't find it */ /* Unimportant - just ignore it if we can't find it */
_alpm_log(PM_LOG_DEBUG, _("could not find %s in database"), name); _alpm_log(PM_LOG_DEBUG, _("could not find %s in database"), name);
RET_ERR(PM_ERR_PKG_NOT_FOUND, -1); RET_ERR(PM_ERR_PKG_NOT_FOUND, -1);
@ -115,9 +115,9 @@ int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
alpm_list_t *i; alpm_list_t *i;
for(i = lp; i; i = i->next) { for(i = lp; i; i = i->next) {
pmdepmissing_t *miss = (pmdepmissing_t *)i->data; pmdepmissing_t *miss = (pmdepmissing_t *)i->data;
pmpkg_t *info = _alpm_db_scan(db, miss->depend.name, INFRQ_ALL); pmpkg_t *info = _alpm_db_scan(db, miss->depend.name);
if(info) { if(info) {
_alpm_log(PM_LOG_DEBUG, _("pulling %s in the targets list"), info->name); _alpm_log(PM_LOG_DEBUG, _("pulling %s in the targets list"), alpm_pkg_get_name(info));
trans->packages = alpm_list_add(trans->packages, info); trans->packages = alpm_list_add(trans->packages, info);
} else { } else {
_alpm_log(PM_LOG_ERROR, _("could not find %s in database -- skipping"), _alpm_log(PM_LOG_ERROR, _("could not find %s in database -- skipping"),
@ -200,7 +200,7 @@ static void unlink_file(pmpkg_t *info, alpm_list_t *lp, alpm_list_t *targ,
percent = (double)*position / filenum; percent = (double)*position / filenum;
} }
char *hash = _alpm_needbackup(lp->data, info->backup); char *hash = _alpm_needbackup(lp->data, alpm_pkg_get_backup(info));
if(hash) { if(hash) {
needbackup = 1; needbackup = 1;
FREE(hash); FREE(hash);
@ -275,6 +275,7 @@ int _alpm_remove_commit(pmtrans_t *trans, pmdb_t *db)
for(targ = trans->packages; targ; targ = targ->next) { for(targ = trans->packages; targ; targ = targ->next) {
int position = 0; int position = 0;
char pm_install[PATH_MAX]; char pm_install[PATH_MAX];
alpm_list_t *files;
info = (pmpkg_t*)targ->data; info = (pmpkg_t*)targ->data;
if(handle->trans->state == STATE_INTERRUPTED) { if(handle->trans->state == STATE_INTERRUPTED) {
@ -283,54 +284,63 @@ int _alpm_remove_commit(pmtrans_t *trans, pmdb_t *db)
if(trans->type != PM_TRANS_TYPE_UPGRADE) { if(trans->type != PM_TRANS_TYPE_UPGRADE) {
EVENT(trans, PM_TRANS_EVT_REMOVE_START, info, NULL); EVENT(trans, PM_TRANS_EVT_REMOVE_START, info, NULL);
_alpm_log(PM_LOG_DEBUG, _("removing package %s-%s"), info->name, info->version); _alpm_log(PM_LOG_DEBUG, _("removing package %s-%s"),
alpm_pkg_get_name(info), alpm_pkg_get_version(info));
/* run the pre-remove scriptlet if it exists */ /* run the pre-remove scriptlet if it exists */
if(info->scriptlet && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) { if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path, info->name, info->version); snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path,
_alpm_runscriptlet(handle->root, pm_install, "pre_remove", info->version, NULL, trans); alpm_pkg_get_name(info), alpm_pkg_get_version(info));
_alpm_runscriptlet(handle->root, pm_install, "pre_remove",
alpm_pkg_get_version(info), NULL, trans);
} }
} }
files = alpm_pkg_get_files(info);
if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) { if(!(trans->flags & PM_TRANS_FLAG_DBONLY)) {
for(lp = info->files; lp; lp = lp->next) { for(lp = files; lp; lp = lp->next) {
if(!can_remove_file(trans, lp->data)) { if(!can_remove_file(trans, lp->data)) {
_alpm_log(PM_LOG_DEBUG, _("not removing package '%s', can't remove all files"), info->name); _alpm_log(PM_LOG_DEBUG, _("not removing package '%s', can't remove all files"),
alpm_pkg_get_name(info));
RET_ERR(PM_ERR_PKG_CANT_REMOVE, -1); RET_ERR(PM_ERR_PKG_CANT_REMOVE, -1);
} }
} }
int filenum = alpm_list_count(info->files); int filenum = alpm_list_count(files);
_alpm_log(PM_LOG_DEBUG, _("removing files")); _alpm_log(PM_LOG_DEBUG, _("removing %d files"), filenum);
/* iterate through the list backwards, unlinking files */ /* iterate through the list backwards, unlinking files */
for(lp = alpm_list_last(info->files); lp; lp = lp->prev) { for(lp = alpm_list_last(files); lp; lp = lp->prev) {
unlink_file(info, lp, targ, trans, filenum, &position); unlink_file(info, lp, targ, trans, filenum, &position);
} }
} }
if(trans->type != PM_TRANS_TYPE_UPGRADE) { if(trans->type != PM_TRANS_TYPE_UPGRADE) {
/* run the post-remove script if it exists */ /* run the post-remove script if it exists */
if(info->scriptlet && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) { if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path, info->name, info->version); snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path,
_alpm_runscriptlet(handle->root, pm_install, "post_remove", info->version, NULL, trans); alpm_pkg_get_name(info), alpm_pkg_get_version(info));
_alpm_runscriptlet(handle->root, pm_install, "post_remove",
alpm_pkg_get_version(info), NULL, trans);
} }
} }
/* remove the package from the database */ /* remove the package from the database */
_alpm_log(PM_LOG_DEBUG, _("updating database")); _alpm_log(PM_LOG_DEBUG, _("updating database"));
_alpm_log(PM_LOG_DEBUG, _("removing database entry '%s'"), info->name); _alpm_log(PM_LOG_DEBUG, _("removing database entry '%s'"), alpm_pkg_get_name(info));
if(_alpm_db_remove(db, info) == -1) { if(_alpm_db_remove(db, info) == -1) {
_alpm_log(PM_LOG_ERROR, _("could not remove database entry %s-%s"), info->name, info->version); _alpm_log(PM_LOG_ERROR, _("could not remove database entry %s-%s"),
alpm_pkg_get_name(info), alpm_pkg_get_version(info));
} }
if(_alpm_db_remove_pkgfromcache(db, info) == -1) { if(_alpm_db_remove_pkgfromcache(db, info) == -1) {
_alpm_log(PM_LOG_ERROR, _("could not remove entry '%s' from cache"), info->name); _alpm_log(PM_LOG_ERROR, _("could not remove entry '%s' from cache"), alpm_pkg_get_name(info));
} }
/* update dependency packages' REQUIREDBY fields */ /* update dependency packages' REQUIREDBY fields */
_alpm_trans_update_depends(trans, info); _alpm_trans_update_depends(trans, info);
PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, info->name, 100, alpm_list_count(trans->packages), (alpm_list_count(trans->packages) - alpm_list_count(targ) +1)); PROGRESS(trans, PM_TRANS_PROGRESS_REMOVE_START, alpm_pkg_get_name(info), 100, alpm_list_count(trans->packages), (alpm_list_count(trans->packages) - alpm_list_count(targ) +1));
if(trans->type != PM_TRANS_TYPE_UPGRADE) { if(trans->type != PM_TRANS_TYPE_UPGRADE) {
EVENT(trans, PM_TRANS_EVT_REMOVE_DONE, info, NULL); EVENT(trans, PM_TRANS_EVT_REMOVE_DONE, info, NULL);
} }

191
lib/libalpm/sync.c
View File

@ -91,37 +91,13 @@ void _alpm_sync_free(void *data)
FREE(sync); FREE(sync);
} }
/* Test for existence of a package in a alpm_list_t* of pmsyncpkg_t*
* If found, return a pointer to the respective pmsyncpkg_t*
*/
static pmsyncpkg_t *find_pkginsync(char *needle, alpm_list_t *haystack)
{
alpm_list_t *i;
pmsyncpkg_t *sync = NULL;
int found = 0;
ALPM_LOG_FUNC;
for(i = haystack; i && !found; i = i->next) {
sync = i->data;
if(sync && !strcmp(sync->pkg->name, needle)) {
found = 1;
}
}
if(!found) {
sync = NULL;
}
return(sync);
}
/* Find recommended replacements for packages during a sync. /* Find recommended replacements for packages during a sync.
* (refactored from _alpm_sync_prepare) * (refactored from _alpm_sync_prepare)
*/ */
static int find_replacements(pmtrans_t *trans, pmdb_t *db_local, static int find_replacements(pmtrans_t *trans, pmdb_t *db_local,
alpm_list_t *dbs_sync) alpm_list_t *dbs_sync)
{ {
alpm_list_t *i, *j, *k, *m; /* wow */ alpm_list_t *i, *j, *k; /* wow */
ALPM_LOG_FUNC; ALPM_LOG_FUNC;
@ -131,20 +107,22 @@ static int find_replacements(pmtrans_t *trans, pmdb_t *db_local,
pmdb_t *db = i->data; pmdb_t *db = i->data;
/* for each db, check each package's REPLACES list */ /* for each db, check each package's REPLACES list */
for(j = _alpm_db_get_pkgcache(db, INFRQ_DESC); j; j = j->next) { for(j = _alpm_db_get_pkgcache(db); j; j = j->next) {
pmpkg_t *spkg = j->data; pmpkg_t *spkg = j->data;
for(k = alpm_pkg_get_replaces(spkg); k; k = k->next) { for(k = alpm_pkg_get_replaces(spkg); k; k = k->next) {
const char *replacement = k->data; const char *replacement = k->data;
/* compare to local DB */
for(m = _alpm_db_get_pkgcache(db_local, INFRQ_BASE); m; m = m->next) {
pmpkg_t *lpkg = m->data;
if(strcmp(replacement, lpkg->name) == 0) { pmpkg_t *lpkg = _alpm_db_get_pkgfromcache(db_local, replacement);
if(!lpkg) {
continue;
}
_alpm_log(PM_LOG_DEBUG, _("checking replacement '%s' for package '%s'"), replacement, spkg->name); _alpm_log(PM_LOG_DEBUG, _("checking replacement '%s' for package '%s'"), replacement, spkg->name);
if(alpm_list_find_str(handle->ignorepkg, lpkg->name)) { if(alpm_list_find_str(handle->ignorepkg, lpkg->name)) {
_alpm_log(PM_LOG_WARNING, _("%s-%s: ignoring package upgrade (to be replaced by %s-%s)"), _alpm_log(PM_LOG_WARNING, _("%s-%s: ignoring package upgrade (to be replaced by %s-%s)"),
lpkg->name, lpkg->version, spkg->name, spkg->version); alpm_pkg_get_name(lpkg), alpm_pkg_get_version(lpkg),
alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
} else { } else {
/* get confirmation for the replacement */ /* get confirmation for the replacement */
int doreplace = 0; int doreplace = 0;
@ -155,14 +133,14 @@ static int find_replacements(pmtrans_t *trans, pmdb_t *db_local,
* the package to replace. * the package to replace.
*/ */
pmsyncpkg_t *sync; pmsyncpkg_t *sync;
pmpkg_t *dummy = _alpm_pkg_new(lpkg->name, NULL); pmpkg_t *dummy = _alpm_pkg_new(alpm_pkg_get_name(lpkg), NULL);
if(dummy == NULL) { if(dummy == NULL) {
pm_errno = PM_ERR_MEMORY; pm_errno = PM_ERR_MEMORY;
goto error; goto error;
} }
dummy->requiredby = alpm_list_strdup(lpkg->requiredby); dummy->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(lpkg));
/* check if spkg->name is already in the packages list. */ /* check if spkg->name is already in the packages list. */
sync = find_pkginsync(spkg->name, trans->packages); sync = _alpm_sync_find(trans->packages, alpm_pkg_get_name(spkg));
if(sync) { if(sync) {
/* found it -- just append to the replaces list */ /* found it -- just append to the replaces list */
sync->data = alpm_list_add(sync->data, dummy); sync->data = alpm_list_add(sync->data, dummy);
@ -178,10 +156,8 @@ static int find_replacements(pmtrans_t *trans, pmdb_t *db_local,
trans->packages = alpm_list_add(trans->packages, sync); trans->packages = alpm_list_add(trans->packages, sync);
} }
_alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (to be replaced by %s-%s)"), _alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (to be replaced by %s-%s)"),
lpkg->name, lpkg->version, spkg->name, spkg->version); alpm_pkg_get_name(lpkg), alpm_pkg_get_version(lpkg),
} alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
}
break;
} }
} }
} }
@ -203,17 +179,17 @@ int _alpm_sync_sysupgrade(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_s
if(find_replacements(trans, db_local, dbs_sync) == 0) { if(find_replacements(trans, db_local, dbs_sync) == 0) {
/* match installed packages with the sync dbs and compare versions */ /* match installed packages with the sync dbs and compare versions */
_alpm_log(PM_LOG_DEBUG, _("checking for package upgrades")); _alpm_log(PM_LOG_DEBUG, _("checking for package upgrades"));
for(i = _alpm_db_get_pkgcache(db_local, INFRQ_BASE); i; i = i->next) { for(i = _alpm_db_get_pkgcache(db_local); i; i = i->next) {
int replace=0; int replace=0;
pmpkg_t *local = i->data; pmpkg_t *local = i->data;
pmpkg_t *spkg = NULL; pmpkg_t *spkg = NULL;
pmsyncpkg_t *sync; pmsyncpkg_t *sync;
for(j = dbs_sync; !spkg && j; j = j->next) { for(j = dbs_sync; !spkg && j; j = j->next) {
spkg = _alpm_db_get_pkgfromcache(j->data, local->name); spkg = _alpm_db_get_pkgfromcache(j->data, alpm_pkg_get_name(local));
} }
if(spkg == NULL) { if(spkg == NULL) {
_alpm_log(PM_LOG_DEBUG, _("'%s' not found in sync db -- skipping"), local->name); _alpm_log(PM_LOG_DEBUG, _("'%s' not found in sync db -- skipping"), alpm_pkg_get_name(local));
continue; continue;
} }
@ -221,23 +197,25 @@ int _alpm_sync_sysupgrade(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_s
for(j = trans->packages; j && !replace; j=j->next) { for(j = trans->packages; j && !replace; j=j->next) {
sync = j->data; sync = j->data;
if(sync->type == PM_SYNC_TYPE_REPLACE) { if(sync->type == PM_SYNC_TYPE_REPLACE) {
if(_alpm_pkg_find(spkg->name, sync->data)) { if(_alpm_pkg_find(alpm_pkg_get_name(spkg), sync->data)) {
replace=1; replace=1;
} }
} }
} }
if(replace) { if(replace) {
_alpm_log(PM_LOG_DEBUG, _("'%s' is already elected for removal -- skipping"), _alpm_log(PM_LOG_DEBUG, _("'%s' is already elected for removal -- skipping"),
local->name); alpm_pkg_get_name(local));
continue; continue;
} }
/* compare versions and see if we need to upgrade */ /* compare versions and see if we need to upgrade */
if(alpm_pkg_compare_versions(local, spkg)) { if(alpm_pkg_compare_versions(local, spkg)) {
_alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (%s => %s)"), _alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (%s => %s)"),
local->name, local->version, local->version, spkg->version); alpm_pkg_get_name(local), alpm_pkg_get_version(local),
if(!find_pkginsync(spkg->name, trans->packages)) { alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
pmpkg_t *dummy = _alpm_pkg_new(local->name, local->version); if(!_alpm_sync_find(trans->packages, alpm_pkg_get_name(spkg))) {
pmpkg_t *dummy = _alpm_pkg_new(alpm_pkg_get_name(local),
alpm_pkg_get_version(local));
if(dummy == NULL) { if(dummy == NULL) {
goto error; goto error;
} }
@ -279,22 +257,21 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
if(targ) { if(targ) {
*targ = '\0'; *targ = '\0';
targ++; targ++;
_alpm_log(PM_LOG_DEBUG, _("searching for target in repo '%s'"), targline); _alpm_log(PM_LOG_DEBUG, _("searching for target in repo '%s'"), targ);
for(j = dbs_sync; j && !spkg; j = j->next) { for(j = dbs_sync; j && !spkg; j = j->next) {
pmdb_t *dbs = j->data; pmdb_t *db = j->data;
if(strcmp(dbs->treename, targline) == 0) { if(strcmp(db->treename, targline) == 0) {
repo_found = 1; repo_found = 1;
spkg = _alpm_db_get_pkgfromcache(dbs, targ); spkg = _alpm_db_get_pkgfromcache(db, targ);
if(spkg == NULL) { if(spkg == NULL) {
/* Search provides */ /* Search provides */
alpm_list_t *p;
_alpm_log(PM_LOG_DEBUG, _("target '%s' not found -- looking for provisions"), targ); _alpm_log(PM_LOG_DEBUG, _("target '%s' not found -- looking for provisions"), targ);
p = _alpm_db_whatprovides(dbs, targ); alpm_list_t *p = _alpm_db_whatprovides(db, targ);
if(p == NULL) { if(!p) {
RET_ERR(PM_ERR_PKG_NOT_FOUND, -1); RET_ERR(PM_ERR_PKG_NOT_FOUND, -1);
} }
_alpm_log(PM_LOG_DEBUG, _("found '%s' as a provision for '%s'"), p->data, targ); _alpm_log(PM_LOG_DEBUG, _("found '%s' as a provision for '%s'"), p->data, targ);
spkg = _alpm_db_get_pkgfromcache(dbs, p->data); spkg = _alpm_db_get_pkgfromcache(db, p->data);
FREELISTPTR(p); FREELISTPTR(p);
} }
} }
@ -306,33 +283,34 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
} else { } else {
targ = targline; targ = targline;
for(j = dbs_sync; j && !spkg; j = j->next) { for(j = dbs_sync; j && !spkg; j = j->next) {
pmdb_t *dbs = j->data; pmdb_t *db = j->data;
spkg = _alpm_db_get_pkgfromcache(dbs, targ); spkg = _alpm_db_get_pkgfromcache(db, targ);
} }
if(spkg == NULL) { if(spkg == NULL) {
/* Search provides */ /* Search provides */
_alpm_log(PM_LOG_DEBUG, _("target '%s' not found -- looking for provisions"), targ); _alpm_log(PM_LOG_DEBUG, _("target '%s' not found -- looking for provisions"), targ);
for(j = dbs_sync; j && !spkg; j = j->next) { for(j = dbs_sync; j && !spkg; j = j->next) {
pmdb_t *dbs = j->data; pmdb_t *db = j->data;
alpm_list_t *p = _alpm_db_whatprovides(dbs, targ); alpm_list_t *p = _alpm_db_whatprovides(db, targ);
if(p) { if(p) {
_alpm_log(PM_LOG_DEBUG, _("found '%s' as a provision for '%s'"), p->data, targ); _alpm_log(PM_LOG_DEBUG, _("found '%s' as a provision for '%s'"), p->data, targ);
spkg = _alpm_db_get_pkgfromcache(dbs, p->data); spkg = _alpm_db_get_pkgfromcache(db, p->data);
FREELISTPTR(p); FREELISTPTR(p);
} }
} }
} }
} }
if(spkg == NULL) { if(spkg == NULL) {
RET_ERR(PM_ERR_PKG_NOT_FOUND, -1); RET_ERR(PM_ERR_PKG_NOT_FOUND, -1);
} }
local = _alpm_db_get_pkgfromcache(db_local, spkg->name); local = _alpm_db_get_pkgfromcache(db_local, alpm_pkg_get_name(spkg));
if(local) { if(local) {
if(alpm_pkg_compare_versions(local, spkg) == 0) { if(alpm_pkg_compare_versions(local, spkg) == 0) {
/* spkg is NOT an upgrade, get confirmation before adding */ /* spkg is NOT an upgrade, get confirmation before adding */
int resp = 0; int resp = 0;
if(alpm_list_find_str(handle->ignorepkg, local->name)) { if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(local))) {
QUESTION(trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, local, NULL, NULL, &resp); QUESTION(trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, local, NULL, NULL, &resp);
if(!resp) { if(!resp) {
return(0); return(0);
@ -340,7 +318,8 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
} else { } else {
QUESTION(trans, PM_TRANS_CONV_LOCAL_UPTODATE, local, NULL, NULL, &resp); QUESTION(trans, PM_TRANS_CONV_LOCAL_UPTODATE, local, NULL, NULL, &resp);
if(!resp) { if(!resp) {
_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- skipping"), local->name, local->version); _alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- skipping"),
alpm_pkg_get_name(local), alpm_pkg_get_version(local));
return(0); return(0);
} }
} }
@ -348,10 +327,11 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
} }
/* add the package to the transaction */ /* add the package to the transaction */
if(!find_pkginsync(spkg->name, trans->packages)) { if(!_alpm_sync_find(trans->packages, alpm_pkg_get_name(spkg))) {
pmpkg_t *dummy = NULL; pmpkg_t *dummy = NULL;
if(local) { if(local) {
dummy = _alpm_pkg_new(local->name, local->version); dummy = _alpm_pkg_new(alpm_pkg_get_name(local),
alpm_pkg_get_version(local));
if(dummy == NULL) { if(dummy == NULL) {
RET_ERR(PM_ERR_MEMORY, -1); RET_ERR(PM_ERR_MEMORY, -1);
} }
@ -361,7 +341,8 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
FREEPKG(dummy); FREEPKG(dummy);
RET_ERR(PM_ERR_MEMORY, -1); RET_ERR(PM_ERR_MEMORY, -1);
} }
_alpm_log(PM_LOG_DEBUG, _("adding target '%s' to the transaction set"), spkg->name); _alpm_log(PM_LOG_DEBUG, _("adding target '%s' to the transaction set"),
alpm_pkg_get_name(spkg));
trans->packages = alpm_list_add(trans->packages, sync); trans->packages = alpm_list_add(trans->packages, sync);
} }
@ -372,12 +353,14 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
*/ */
static int syncpkg_cmp(const void *s1, const void *s2) static int syncpkg_cmp(const void *s1, const void *s2)
{ {
return(strcmp(((pmsyncpkg_t *)s1)->pkg->name, ((pmsyncpkg_t *)s2)->pkg->name)); pmsyncpkg_t *sp1 = (pmsyncpkg_t *)s1;
} pmsyncpkg_t *sp2 = (pmsyncpkg_t *)s2;
pmpkg_t *p1, *p2;
static int pkg_cmp(const void *p1, const void *p2) p1 = alpm_sync_get_pkg(sp1);
{ p2 = alpm_sync_get_pkg(sp2);
return(strcmp(((pmpkg_t *)p1)->name, ((pmsyncpkg_t *)p2)->pkg->name));
return(strcmp(alpm_pkg_get_name(p1), alpm_pkg_get_name(p2)));
} }
int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data) int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data)
@ -419,7 +402,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
for(i = list; i; i = i->next) { for(i = list; i; i = i->next) {
/* add the dependencies found by resolvedeps to the transaction set */ /* add the dependencies found by resolvedeps to the transaction set */
pmpkg_t *spkg = i->data; pmpkg_t *spkg = i->data;
if(!find_pkginsync(spkg->name, trans->packages)) { if(!_alpm_sync_find(trans->packages, alpm_pkg_get_name(spkg))) {
pmsyncpkg_t *sync = _alpm_sync_new(PM_SYNC_TYPE_DEPEND, spkg, NULL); pmsyncpkg_t *sync = _alpm_sync_new(PM_SYNC_TYPE_DEPEND, spkg, NULL);
if(sync == NULL) { if(sync == NULL) {
ret = -1; ret = -1;
@ -427,13 +410,13 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
} }
trans->packages = alpm_list_add(trans->packages, sync); trans->packages = alpm_list_add(trans->packages, sync);
_alpm_log(PM_LOG_DEBUG, _("adding package %s-%s to the transaction targets"), _alpm_log(PM_LOG_DEBUG, _("adding package %s-%s to the transaction targets"),
spkg->name, spkg->version); alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
} else { } else {
/* remove the original targets from the list if requested */ /* remove the original targets from the list if requested */
if((trans->flags & PM_TRANS_FLAG_DEPENDSONLY)) { if((trans->flags & PM_TRANS_FLAG_DEPENDSONLY)) {
void *vp; void *vp;
pmpkg_t *p; pmpkg_t *p;
trans->packages = alpm_list_remove(trans->packages, spkg, pkg_cmp, &vp); trans->packages = alpm_list_remove(trans->packages, spkg, _alpm_pkg_cmp, &vp);
p = vp; p = vp;
FREEPKG(p); FREEPKG(p);
} }
@ -492,7 +475,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
pmsyncpkg_t *sync; pmsyncpkg_t *sync;
pmpkg_t *local; pmpkg_t *local;
_alpm_log(PM_LOG_DEBUG, _("package '%s' is conflicting with '%s'"), _alpm_log(PM_LOG_DEBUG, _("package '%s' conflicts with '%s'"),
miss->target, miss->depend.name); miss->target, miss->depend.name);
/* check if the conflicting package is one that's about to be removed/replaced. /* check if the conflicting package is one that's about to be removed/replaced.
@ -512,7 +495,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
continue; continue;
} }
sync = find_pkginsync(miss->target, trans->packages); sync = _alpm_sync_find(trans->packages, miss->target);
if(sync == NULL) { if(sync == NULL) {
_alpm_log(PM_LOG_DEBUG, _("'%s' not found in transaction set -- skipping"), _alpm_log(PM_LOG_DEBUG, _("'%s' not found in transaction set -- skipping"),
miss->target); miss->target);
@ -521,7 +504,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
local = _alpm_db_get_pkgfromcache(db_local, miss->depend.name); local = _alpm_db_get_pkgfromcache(db_local, miss->depend.name);
/* check if this package also "provides" the package it's conflicting with /* check if this package also "provides" the package it's conflicting with
*/ */
if(alpm_list_find_str(sync->pkg->provides, miss->depend.name)) { if(alpm_list_find_str(alpm_pkg_get_provides(sync->pkg), miss->depend.name)) {
/* so just treat it like a "replaces" item so the REQUIREDBY /* so just treat it like a "replaces" item so the REQUIREDBY
* fields are inherited properly. * fields are inherited properly.
*/ */
@ -563,7 +546,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
rmpkg = miss->depend.name; rmpkg = miss->depend.name;
} }
if(rmpkg) { if(rmpkg) {
pmsyncpkg_t *rsync = find_pkginsync(rmpkg, trans->packages); pmsyncpkg_t *rsync = _alpm_sync_find(trans->packages, rmpkg);
void *vpkg; void *vpkg;
_alpm_log(PM_LOG_DEBUG, _("removing '%s' from target list"), rsync->pkg->name); _alpm_log(PM_LOG_DEBUG, _("removing '%s' from target list"), rsync->pkg->name);
trans->packages = alpm_list_remove(trans->packages, rsync, syncpkg_cmp, &vpkg); trans->packages = alpm_list_remove(trans->packages, rsync, syncpkg_cmp, &vpkg);
@ -581,7 +564,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
QUESTION(trans, PM_TRANS_CONV_CONFLICT_PKG, miss->target, miss->depend.name, NULL, &doremove); QUESTION(trans, PM_TRANS_CONV_CONFLICT_PKG, miss->target, miss->depend.name, NULL, &doremove);
asked = alpm_list_add(asked, strdup(miss->depend.name)); asked = alpm_list_add(asked, strdup(miss->depend.name));
if(doremove) { if(doremove) {
pmsyncpkg_t *rsync = find_pkginsync(miss->depend.name, trans->packages); pmsyncpkg_t *rsync = _alpm_sync_find(trans->packages, miss->depend.name);
pmpkg_t *q = _alpm_pkg_new(miss->depend.name, NULL); pmpkg_t *q = _alpm_pkg_new(miss->depend.name, NULL);
if(q == NULL) { if(q == NULL) {
if(data) { if(data) {
@ -590,7 +573,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
ret = -1; ret = -1;
goto cleanup; goto cleanup;
} }
q->requiredby = alpm_list_strdup(local->requiredby); q->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(local));
if(sync->type != PM_SYNC_TYPE_REPLACE) { if(sync->type != PM_SYNC_TYPE_REPLACE) {
/* switch this sync type to REPLACE */ /* switch this sync type to REPLACE */
sync->type = PM_SYNC_TYPE_REPLACE; sync->type = PM_SYNC_TYPE_REPLACE;
@ -682,7 +665,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
int errorout = 0; int errorout = 0;
for(i = deps; i; i = i->next) { for(i = deps; i; i = i->next) {
pmdepmissing_t *miss = i->data; pmdepmissing_t *miss = i->data;
if(!find_pkginsync(miss->depend.name, trans->packages)) { if(!_alpm_sync_find(trans->packages, miss->depend.name)) {
int pfound = 0; int pfound = 0;
alpm_list_t *k; alpm_list_t *k;
/* If miss->depend.name depends on something that miss->target and a /* If miss->depend.name depends on something that miss->target and a
@ -696,9 +679,9 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
} }
/* Look through the upset package's dependencies and try to match one up /* Look through the upset package's dependencies and try to match one up
* to a provisio from the package we want to remove */ * to a provisio from the package we want to remove */
for(k = conflictp->depends; k && !pfound; k = k->next) { for(k = alpm_pkg_get_depends(conflictp); k && !pfound; k = k->next) {
alpm_list_t *m; alpm_list_t *m;
for(m = leavingp->provides; m && !pfound; m = m->next) { for(m = alpm_pkg_get_provides(leavingp); m && !pfound; m = m->next) {
if(!strcmp(k->data, m->data)) { if(!strcmp(k->data, m->data)) {
/* Found a match -- now look through final for a package that /* Found a match -- now look through final for a package that
* provides the same thing. If none are found, then it truly * provides the same thing. If none are found, then it truly
@ -706,11 +689,12 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
alpm_list_t *n, *o; alpm_list_t *n, *o;
for(n = trans->packages; n && !pfound; n = n->next) { for(n = trans->packages; n && !pfound; n = n->next) {
pmsyncpkg_t *sp = n->data; pmsyncpkg_t *sp = n->data;
for(o = sp->pkg->provides; o && !pfound; o = o->next) { pmpkg_t *sppkg = sp->pkg;
for(o = alpm_pkg_get_provides(sppkg); o && !pfound; o = o->next) {
if(!strcmp(m->data, o->data)) { if(!strcmp(m->data, o->data)) {
/* found matching provisio -- we're good to go */ /* found matching provisio -- we're good to go */
_alpm_log(PM_LOG_DEBUG, _("found '%s' as a provision for '%s' -- conflict aborted"), _alpm_log(PM_LOG_DEBUG, _("found '%s' as a provision for '%s' -- conflict aborted"),
sp->pkg->name, (char *)o->data); alpm_pkg_get_name(sppkg), (char *)o->data);
pfound = 1; pfound = 1;
} }
} }
@ -1002,13 +986,13 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
pmsyncpkg_t *sync = i->data; pmsyncpkg_t *sync = i->data;
if(sync->type == PM_SYNC_TYPE_REPLACE) { if(sync->type == PM_SYNC_TYPE_REPLACE) {
alpm_list_t *j; alpm_list_t *j;
pmpkg_t *new = _alpm_db_get_pkgfromcache(db_local, sync->pkg->name); pmpkg_t *new = _alpm_db_get_pkgfromcache(db_local, alpm_pkg_get_name(sync->pkg));
for(j = sync->data; j; j = j->next) { for(j = sync->data; j; j = j->next) {
alpm_list_t *k; alpm_list_t *k;
pmpkg_t *old = j->data; pmpkg_t *old = j->data;
/* merge lists */ /* merge lists */
for(k = old->requiredby; k; k = k->next) { for(k = alpm_pkg_get_requiredby(old); k; k = k->next) {
if(!alpm_list_find_str(new->requiredby, k->data)) { if(!alpm_list_find_str(alpm_pkg_get_requiredby(new), k->data)) {
/* replace old's name with new's name in the requiredby's dependency list */ /* replace old's name with new's name in the requiredby's dependency list */
alpm_list_t *m; alpm_list_t *m;
pmpkg_t *depender = _alpm_db_get_pkgfromcache(db_local, k->data); pmpkg_t *depender = _alpm_db_get_pkgfromcache(db_local, k->data);
@ -1019,24 +1003,24 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
* here. */ * here. */
continue; continue;
} }
for(m = depender->depends; m; m = m->next) { for(m = alpm_pkg_get_depends(depender); m; m = m->next) {
if(!strcmp(m->data, old->name)) { if(!strcmp(m->data, alpm_pkg_get_name(old))) {
FREE(m->data); FREE(m->data);
m->data = strdup(new->name); m->data = strdup(alpm_pkg_get_name(new));
} }
} }
if(_alpm_db_write(db_local, depender, INFRQ_DEPENDS) == -1) { if(_alpm_db_write(db_local, depender, INFRQ_DEPENDS) == -1) {
_alpm_log(PM_LOG_ERROR, _("could not update requiredby for database entry %s-%s"), _alpm_log(PM_LOG_ERROR, _("could not update requiredby for database entry %s-%s"),
new->name, new->version); alpm_pkg_get_name(new), alpm_pkg_get_version(new));
} }
/* add the new requiredby */ /* add the new requiredby */
new->requiredby = alpm_list_add(new->requiredby, strdup(k->data)); new->requiredby = alpm_list_add(alpm_pkg_get_requiredby(new), strdup(k->data));
} }
} }
} }
if(_alpm_db_write(db_local, new, INFRQ_DEPENDS) == -1) { if(_alpm_db_write(db_local, new, INFRQ_DEPENDS) == -1) {
_alpm_log(PM_LOG_ERROR, _("could not update new database entry %s-%s"), _alpm_log(PM_LOG_ERROR, _("could not update new database entry %s-%s"),
new->name, new->version); alpm_pkg_get_name(new), alpm_pkg_get_version(new));
} }
} }
} }
@ -1064,6 +1048,27 @@ error:
return(-1); return(-1);
} }
pmsyncpkg_t *_alpm_sync_find(alpm_list_t *syncpkgs, const char* pkgname)
{
alpm_list_t *i;
for(i = syncpkgs; i; i = i->next) {
pmsyncpkg_t *syncpkg = i->data;
if(!syncpkg) {
continue;
}
pmpkg_t *pkg = alpm_sync_get_pkg(syncpkg);
if(strcmp(alpm_pkg_get_name(pkg), pkgname) == 0) {
_alpm_log(PM_LOG_DEBUG, _("found package '%s-%s' in sync"),
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
return(syncpkg);
}
}
_alpm_log(PM_LOG_DEBUG, _("package '%s not found in sync"), pkgname);
return(NULL); /* not found */
}
pmsynctype_t SYMEXPORT alpm_sync_get_type(pmsyncpkg_t *sync) pmsynctype_t SYMEXPORT alpm_sync_get_type(pmsyncpkg_t *sync)
{ {
/* Sanity checks */ /* Sanity checks */

3
lib/libalpm/sync.h
View File

@ -42,6 +42,9 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data); int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data);
int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data); int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data);
/* typically trans->packages */
pmsyncpkg_t *_alpm_sync_find(alpm_list_t *syncpkgs, const char* pkgname);
#endif /* _ALPM_SYNC_H */ #endif /* _ALPM_SYNC_H */
/* vim: set ts=2 sw=2 noet: */ /* vim: set ts=2 sw=2 noet: */

34
lib/libalpm/trans.c
View File

@ -250,6 +250,7 @@ int _alpm_trans_commit(pmtrans_t *trans, alpm_list_t **data)
int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg) int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
{ {
alpm_list_t *i, *j; alpm_list_t *i, *j;
alpm_list_t *depends = NULL;
pmdb_t *localdb; pmdb_t *localdb;
ALPM_LOG_FUNC; ALPM_LOG_FUNC;
@ -258,7 +259,8 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1)); ASSERT(trans != NULL, RET_ERR(PM_ERR_TRANS_NULL, -1));
ASSERT(pkg != NULL, RET_ERR(PM_ERR_PKG_INVALID, -1)); ASSERT(pkg != NULL, RET_ERR(PM_ERR_PKG_INVALID, -1));
if(pkg->depends) { depends = alpm_pkg_get_depends(pkg);
if(depends) {
_alpm_log(PM_LOG_DEBUG, _("updating dependency packages 'requiredby' fields for %s-%s"), _alpm_log(PM_LOG_DEBUG, _("updating dependency packages 'requiredby' fields for %s-%s"),
pkg->name, pkg->version); pkg->name, pkg->version);
} else { } else {
@ -266,7 +268,7 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
} }
localdb = alpm_option_get_localdb(); localdb = alpm_option_get_localdb();
for(i = pkg->depends; i; i = i->next) { for(i = depends; i; i = i->next) {
pmdepend_t dep; pmdepend_t dep;
if(_alpm_splitdep(i->data, &dep) != 0) { if(_alpm_splitdep(i->data, &dep) != 0) {
continue; continue;
@ -288,7 +290,7 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
continue; continue;
} }
pmpkg_t *provpkg = j->data; pmpkg_t *provpkg = j->data;
deppkg = _alpm_db_get_pkgfromcache(localdb, provpkg->name); deppkg = _alpm_db_get_pkgfromcache(localdb, alpm_pkg_get_name(provpkg));
if(!deppkg) { if(!deppkg) {
continue; continue;
@ -296,20 +298,22 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
found_provides = 1; found_provides = 1;
/* Ensure package has the right newpkg */ /* this is cheating... we call this function to populate the package */
_alpm_db_read(localdb, deppkg, INFRQ_DEPENDS); alpm_pkg_get_requiredby(deppkg);
_alpm_log(PM_LOG_DEBUG, _("updating 'requiredby' field for package '%s'"), deppkg->name); _alpm_log(PM_LOG_DEBUG, _("updating 'requiredby' field for package '%s'"), alpm_pkg_get_name(deppkg));
if(trans->type == PM_TRANS_TYPE_REMOVE) { if(trans->type == PM_TRANS_TYPE_REMOVE) {
void *data = NULL; void *data = NULL;
deppkg->requiredby = alpm_list_remove(deppkg->requiredby, pkg->name, _alpm_str_cmp, &data); deppkg->requiredby = alpm_list_remove(deppkg->requiredby,
alpm_pkg_get_name(pkg), _alpm_str_cmp, &data);
FREE(data); FREE(data);
} else { } else {
deppkg->requiredby = alpm_list_add(deppkg->requiredby, strdup(pkg->name)); deppkg->requiredby = alpm_list_add(deppkg->requiredby, strdup(alpm_pkg_get_name(pkg)));
} }
if(_alpm_db_write(localdb, deppkg, INFRQ_DEPENDS)) { if(_alpm_db_write(localdb, deppkg, INFRQ_DEPENDS)) {
_alpm_log(PM_LOG_ERROR, _("could not update 'requiredby' database entry %s-%s"), deppkg->name, deppkg->version); _alpm_log(PM_LOG_ERROR, _("could not update 'requiredby' database entry %s-%s"),
alpm_pkg_get_name(deppkg), alpm_pkg_get_version(deppkg));
} }
} }
FREELISTPTR(provides); FREELISTPTR(provides);
@ -320,20 +324,22 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
} }
} }
/* Ensure package has the right newpkg */ /* this is cheating... we call this function to populate the package */
_alpm_db_read(localdb, deppkg, INFRQ_DEPENDS); alpm_pkg_get_requiredby(deppkg);
_alpm_log(PM_LOG_DEBUG, _("updating 'requiredby' field for package '%s'"), deppkg->name); _alpm_log(PM_LOG_DEBUG, _("updating 'requiredby' field for package '%s'"), deppkg->name);
if(trans->type == PM_TRANS_TYPE_REMOVE) { if(trans->type == PM_TRANS_TYPE_REMOVE) {
void *data = NULL; void *data = NULL;
deppkg->requiredby = alpm_list_remove(deppkg->requiredby, pkg->name, _alpm_str_cmp, &data); deppkg->requiredby = alpm_list_remove(deppkg->requiredby,
alpm_pkg_get_name(pkg), _alpm_str_cmp, &data);
FREE(data); FREE(data);
} else { } else {
deppkg->requiredby = alpm_list_add(deppkg->requiredby, strdup(pkg->name)); deppkg->requiredby = alpm_list_add(deppkg->requiredby, strdup(alpm_pkg_get_name(pkg)));
} }
if(_alpm_db_write(localdb, deppkg, INFRQ_DEPENDS)) { if(_alpm_db_write(localdb, deppkg, INFRQ_DEPENDS)) {
_alpm_log(PM_LOG_ERROR, _("could not update 'requiredby' database entry %s-%s"), deppkg->name, deppkg->version); _alpm_log(PM_LOG_ERROR, _("could not update 'requiredby' database entry %s-%s"),
alpm_pkg_get_name(deppkg), alpm_pkg_get_version(deppkg));
} }
} }
return(0); return(0);

26
lib/libalpm/util.c
View File

@ -119,7 +119,7 @@ char * mkdtemp(char *template)
#endif #endif
/* does the same thing as 'mkdir -p' */ /* does the same thing as 'mkdir -p' */
int _alpm_makepath(char *path) int _alpm_makepath(const char *path)
{ {
char *orig, *str, *ptr; char *orig, *str, *ptr;
char full[PATH_MAX] = ""; char full[PATH_MAX] = "";
@ -149,7 +149,7 @@ int _alpm_makepath(char *path)
return(0); return(0);
} }
int _alpm_copyfile(char *src, char *dest) int _alpm_copyfile(const char *src, const char *dest)
{ {
FILE *in, *out; FILE *in, *out;
size_t len; size_t len;
@ -184,7 +184,7 @@ char *_alpm_strtoupper(char *str)
(*ptr) = toupper(*ptr); (*ptr) = toupper(*ptr);
ptr++; ptr++;
} }
return str; return(str);
} }
/* Trim whitespace and newlines from a string /* Trim whitespace and newlines from a string
@ -221,7 +221,7 @@ char *_alpm_strtrim(char *str)
/* Create a lock file /* Create a lock file
*/ */
int _alpm_lckmk(char *file) int _alpm_lckmk(const char *file)
{ {
int fd, count = 0; int fd, count = 0;
char *dir, *ptr; char *dir, *ptr;
@ -249,7 +249,7 @@ int _alpm_lckmk(char *file)
/* Remove a lock file /* Remove a lock file
*/ */
int _alpm_lckrm(char *file) int _alpm_lckrm(const char *file)
{ {
if(unlink(file) == -1 && errno != ENOENT) { if(unlink(file) == -1 && errno != ENOENT) {
return(-1); return(-1);
@ -302,7 +302,7 @@ int _alpm_unpack(const char *archive, const char *prefix, const char *fn)
} }
/* does the same thing as 'rm -rf' */ /* does the same thing as 'rm -rf' */
int _alpm_rmrf(char *path) int _alpm_rmrf(const char *path)
{ {
int errflag = 0; int errflag = 0;
struct dirent *dp; struct dirent *dp;
@ -370,15 +370,15 @@ int _alpm_logaction(unsigned short usesyslog, FILE *f, const char *str)
return(0); return(0);
} }
int _alpm_ldconfig(char *root) int _alpm_ldconfig(const char *root)
{ {
char line[PATH_MAX]; char line[PATH_MAX];
struct stat buf; struct stat buf;
snprintf(line, PATH_MAX, "%setc/ld.so.conf", root); snprintf(line, PATH_MAX, "%setc/ld.so.conf", root);
if(!stat(line, &buf)) { if(stat(line, &buf) == 0) {
snprintf(line, PATH_MAX, "%ssbin/ldconfig", root); snprintf(line, PATH_MAX, "%ssbin/ldconfig", root);
if(!stat(line, &buf)) { if(stat(line, &buf) == 0) {
char cmd[PATH_MAX]; char cmd[PATH_MAX];
snprintf(cmd, PATH_MAX, "%s -r %s", line, root); snprintf(cmd, PATH_MAX, "%s -r %s", line, root);
system(cmd); system(cmd);
@ -413,7 +413,9 @@ static int grep(const char *fn, const char *needle)
return(0); return(0);
} }
int _alpm_runscriptlet(char *root, char *installfn, char *script, char *ver, char *oldver, pmtrans_t *trans) int _alpm_runscriptlet(const char *root, const char *installfn,
const char *script, const char *ver,
const char *oldver, pmtrans_t *trans)
{ {
char scriptfn[PATH_MAX]; char scriptfn[PATH_MAX];
char cmdline[PATH_MAX]; char cmdline[PATH_MAX];
@ -589,13 +591,13 @@ int _alpm_check_freespace(pmtrans_t *trans, alpm_list_t **data)
pmsyncpkg_t *sync = i->data; pmsyncpkg_t *sync = i->data;
if(sync->type != PM_SYNC_TYPE_REPLACE) { if(sync->type != PM_SYNC_TYPE_REPLACE) {
pmpkg_t *pkg = sync->pkg; pmpkg_t *pkg = sync->pkg;
pkgsize += pkg->isize; pkgsize += alpm_pkg_get_isize(pkg);
} }
} }
else else
{ {
pmpkg_t *pkg = i->data; pmpkg_t *pkg = i->data;
pkgsize += pkg->size; pkgsize += alpm_pkg_get_size(pkg);
} }
} }
freespace = get_freespace(); freespace = get_freespace();

16
lib/libalpm/util.h
View File

@ -55,18 +55,20 @@
#define SCRIPTLET_START "START " #define SCRIPTLET_START "START "
#define SCRIPTLET_DONE "DONE " #define SCRIPTLET_DONE "DONE "
int _alpm_makepath(char *path); int _alpm_makepath(const char *path);
int _alpm_copyfile(char *src, char *dest); int _alpm_copyfile(const char *src, const char *dest);
char *_alpm_strtoupper(char *str); char *_alpm_strtoupper(char *str);
char *_alpm_strtrim(char *str); char *_alpm_strtrim(char *str);
int _alpm_lckmk(char *file); int _alpm_lckmk(const char *file);
int _alpm_lckrm(char *file); int _alpm_lckrm(const char *file);
int _alpm_unpack(const char *archive, const char *prefix, const char *fn); int _alpm_unpack(const char *archive, const char *prefix, const char *fn);
int _alpm_rmrf(char *path); int _alpm_rmrf(const char *path);
int _alpm_logaction(unsigned short usesyslog, FILE *f, const char *str); int _alpm_logaction(unsigned short usesyslog, FILE *f, const char *str);
int _alpm_ldconfig(char *root); int _alpm_ldconfig(const char *root);
#ifdef _ALPM_TRANS_H #ifdef _ALPM_TRANS_H
int _alpm_runscriptlet(char *util, char *installfn, char *script, char *ver, char *oldver, pmtrans_t *trans); int _alpm_runscriptlet(const char *root, const char *installfn,
const char *script, const char *ver,
const char *oldver, pmtrans_t *trans);
#ifndef __sun__ #ifndef __sun__
int _alpm_check_freespace(pmtrans_t *trans, alpm_list_t **data); int _alpm_check_freespace(pmtrans_t *trans, alpm_list_t **data);
#endif #endif

8
lib/libalpm/versioncmp.c
View File

@ -256,7 +256,7 @@ int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
if(dep->mod == PM_DEP_MOD_ANY) { if(dep->mod == PM_DEP_MOD_ANY) {
equal = 1; equal = 1;
} else { } else {
int cmp = _alpm_versioncmp(pkg->version, dep->version); int cmp = _alpm_versioncmp(alpm_pkg_get_version(pkg), dep->version);
switch(dep->mod) { switch(dep->mod) {
case PM_DEP_MOD_EQ: equal = (cmp == 0); break; case PM_DEP_MOD_EQ: equal = (cmp == 0); break;
case PM_DEP_MOD_GE: equal = (cmp >= 0); break; case PM_DEP_MOD_GE: equal = (cmp >= 0); break;
@ -275,11 +275,13 @@ int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
if(strlen(dep->version) > 0) { if(strlen(dep->version) > 0) {
_alpm_log(PM_LOG_DEBUG, _("depcmp: %s-%s %s %s-%s => %s"), _alpm_log(PM_LOG_DEBUG, _("depcmp: %s-%s %s %s-%s => %s"),
pkg->name, pkg->version, mod, dep->name, dep->version, alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg),
mod, dep->name, dep->version,
(equal ? "match" : "no match")); (equal ? "match" : "no match"));
} else { } else {
_alpm_log(PM_LOG_DEBUG, _("depcmp: %s-%s %s %s => %s"), _alpm_log(PM_LOG_DEBUG, _("depcmp: %s-%s %s %s => %s"),
pkg->name, pkg->version, mod, dep->name, alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg),
mod, dep->name,
(equal ? "match" : "no match")); (equal ? "match" : "no match"));
} }
} }

4
src/pacman/trans.c
View File

@ -277,8 +277,8 @@ void cb_trans_conv(pmtransconv_t event, void *data1, void *data2,
} }
} }
void cb_trans_progress(pmtransprog_t event, char *pkgname, const int percent, void cb_trans_progress(pmtransprog_t event, const char *pkgname, int percent,
const int howmany, const int remain) int howmany, int remain)
{ {
float timediff; float timediff;

4
src/pacman/trans.h
View File

@ -29,8 +29,8 @@ void cb_trans_conv(pmtransconv_t event, void *data1, void *data2,
void *data3, int *response); void *data3, int *response);
/* callback to handle display of the progress bar for transactions */ /* callback to handle display of the progress bar for transactions */
void cb_trans_progress(pmtransprog_t event, char *pkgname, const int percent, void cb_trans_progress(pmtransprog_t event, const char *pkgname, int percent,
const int howmany, const int remain); int howmany, int remain);
#endif /* _PM_TRANS_H */ #endif /* _PM_TRANS_H */