moparisthebest/pacman
1
0
Fork 0
mirror of https://github.com/moparisthebest/pacman synced 2024-12-22 15:58: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"));
for (lp=trans->packages; lp!=NULL; lp=lp->next) {
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);
remove(rm_fname);
}
@ -354,7 +354,7 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
newpkg->reason = alpm_pkg_get_reason(local);
/* 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);
}
} 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);
/* 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);
}
}
@ -400,9 +400,10 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
* old, we cover all bases, including backup=() locations changing hands.
* But is this viable? */
alpm_list_t *old_noupgrade = alpm_list_strdup(handle->noupgrade);
for(b = newpkg->backup; b; b = b->next) {
_alpm_log(PM_LOG_DEBUG, _("adding %s to the NoUpgrade array temporarilly"), (char *)b->data);
handle->noupgrade = alpm_list_add(handle->noupgrade, strdup(b->data));
for(b = alpm_pkg_get_backup(newpkg); b; b = b->next) {
const char *backup = 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);
@ -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(alpm_list_find_str(handle->noextract, 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);
continue;
}
@ -508,10 +509,10 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
/* it does, is it 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 */
needbackup = alpm_list_find_str(newpkg->backup, entryname);
needbackup = alpm_list_find_str(alpm_pkg_get_backup(newpkg), entryname);
if(is_upgrade) {
hash_orig = _alpm_needbackup(entryname, oldpkg->backup);
hash_orig = _alpm_needbackup(entryname, alpm_pkg_get_backup(oldpkg));
if(hash_orig) {
needbackup = 1;
}
@ -561,9 +562,9 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
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) */
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) {
continue;
}
@ -699,8 +700,8 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
errors++;
}
/* calculate an hash if this is in newpkg->backup */
for(lp = newpkg->backup; lp; lp = lp->next) {
/* calculate an hash if this is in newpkg's backup */
for(lp = alpm_pkg_get_backup(newpkg); lp; lp = lp->next) {
char *backup = NULL, *hash = NULL;
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) {
const char *provname = prov->data;
_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);
if(p) {
@ -769,15 +771,18 @@ int _alpm_add_commit(pmtrans_t *trans, pmdb_t *db)
* provision, we'll use the FIRST for now.
* TODO figure out a way to find a "correct" provision */
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);
if(_alpm_db_write(db, provpkg, INFRQ_DEPENDS)) {
_alpm_log(PM_LOG_ERROR, _("could not update provision '%s' from '%s'"), provname, provpkg->name);
alpm_logaction(_("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, pkgname);
RET_ERR(PM_ERR_DB_WRITE, -1);
}
}
}
alpm_list_free(provdiff);
/* make an install date (in UTC) */
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)) {
_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"),
newpkg->name, newpkg->version);
alpm_pkg_get_name(newpkg), alpm_pkg_get_version(newpkg));
RET_ERR(PM_ERR_DB_WRITE, -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 */
_alpm_trans_update_depends(trans, newpkg);
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);
/* 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];
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) {
_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 {
_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);
/* remove the old dir */
_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) {
if(_alpm_db_remove(db, lp->data) == -1) {
if(lp->data) {
_alpm_log(PM_LOG_ERROR, _("could not remove database entry %s/%s"), db->treename,
((pmpkg_t *)lp->data)->name);
}
_alpm_log(PM_LOG_DEBUG, _("flushing database %s%s"), handle->dbpath, db->treename);
for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
pmpkg_t *pkg = 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_pkg_get_name(pkg));
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(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
@ -472,21 +471,21 @@ int alpm_pkg_checksha1sum(pmpkg_t *pkg)
snprintf(path, PATH_MAX, "%s%s/%s-%s" PM_EXT_PKG,
handle->root, handle->cachedir,
pkg->name, pkg->version);
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
sha1sum = _alpm_SHAFile(path);
if(sha1sum == NULL) {
_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;
retval = -1;
} else {
if(strcmp(sha1sum, alpm_pkg_get_sha1sum(pkg)) == 0) {
_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 {
_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;
retval = -1;
}
@ -516,21 +515,21 @@ int alpm_pkg_checkmd5sum(pmpkg_t *pkg)
snprintf(path, PATH_MAX, "%s%s/%s-%s" PM_EXT_PKG,
handle->root, handle->cachedir,
pkg->name, pkg->version);
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
md5sum = _alpm_MDFile(path);
if(md5sum == NULL) {
_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;
retval = -1;
} else {
if(strcmp(md5sum, alpm_pkg_get_md5sum(pkg)) == 0) {
_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 {
_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;
retval = -1;
}
@ -1071,9 +1070,8 @@ int SYMEXPORT alpm_parse_config(char *file, alpm_cb_db_register callback, const
* solution made for -Qu operation */
alpm_list_t *alpm_get_upgrades()
{
int found = 0;
alpm_list_t *syncpkgs = NULL;
alpm_list_t *i, *j, *k;
alpm_list_t *i, *j, *k, *m;
ALPM_LOG_FUNC;
@ -1081,36 +1079,35 @@ alpm_list_t *alpm_get_upgrades()
/* check for "recommended" package replacements */
_alpm_log(PM_LOG_DEBUG, _("checking for package replacements"));
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;
for(k = spkg->replaces; k; k = k->next) {
alpm_list_t *m;
for(m = _alpm_db_get_pkgcache(handle->db_local, INFRQ_BASE); m; m = m->next) {
for(k = alpm_pkg_get_replaces(spkg); k; k = k->next) {
for(m = _alpm_db_get_pkgcache(handle->db_local); m; m = m->next) {
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(alpm_list_find_str(handle->ignorepkg, lpkg->name)) {
if(strcmp(k->data, alpm_pkg_get_name(lpkg)) == 0) {
_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)"),
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 {
/* assume all replaces=() packages are accepted */
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) {
pm_errno = PM_ERR_MEMORY;
goto error;
}
dummy->requiredby = alpm_list_strdup(lpkg->requiredby);
/* 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;
}
}
dummy->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(lpkg));
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 */
sync->data = alpm_list_add(sync->data, dummy);
} else {
@ -1125,7 +1122,8 @@ alpm_list_t *alpm_get_upgrades()
syncpkgs = alpm_list_add(syncpkgs, sync);
}
_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;
}
@ -1135,17 +1133,17 @@ alpm_list_t *alpm_get_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;
pmpkg_t *local = i->data;
pmpkg_t *spkg = NULL;
pmsyncpkg_t *sync;
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) {
_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;
}
@ -1153,32 +1151,28 @@ alpm_list_t *alpm_get_upgrades()
for(j = syncpkgs; j && !replace; j=j->next) {
sync = j->data;
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;
}
}
}
if(replace) {
_alpm_log(PM_LOG_DEBUG, _("'%s' is already elected for removal -- skipping"),
local->name);
alpm_pkg_get_name(local));
continue;
}
if(alpm_pkg_compare_versions(local, spkg)) {
_alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (%s => %s)"),
local->name, local->version, local->version, spkg->version);
alpm_list_t *s;
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;
}
}
_alpm_log(PM_LOG_DEBUG, _("%s elected for upgrade (%s => %s)"),
alpm_pkg_get_name(local), alpm_pkg_get_version(local),
alpm_pkg_get_version(spkg));
if(!found) {
pmpkg_t *dummy = _alpm_pkg_new(local->name, local->version);
pmsyncpkg_t *syncpkg;
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) {
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 *);
/* 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();
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
* @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? */
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_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_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_dupes(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);
}
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 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);
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 */
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);
} else if(!strcmp(line, "%LICENSE%")) {
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%")) {
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"
"%s\n\n", info->url);
}
if(info->license) {
if(info->licenses) {
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, "\n");
@ -687,7 +692,7 @@ int _alpm_db_remove(pmdb_t *db, pmpkg_t *info)
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) {
return(-1);
}

82
lib/libalpm/cache.c
View File

@ -41,12 +41,10 @@
/* Returns a new package cache from db.
* 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;
int count = 0;
/* The group cache needs INFRQ_DESC as well */
/* pmdbinfrq_t infolevel = INFRQ_DEPENDS | INFRQ_DESC;*/
ALPM_LOG_FUNC;
@ -56,12 +54,13 @@ int _alpm_db_load_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel)
_alpm_db_free_pkgcache(db);
_alpm_log(PM_LOG_DEBUG, _("loading package cache (infolevel=%#x) for repository '%s'"),
infolevel, db->treename);
_alpm_log(PM_LOG_DEBUG, _("loading package cache for repository '%s'"),
db->treename);
_alpm_db_rewind(db);
while((info = _alpm_db_scan(db, NULL, infolevel)) != NULL) {
_alpm_log(PM_LOG_FUNCTION, _("adding '%s' to package cache for db '%s'"), info->name, db->treename);
while((info = _alpm_db_scan(db, NULL)) != NULL) {
_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->data = db;
/* 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;
@ -99,46 +98,18 @@ alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db, pmdbinfrq_t infolevel)
return(NULL);
}
if(db->pkgcache == NULL) {
_alpm_db_load_pkgcache(db, infolevel);
if(!db->pkgcache) {
_alpm_db_load_pkgcache(db);
}
_alpm_db_ensure_pkgcache(db, infolevel);
/* hmmm, still NULL ?*/
if(!db->pkgcache) {
_alpm_log(PM_LOG_DEBUG, _("error: pkgcache is NULL for db '%s'"), db->treename);
}
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)
{
pmpkg_t *newpkg;
@ -153,7 +124,8 @@ int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
if(newpkg == NULL) {
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);
_alpm_db_free_grpcache(db);
@ -172,14 +144,18 @@ int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
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);
data = vdata;
if(data == NULL) {
/* 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);
}
_alpm_log(PM_LOG_DEBUG, _("removing entry '%s' from '%s' cache"), pkg->name, db->treename);
FREEPKG(data);
_alpm_db_free_grpcache(db);
@ -195,7 +171,7 @@ pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
return(NULL);
}
alpm_list_t *pkgcache = _alpm_db_get_pkgcache(db, INFRQ_BASE);
alpm_list_t *pkgcache = _alpm_db_get_pkgcache(db);
if(!pkgcache) {
_alpm_log(PM_LOG_DEBUG, _("error: failed to get '%s' from NULL pkgcache"), target);
return(NULL);
@ -217,21 +193,26 @@ int _alpm_db_load_grpcache(pmdb_t *db)
}
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);
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;
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)) {
pmgrp_t *grp = _alpm_grp_new();
STRNCPY(grp->name, (char *)i->data, GRP_NAME_LEN);
grp->packages = alpm_list_add_sorted(grp->packages, pkg->name, _alpm_grp_cmp);
strncpy(grp->name, i->data, GRP_NAME_LEN);
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);
} else {
alpm_list_t *j;
@ -240,8 +221,9 @@ int _alpm_db_load_grpcache(pmdb_t *db)
pmgrp_t *grp = j->data;
if(strcmp(grp->name, i->data) == 0) {
if(!alpm_list_find_str(grp->packages, pkg->name)) {
grp->packages = alpm_list_add_sorted(grp->packages, (char *)pkg->name, _alpm_grp_cmp);
const char *pkgname = alpm_pkg_get_name(pkg);
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"
/* 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);
int _alpm_db_add_pkgincache(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);
pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target);
/* groups */

345
lib/libalpm/conflict.c
View File

@ -46,16 +46,191 @@
#include "deps.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.
*
* conflicts are always name only
*/
alpm_list_t *_alpm_checkconflicts(pmdb_t *db, alpm_list_t *packages)
{
pmpkg_t *info = NULL;
alpm_list_t *i, *j, *k;
alpm_list_t *baddeps = NULL;
pmdepmissing_t *miss = NULL;
alpm_list_t *i, *baddeps = NULL;
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) {
pmpkg_t *tp = i->data;
if(tp == NULL) {
pmpkg_t *pkg = i->data;
if(pkg == NULL) {
continue;
}
for(j = tp->conflicts; j; j = j->next) {
if(!strcmp(tp->name, j->data)) {
/* a package cannot conflict with itself -- that's just not nice */
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;
baddeps = chk_pkg_vs_db(baddeps, pkg, db);
baddeps = chk_pkg_vs_targets(baddeps, pkg, db, packages);
baddeps = chk_db_vs_targets(baddeps, pkg, db, packages);
}
info = k->data;
if(!strcmp(info->name, tp->name)) {
/* a package cannot conflict with itself -- that's just not nice */
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);
}
}
}
}
}
}
}
for(i = baddeps; i; i = i->next) {
pmdepmissing_t *miss = i->data;
_alpm_log(PM_LOG_DEBUG, _("\tCONFLICTS:: %s conflicts with %s"), miss->target, miss->depend.name);
}
return(baddeps);
}
/* Returns a alpm_list_t* of file conflicts.
* Hooray for set-intersects!
* 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.
*/
static alpm_list_t *add_fileconflict(alpm_list_t *conflicts,
pmconflicttype_t type, char *filestr, char* name1,
char* name2)
pmconflicttype_t type, const char *filestr,
const char* name1, const char* name2)
{
pmconflict_t *conflict = malloc(sizeof(pmconflict_t));
if(conflict == NULL) {
@ -349,15 +399,16 @@ alpm_list_t *_alpm_db_find_conflicts(pmdb_t *db, pmtrans_t *trans, char *root)
if(!p2) {
continue;
}
_alpm_log(PM_LOG_DEBUG, "searching for file conflicts: %s and %s", p1->name, p2->name);
tmpfiles = chk_fileconflicts(p1->files, p2->files);
_alpm_log(PM_LOG_DEBUG, "searching for file conflicts: %s and %s",
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) {
char path[PATH_MAX];
for(k = tmpfiles; k; k = k->next) {
snprintf(path, PATH_MAX, "%s%s", root, (char *)k->data);
conflicts = add_fileconflict(conflicts, PM_CONFLICT_TYPE_TARGET,
path, p1->name, p2->name);
conflicts = add_fileconflict(conflicts, PM_CONFLICT_TYPE_TARGET, path,
alpm_pkg_get_name(p1), alpm_pkg_get_name(p2));
}
alpm_list_free_inner(tmpfiles, &free);
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 */
if(dbpkg) {
/* 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 {
/* 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 */

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);
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);
@ -115,23 +115,23 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, alpm_list_t *needles)
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;
char *matched = NULL;
const char *matched = NULL;
/* check name */
if (regexec(&reg, pkg->name, 0, 0, 0) == 0) {
matched = pkg->name;
if (regexec(&reg, alpm_pkg_get_name(pkg), 0, 0, 0) == 0) {
matched = alpm_pkg_get_name(pkg);
}
/* check desc */
else if (regexec(&reg, pkg->desc, 0, 0, 0) == 0) {
matched = pkg->desc;
else if (regexec(&reg, alpm_pkg_get_desc(pkg), 0, 0, 0) == 0) {
matched = alpm_pkg_get_desc(pkg);
}
/* check provides */
/* TODO: should we be doing this, and should we print something
* differently when we do match it since it isn't currently printed? */
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) {
matched = k->data;
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);
void _alpm_db_close(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_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq);
int _alpm_db_remove(pmdb_t *db, pmpkg_t *info);

124
lib/libalpm/deps.c
View File

@ -136,8 +136,8 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, pmtranstype_t mode)
numscans++;
/* run thru targets, moving up packages as necessary */
for(i = newtargs; i; i = i->next) {
pmpkg_t *p = (pmpkg_t*)i->data;
_alpm_log(PM_LOG_DEBUG, "sorting %s", p->name);
pmpkg_t *p = i->data;
_alpm_log(PM_LOG_DEBUG, " sorting %s", alpm_pkg_get_name(p));
for(j = alpm_pkg_get_depends(p); j; j = j->next) {
pmdepend_t dep;
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
*/
for(k = i->next; k; k = k->next) {
q = (pmpkg_t *)k->data;
if(!strcmp(dep.name, q->name)) {
if(!_alpm_pkg_find(q->name, tmptargs)) {
q = k->data;
const char *qname = alpm_pkg_get_name(q);
if(!strcmp(dep.name, qname)) {
if(!_alpm_pkg_find(qname, tmptargs)) {
change = 1;
tmptargs = alpm_list_add(tmptargs, q);
}
break;
}
for(l = q->provides; l; l = l->next) {
if(!strcmp(dep.name, (char*)l->data)) {
if(!_alpm_pkg_find((char*)l->data, tmptargs)) {
for(l = alpm_pkg_get_provides(q); l; l = l->next) {
const char *provname = l->data;
if(!strcmp(dep.name, provname)) {
if(!_alpm_pkg_find(provname, tmptargs)) {
change = 1;
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);
}
}
@ -221,8 +223,9 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
continue;
}
if((oldpkg = _alpm_db_get_pkgfromcache(db, newpkg->name)) == NULL) {
_alpm_log(PM_LOG_DEBUG, _("cannot find package installed '%s'"), newpkg->name);
if((oldpkg = _alpm_db_get_pkgfromcache(db, alpm_pkg_get_name(newpkg))) == NULL) {
_alpm_log(PM_LOG_DEBUG, _("cannot find package installed '%s'"),
alpm_pkg_get_name(newpkg));
continue;
}
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.. */
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 */
continue;
}
@ -250,7 +253,7 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
if(_alpm_depcmp(pkg, &depend)) {
_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;
break;
}
@ -259,17 +262,17 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
if(!satisfied) {
/* worst case... check installed packages to see if anything else
* 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;
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 */
continue;
}
if(_alpm_depcmp(pkg, &depend)) {
_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;
break;
}
@ -278,7 +281,7 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
if(!satisfied) {
_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,
depend.name, depend.version);
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;
}
/* ensure package has depends data */
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) {
for(j = alpm_pkg_get_depends(tp); j; j = j->next) {
/* split into name/version pairs */
_alpm_splitdep((char *)j->data, &depend);
found = 0;
/* check database for literal packages */
for(k = _alpm_db_get_pkgcache(db, INFRQ_DESC|INFRQ_DEPENDS);
k && !found; k = k->next) {
for(k = _alpm_db_get_pkgcache(db); k && !found; k = k->next) {
pmpkg_t *p = (pmpkg_t *)k->data;
found = _alpm_depcmp(p, &depend);
}
/* check database for provides matches */
if(!found) {
alpm_list_t *m;
k = _alpm_db_whatprovides(db, depend.name);
for(m = k; m && !found; m = m->next) {
for(m = _alpm_db_whatprovides(db, depend.name); m && !found; m = m->next) {
/* 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
* 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;
for(n = packages; n && !skip; n = n->next) {
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;
}
}
@ -346,14 +340,14 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
}
/* check other targets */
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);
}
/* else if still not found... */
if(!found) {
_alpm_log(PM_LOG_DEBUG, _("missing dependency '%s' for package '%s'"),
depend.name, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_DEPEND, depend.mod,
depend.name, alpm_pkg_get_name(tp));
miss = _alpm_depmiss_new(alpm_pkg_get_name(tp), PM_DEP_TYPE_DEPEND, depend.mod,
depend.name, depend.version);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
@ -372,20 +366,20 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
}
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 */
char *reqname = j->data;
alpm_list_t *x = NULL;
for(x = packages; x; x = x->next) {
pmpkg_t *xp = x->data;
if(strcmp(reqname, xp->name) == 0) {
if(strcmp(reqname, alpm_pkg_get_name(xp)) == 0) {
found = 1;
break;
}
}
if(!found) {
/* check if a package in trans->packages provides this package */
for(k=trans->packages; !found && k; k=k->next) {
for(k = trans->packages; !found && k; k=k->next) {
pmpkg_t *spkg = NULL;
if(trans->type == PM_TRANS_TYPE_SYNC) {
pmsyncpkg_t *sync = k->data;
@ -394,16 +388,16 @@ alpm_list_t *_alpm_checkdeps(pmtrans_t *trans, pmdb_t *db, pmtranstype_t op,
spkg = k->data;
}
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;
}
}
}
if(!found) {
_alpm_log(PM_LOG_DEBUG, _("checkdeps: found %s as required by %s"),
reqname, tp->name);
miss = _alpm_depmiss_new(tp->name, PM_DEP_TYPE_REQUIRED,
PM_DEP_MOD_ANY, j->data, NULL);
reqname, alpm_pkg_get_name(tp));
miss = _alpm_depmiss_new(alpm_pkg_get_name(tp), PM_DEP_TYPE_REQUIRED,
PM_DEP_MOD_ANY, j->data, NULL);
if(!_alpm_depmiss_isin(miss, baddeps)) {
baddeps = alpm_list_add(baddeps, miss);
} else {
@ -468,20 +462,20 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets)
{
alpm_list_t *i;
if(_alpm_pkg_find(pkg->name, targets)) {
if(_alpm_pkg_find(alpm_pkg_get_name(pkg), targets)) {
return(0);
}
/* see if it was explicitly installed */
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);
}
/* see if other packages need it */
for(i = alpm_pkg_get_requiredby(pkg); i; i = i->next) {
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);
}
}
@ -527,10 +521,9 @@ alpm_list_t *_alpm_removedeps(pmdb_t *db, alpm_list_t *targs)
for(k = provides; k; k = k->next) {
pmpkg_t *provpkg = k->data;
if(can_remove_package(db, provpkg, newtargs)) {
pmpkg_t *pkg = _alpm_pkg_new(provpkg->name, provpkg->version);
_alpm_db_read(db, pkg, INFRQ_ALL);
pmpkg_t *pkg = _alpm_pkg_new(alpm_pkg_get_name(provpkg), alpm_pkg_get_version(provpkg));
_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 */
newtargs = alpm_list_add(newtargs, pkg);
@ -540,9 +533,8 @@ alpm_list_t *_alpm_removedeps(pmdb_t *db, alpm_list_t *targs)
FREELISTPTR(provides);
} else if(can_remove_package(db, dep, newtargs)) {
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 */
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 */
for(j = list; j && !found; j = j->next) {
pmpkg_t *sp = (pmpkg_t *)j->data;
if(alpm_list_find_str(sp->provides, miss->depend.name)) {
pmpkg_t *sp = j->data;
if(alpm_list_find_str(alpm_pkg_get_provides(sp), miss->depend.name)) {
_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;
}
}
@ -604,18 +596,22 @@ int _alpm_resolvedeps(pmdb_t *local, alpm_list_t *dbs_sync, pmpkg_t *syncpkg,
/* check literals */
for(j = dbs_sync; !sync && j; j = j->next) {
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 */
for(j = dbs_sync; !sync && j; j = j->next) {
alpm_list_t *provides;
provides = _alpm_db_whatprovides(j->data, miss->depend.name);
if(provides) {
sync = provides->data;
if(!sync) {
for(j = dbs_sync; !sync && j; j = j->next) {
alpm_list_t *provides;
provides = _alpm_db_whatprovides(j->data, miss->depend.name);
if(provides) {
sync = provides->data;
}
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)"),
miss->target, miss->depend.name);
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;
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 */
_alpm_log(PM_LOG_DEBUG, _("dependency %s is already in the target list -- skipping"),
sync->name);
alpm_pkg_get_name(sync));
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
* something we're not supposed to.
*/
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);
QUESTION(trans, PM_TRANS_CONV_INSTALL_IGNOREPKG, dummypkg, sync, NULL, &usedep);
FREEPKG(dummypkg);
@ -654,7 +650,7 @@ int _alpm_resolvedeps(pmdb_t *local, alpm_list_t *dbs_sync, pmpkg_t *syncpkg,
goto error;
}
_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);
} else {
_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));
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->requiredby = alpm_list_strdup(pkg->requiredby);
newpkg->conflicts = alpm_list_strdup(pkg->conflicts);
newpkg->files = alpm_list_strdup(pkg->files);
newpkg->backup = alpm_list_strdup(pkg->backup);
newpkg->depends = alpm_list_strdup(pkg->depends);
newpkg->removes = alpm_list_strdup(pkg->removes);
newpkg->groups = alpm_list_strdup(pkg->groups);
newpkg->provides = alpm_list_strdup(pkg->provides);
newpkg->replaces = alpm_list_strdup(pkg->replaces);
newpkg->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(pkg));
newpkg->conflicts = alpm_list_strdup(alpm_pkg_get_conflicts(pkg));
newpkg->files = alpm_list_strdup(alpm_pkg_get_files(pkg));
newpkg->backup = alpm_list_strdup(alpm_pkg_get_backup(pkg));
newpkg->depends = alpm_list_strdup(alpm_pkg_get_depends(pkg));
newpkg->removes = alpm_list_strdup(alpm_pkg_get_removes(pkg));
newpkg->groups = alpm_list_strdup(alpm_pkg_get_groups(pkg));
newpkg->provides = alpm_list_strdup(alpm_pkg_get_provides(pkg));
newpkg->replaces = alpm_list_strdup(alpm_pkg_get_replaces(pkg));
/* internal */
newpkg->data = (newpkg->origin == PKG_FROM_FILE) ? strdup(pkg->data) : pkg->data;
@ -109,7 +109,7 @@ void _alpm_pkg_free(void *data)
return;
}
FREELIST(pkg->license);
FREELIST(pkg->licenses);
/*FREELIST(pkg->desc_localized);*/
FREELIST(pkg->files);
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 */
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) {
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) {
/* local version is newer */
pmdb_t *db = pkg->data;
_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;
} else if(cmp > 0) {
/* 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) */
_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;
} else if(_alpm_pkg_istoonew(pkg)) {
/* package too new (UpgradeDelay) */
_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;
}
}
@ -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)
{
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
@ -240,7 +247,7 @@ static int parse_descfile(const char *descfile, pmpkg_t *info)
} else if(!strcmp(key, "URL")) {
STRNCPY(info->url, ptr, sizeof(info->url));
} 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")) {
STRNCPY(info->builddate, ptr, sizeof(info->builddate));
} 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) {
pmpkg_t *info = lp->data;
if(info && strcmp(info->name, needle) == 0) {
if(info && strcmp(alpm_pkg_get_name(info), needle) == 0) {
return(info);
}
}
@ -533,12 +540,12 @@ void _alpm_pkg_update_requiredby(pmpkg_t *pkg)
alpm_list_t *i, *j, *k;
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) {
continue;
}
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;
if(!j->data) {
continue;
@ -548,19 +555,23 @@ void _alpm_pkg_update_requiredby(pmpkg_t *pkg)
}
/* 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'"),
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 */
for(k = pkg->provides; k; k = k->next) {
for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
const char *provname = k->data;
if(strcmp(dep.name, provname) == 0) {
_alpm_log(PM_LOG_DEBUG, _("adding '%s' in requiredby field for '%s' (provides: %s)"),
cachepkg->name, pkg->name, provname);
pkg->requiredby = alpm_list_add(pkg->requiredby, strdup(cachepkg->name));
alpm_pkg_get_name(cachepkg), alpm_pkg_get_name(pkg), provname);
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)) {
_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)

2
lib/libalpm/package.h
View File

@ -71,7 +71,7 @@ struct __pmpkg_t {
time_t date;
pmpkgreason_t reason;
/* alpm_list_t *desc_localized;*/
alpm_list_t *license;
alpm_list_t *licenses;
alpm_list_t *replaces;
alpm_list_t *groups;
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);
}
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;
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);
}
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 */
_alpm_log(PM_LOG_DEBUG, _("could not find %s in database"), name);
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;
for(i = lp; i; i = i->next) {
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) {
_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);
} else {
_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;
}
char *hash = _alpm_needbackup(lp->data, info->backup);
char *hash = _alpm_needbackup(lp->data, alpm_pkg_get_backup(info));
if(hash) {
needbackup = 1;
FREE(hash);
@ -275,6 +275,7 @@ int _alpm_remove_commit(pmtrans_t *trans, pmdb_t *db)
for(targ = trans->packages; targ; targ = targ->next) {
int position = 0;
char pm_install[PATH_MAX];
alpm_list_t *files;
info = (pmpkg_t*)targ->data;
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) {
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 */
if(info->scriptlet && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path, info->name, info->version);
_alpm_runscriptlet(handle->root, pm_install, "pre_remove", info->version, NULL, trans);
if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path,
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)) {
for(lp = info->files; lp; lp = lp->next) {
for(lp = files; lp; lp = lp->next) {
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);
}
}
int filenum = alpm_list_count(info->files);
_alpm_log(PM_LOG_DEBUG, _("removing files"));
int filenum = alpm_list_count(files);
_alpm_log(PM_LOG_DEBUG, _("removing %d files"), filenum);
/* 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);
}
}
if(trans->type != PM_TRANS_TYPE_UPGRADE) {
/* run the post-remove script if it exists */
if(info->scriptlet && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path, info->name, info->version);
_alpm_runscriptlet(handle->root, pm_install, "post_remove", info->version, NULL, trans);
if(alpm_pkg_has_scriptlet(info) && !(trans->flags & PM_TRANS_FLAG_NOSCRIPTLET)) {
snprintf(pm_install, PATH_MAX, "%s/%s-%s/install", db->path,
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 */
_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) {
_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) {
_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 */
_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) {
EVENT(trans, PM_TRANS_EVT_REMOVE_DONE, info, NULL);
}

255
lib/libalpm/sync.c
View File

@ -91,37 +91,13 @@ void _alpm_sync_free(void *data)
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.
* (refactored from _alpm_sync_prepare)
*/
static int find_replacements(pmtrans_t *trans, pmdb_t *db_local,
alpm_list_t *dbs_sync)
{
alpm_list_t *i, *j, *k, *m; /* wow */
alpm_list_t *i, *j, *k; /* wow */
ALPM_LOG_FUNC;
@ -131,57 +107,57 @@ static int find_replacements(pmtrans_t *trans, pmdb_t *db_local,
pmdb_t *db = i->data;
/* 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;
for(k = alpm_pkg_get_replaces(spkg); k; k = k->next) {
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) {
_alpm_log(PM_LOG_DEBUG, _("checking replacement '%s' for package '%s'"), replacement, spkg->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)"),
lpkg->name, lpkg->version, spkg->name, spkg->version);
} else {
/* get confirmation for the replacement */
int doreplace = 0;
QUESTION(trans, PM_TRANS_CONV_REPLACE_PKG, lpkg, spkg, db->treename, &doreplace);
pmpkg_t *lpkg = _alpm_db_get_pkgfromcache(db_local, replacement);
if(!lpkg) {
continue;
}
if(doreplace) {
/* if confirmed, add this to the 'final' list, designating 'lpkg' as
* the package to replace.
*/
pmsyncpkg_t *sync;
pmpkg_t *dummy = _alpm_pkg_new(lpkg->name, NULL);
if(dummy == NULL) {
pm_errno = PM_ERR_MEMORY;
goto error;
}
dummy->requiredby = alpm_list_strdup(lpkg->requiredby);
/* check if spkg->name is already in the packages list. */
sync = find_pkginsync(spkg->name, trans->packages);
if(sync) {
/* found it -- just append to the replaces list */
sync->data = alpm_list_add(sync->data, dummy);
} else {
/* none found -- enter pkg into the final sync list */
sync = _alpm_sync_new(PM_SYNC_TYPE_REPLACE, spkg, NULL);
if(sync == NULL) {
FREEPKG(dummy);
pm_errno = PM_ERR_MEMORY;
goto error;
}
sync->data = alpm_list_add(NULL, dummy);
trans->packages = alpm_list_add(trans->packages, sync);
}
_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_log(PM_LOG_DEBUG, _("checking replacement '%s' for package '%s'"), replacement, spkg->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_pkg_get_name(lpkg), alpm_pkg_get_version(lpkg),
alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
} else {
/* get confirmation for the replacement */
int doreplace = 0;
QUESTION(trans, PM_TRANS_CONV_REPLACE_PKG, lpkg, spkg, db->treename, &doreplace);
if(doreplace) {
/* if confirmed, add this to the 'final' list, designating 'lpkg' as
* the package to replace.
*/
pmsyncpkg_t *sync;
pmpkg_t *dummy = _alpm_pkg_new(alpm_pkg_get_name(lpkg), NULL);
if(dummy == NULL) {
pm_errno = PM_ERR_MEMORY;
goto error;
}
break;
dummy->requiredby = alpm_list_strdup(alpm_pkg_get_requiredby(lpkg));
/* check if spkg->name is already in the packages list. */
sync = _alpm_sync_find(trans->packages, alpm_pkg_get_name(spkg));
if(sync) {
/* found it -- just append to the replaces list */
sync->data = alpm_list_add(sync->data, dummy);
} else {
/* none found -- enter pkg into the final sync list */
sync = _alpm_sync_new(PM_SYNC_TYPE_REPLACE, spkg, NULL);
if(sync == NULL) {
FREEPKG(dummy);
pm_errno = PM_ERR_MEMORY;
goto error;
}
sync->data = alpm_list_add(NULL, dummy);
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_pkg_get_name(lpkg), alpm_pkg_get_version(lpkg),
alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
}
}
}
@ -200,20 +176,20 @@ int _alpm_sync_sysupgrade(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_s
ALPM_LOG_FUNC;
/* check for "recommended" package replacements */
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 */
_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;
pmpkg_t *local = i->data;
pmpkg_t *spkg = NULL;
pmsyncpkg_t *sync;
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) {
_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;
}
@ -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) {
sync = j->data;
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;
}
}
}
if(replace) {
_alpm_log(PM_LOG_DEBUG, _("'%s' is already elected for removal -- skipping"),
local->name);
alpm_pkg_get_name(local));
continue;
}
/* compare versions and see if we need to upgrade */
if(alpm_pkg_compare_versions(local, spkg)) {
_alpm_log(PM_LOG_DEBUG, _("%s-%s elected for upgrade (%s => %s)"),
local->name, local->version, local->version, spkg->version);
if(!find_pkginsync(spkg->name, trans->packages)) {
pmpkg_t *dummy = _alpm_pkg_new(local->name, local->version);
alpm_pkg_get_name(local), alpm_pkg_get_version(local),
alpm_pkg_get_name(spkg), alpm_pkg_get_version(spkg));
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) {
goto error;
}
@ -279,22 +257,21 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
if(targ) {
*targ = '\0';
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) {
pmdb_t *dbs = j->data;
if(strcmp(dbs->treename, targline) == 0) {
pmdb_t *db = j->data;
if(strcmp(db->treename, targline) == 0) {
repo_found = 1;
spkg = _alpm_db_get_pkgfromcache(dbs, targ);
spkg = _alpm_db_get_pkgfromcache(db, targ);
if(spkg == NULL) {
/* Search provides */
alpm_list_t *p;
_alpm_log(PM_LOG_DEBUG, _("target '%s' not found -- looking for provisions"), targ);
p = _alpm_db_whatprovides(dbs, targ);
if(p == NULL) {
alpm_list_t *p = _alpm_db_whatprovides(db, targ);
if(!p) {
RET_ERR(PM_ERR_PKG_NOT_FOUND, -1);
}
_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);
}
}
@ -306,33 +283,34 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
} else {
targ = targline;
for(j = dbs_sync; j && !spkg; j = j->next) {
pmdb_t *dbs = j->data;
spkg = _alpm_db_get_pkgfromcache(dbs, targ);
pmdb_t *db = j->data;
spkg = _alpm_db_get_pkgfromcache(db, targ);
}
if(spkg == NULL) {
/* Search provides */
_alpm_log(PM_LOG_DEBUG, _("target '%s' not found -- looking for provisions"), targ);
for(j = dbs_sync; j && !spkg; j = j->next) {
pmdb_t *dbs = j->data;
alpm_list_t *p = _alpm_db_whatprovides(dbs, targ);
pmdb_t *db = j->data;
alpm_list_t *p = _alpm_db_whatprovides(db, targ);
if(p) {
_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);
}
}
}
}
if(spkg == NULL) {
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(alpm_pkg_compare_versions(local, spkg) == 0) {
/* spkg is NOT an upgrade, get confirmation before adding */
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);
if(!resp) {
return(0);
@ -340,7 +318,8 @@ int _alpm_sync_addtarget(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sy
} else {
QUESTION(trans, PM_TRANS_CONV_LOCAL_UPTODATE, local, NULL, NULL, &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);
}
}
@ -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 */
if(!find_pkginsync(spkg->name, trans->packages)) {
if(!_alpm_sync_find(trans->packages, alpm_pkg_get_name(spkg))) {
pmpkg_t *dummy = NULL;
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) {
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);
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);
}
@ -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)
{
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)
{
return(strcmp(((pmpkg_t *)p1)->name, ((pmsyncpkg_t *)p2)->pkg->name));
p1 = alpm_sync_get_pkg(sp1);
p2 = alpm_sync_get_pkg(sp2);
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)
@ -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) {
/* add the dependencies found by resolvedeps to the transaction set */
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);
if(sync == NULL) {
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);
_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 {
/* remove the original targets from the list if requested */
if((trans->flags & PM_TRANS_FLAG_DEPENDSONLY)) {
void *vp;
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;
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;
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);
/* 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;
}
sync = find_pkginsync(miss->target, trans->packages);
sync = _alpm_sync_find(trans->packages, miss->target);
if(sync == NULL) {
_alpm_log(PM_LOG_DEBUG, _("'%s' not found in transaction set -- skipping"),
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);
/* 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
* 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;
}
if(rmpkg) {
pmsyncpkg_t *rsync = find_pkginsync(rmpkg, trans->packages);
pmsyncpkg_t *rsync = _alpm_sync_find(trans->packages, rmpkg);
void *vpkg;
_alpm_log(PM_LOG_DEBUG, _("removing '%s' from target list"), rsync->pkg->name);
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);
asked = alpm_list_add(asked, strdup(miss->depend.name));
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);
if(q == NULL) {
if(data) {
@ -590,7 +573,7 @@ int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync
ret = -1;
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) {
/* switch this sync type to 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;
for(i = deps; i; i = i->next) {
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;
alpm_list_t *k;
/* 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
* 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;
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)) {
/* Found a match -- now look through final for a package that
* 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;
for(n = trans->packages; n && !pfound; n = n->next) {
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)) {
/* found matching provisio -- we're good to go */
_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;
}
}
@ -1002,13 +986,13 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
pmsyncpkg_t *sync = i->data;
if(sync->type == PM_SYNC_TYPE_REPLACE) {
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) {
alpm_list_t *k;
pmpkg_t *old = j->data;
/* merge lists */
for(k = old->requiredby; k; k = k->next) {
if(!alpm_list_find_str(new->requiredby, k->data)) {
for(k = alpm_pkg_get_requiredby(old); k; k = k->next) {
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 */
alpm_list_t *m;
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. */
continue;
}
for(m = depender->depends; m; m = m->next) {
if(!strcmp(m->data, old->name)) {
for(m = alpm_pkg_get_depends(depender); m; m = m->next) {
if(!strcmp(m->data, alpm_pkg_get_name(old))) {
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) {
_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 */
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) {
_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);
}
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)
{
/* 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_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 */
/* 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)
{
alpm_list_t *i, *j;
alpm_list_t *depends = NULL;
pmdb_t *localdb;
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(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"),
pkg->name, pkg->version);
} else {
@ -266,7 +268,7 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
}
localdb = alpm_option_get_localdb();
for(i = pkg->depends; i; i = i->next) {
for(i = depends; i; i = i->next) {
pmdepend_t dep;
if(_alpm_splitdep(i->data, &dep) != 0) {
continue;
@ -288,7 +290,7 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
continue;
}
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) {
continue;
@ -296,20 +298,22 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
found_provides = 1;
/* Ensure package has the right newpkg */
_alpm_db_read(localdb, deppkg, INFRQ_DEPENDS);
/* this is cheating... we call this function to populate the package */
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) {
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);
} 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)) {
_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);
@ -320,20 +324,22 @@ int _alpm_trans_update_depends(pmtrans_t *trans, pmpkg_t *pkg)
}
}
/* Ensure package has the right newpkg */
_alpm_db_read(localdb, deppkg, INFRQ_DEPENDS);
/* this is cheating... we call this function to populate the package */
alpm_pkg_get_requiredby(deppkg);
_alpm_log(PM_LOG_DEBUG, _("updating 'requiredby' field for package '%s'"), deppkg->name);
if(trans->type == PM_TRANS_TYPE_REMOVE) {
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);
} 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)) {
_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);

28
lib/libalpm/util.c
View File

@ -92,7 +92,7 @@ char* strsep(char** str, const char* delims)
/* Backported from Solaris Express 4/06
* Copyright (c) 2006 Sun Microsystems, Inc. */
char * mkdtemp(char *template)
char *mkdtemp(char *template)
{
char *t = alloca(strlen(template) + 1);
char *r;
@ -119,7 +119,7 @@ char * mkdtemp(char *template)
#endif
/* does the same thing as 'mkdir -p' */
int _alpm_makepath(char *path)
int _alpm_makepath(const char *path)
{
char *orig, *str, *ptr;
char full[PATH_MAX] = "";
@ -149,7 +149,7 @@ int _alpm_makepath(char *path)
return(0);
}
int _alpm_copyfile(char *src, char *dest)
int _alpm_copyfile(const char *src, const char *dest)
{
FILE *in, *out;
size_t len;
@ -184,7 +184,7 @@ char *_alpm_strtoupper(char *str)
(*ptr) = toupper(*ptr);
ptr++;
}
return str;
return(str);
}
/* Trim whitespace and newlines from a string
@ -221,7 +221,7 @@ char *_alpm_strtrim(char *str)
/* Create a lock file
*/
int _alpm_lckmk(char *file)
int _alpm_lckmk(const char *file)
{
int fd, count = 0;
char *dir, *ptr;
@ -249,7 +249,7 @@ int _alpm_lckmk(char *file)
/* Remove a lock file
*/
int _alpm_lckrm(char *file)
int _alpm_lckrm(const char *file)
{
if(unlink(file) == -1 && errno != ENOENT) {
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' */
int _alpm_rmrf(char *path)
int _alpm_rmrf(const char *path)
{
int errflag = 0;
struct dirent *dp;
@ -370,15 +370,15 @@ int _alpm_logaction(unsigned short usesyslog, FILE *f, const char *str)
return(0);
}
int _alpm_ldconfig(char *root)
int _alpm_ldconfig(const char *root)
{
char line[PATH_MAX];
struct stat buf;
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);
if(!stat(line, &buf)) {
if(stat(line, &buf) == 0) {
char cmd[PATH_MAX];
snprintf(cmd, PATH_MAX, "%s -r %s", line, root);
system(cmd);
@ -413,7 +413,9 @@ static int grep(const char *fn, const char *needle)
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 cmdline[PATH_MAX];
@ -589,13 +591,13 @@ int _alpm_check_freespace(pmtrans_t *trans, alpm_list_t **data)
pmsyncpkg_t *sync = i->data;
if(sync->type != PM_SYNC_TYPE_REPLACE) {
pmpkg_t *pkg = sync->pkg;
pkgsize += pkg->isize;
pkgsize += alpm_pkg_get_isize(pkg);
}
}
else
{
pmpkg_t *pkg = i->data;
pkgsize += pkg->size;
pkgsize += alpm_pkg_get_size(pkg);
}
}
freespace = get_freespace();

16
lib/libalpm/util.h
View File

@ -55,18 +55,20 @@
#define SCRIPTLET_START "START "
#define SCRIPTLET_DONE "DONE "
int _alpm_makepath(char *path);
int _alpm_copyfile(char *src, char *dest);
int _alpm_makepath(const char *path);
int _alpm_copyfile(const char *src, const char *dest);
char *_alpm_strtoupper(char *str);
char *_alpm_strtrim(char *str);
int _alpm_lckmk(char *file);
int _alpm_lckrm(char *file);
int _alpm_lckmk(const char *file);
int _alpm_lckrm(const char *file);
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_ldconfig(char *root);
int _alpm_ldconfig(const char *root);
#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__
int _alpm_check_freespace(pmtrans_t *trans, alpm_list_t **data);
#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) {
equal = 1;
} else {
int cmp = _alpm_versioncmp(pkg->version, dep->version);
int cmp = _alpm_versioncmp(alpm_pkg_get_version(pkg), dep->version);
switch(dep->mod) {
case PM_DEP_MOD_EQ: 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) {
_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"));
} else {
_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"));
}
}

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,
const int howmany, const int remain)
void cb_trans_progress(pmtransprog_t event, const char *pkgname, int percent,
int howmany, int remain)
{
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);
/* callback to handle display of the progress bar for transactions */
void cb_trans_progress(pmtransprog_t event, char *pkgname, const int percent,
const int howmany, const int remain);
void cb_trans_progress(pmtransprog_t event, const char *pkgname, int percent,
int howmany, int remain);
#endif /* _PM_TRANS_H */