int
hy_package_evr_cmp(HyPackage pkg1, HyPackage pkg2)
{
Pool *pool1 = package_pool(pkg1);
Pool *pool2 = package_pool(pkg2);
Solvable *s1 = get_solvable(pkg1);
Solvable *s2 = get_solvable(pkg2);
const char *str1 = pool_id2str(pool1, s1->evr);
const char *str2 = pool_id2str(pool2, s2->evr);
return pool_evrcmp_str(package_pool(pkg1), str1, str2, EVRCMP_COMPARE);
}
/**
* dnf_package_evr_cmp:
* @pkg1: a #DnfPackage instance.
* @pkg2: another #DnfPackage instance.
*
* Compares two packages, only using the EVR values.
*
* Returns: %TRUE for success
*
* Since: 0.7.0
*/
int
dnf_package_evr_cmp(DnfPackage *pkg1, DnfPackage *pkg2)
{
Pool *pool1 = dnf_package_get_pool(pkg1);
Pool *pool2 = dnf_package_get_pool(pkg2);
Solvable *s1 = get_solvable(pkg1);
Solvable *s2 = get_solvable(pkg2);
const char *str1 = pool_id2str(pool1, s1->evr);
const char *str2 = pool_id2str(pool2, s2->evr);
return pool_evrcmp_str(dnf_package_get_pool(pkg1), str1, str2, EVRCMP_COMPARE);
}
char *
hy_package_get_location(HyPackage pkg)
{
Solvable *s = get_solvable(pkg);
repo_internalize_trigger(s->repo);
return solv_strdup(solvable_get_location(s, NULL));
}
/**
* dnf_package_get_advisories:
* @pkg: a #DnfPackage instance.
*
* Gets the list of advisories for the package.
*
* Returns: (transfer container) (element-type DnfAdvisory): a list
*
* Since: 0.7.0
*/
GPtrArray *
dnf_package_get_advisories(DnfPackage *pkg, int cmp_type)
{
Dataiterator di;
Id evr;
int cmp;
DnfAdvisory *advisory;
Pool *pool = dnf_package_get_pool(pkg);
DnfSack *sack = dnf_package_get_sack(pkg);
GPtrArray *advisorylist = g_ptr_array_new();
Solvable *s = get_solvable(pkg);
dataiterator_init(&di, pool, 0, 0, UPDATE_COLLECTION_NAME,
pool_id2str(pool, s->name), SEARCH_STRING);
dataiterator_prepend_keyname(&di, UPDATE_COLLECTION);
while (dataiterator_step(&di)) {
dataiterator_setpos_parent(&di);
if (pool_lookup_id(pool, SOLVID_POS, UPDATE_COLLECTION_ARCH) != s->arch)
continue;
evr = pool_lookup_id(pool, SOLVID_POS, UPDATE_COLLECTION_EVR);
if (!evr)
continue;
cmp = pool_evrcmp(pool, evr, s->evr, EVRCMP_COMPARE);
if ((cmp > 0 && (cmp_type & HY_GT)) ||
(cmp < 0 && (cmp_type & HY_LT)) ||
(cmp == 0 && (cmp_type & HY_EQ))) {
advisory = dnf_advisory_new(sack, di.solvid);
g_ptr_array_add(advisorylist, advisory);
dataiterator_skip_solvable(&di);
}
}
dataiterator_free(&di);
return advisorylist;
}
static DnfReldepList *
reldeps_for(DnfPackage *pkg, Id type)
{
Pool *pool = dnf_package_get_pool(pkg);
Solvable *s = get_solvable(pkg);
DnfReldepList *reldeplist;
Queue q, q_final;
Id marker = -1;
Id solv_type = type;
Id rel_id;
if (type == SOLVABLE_REQUIRES)
marker = 0;
if (type == SOLVABLE_PREREQMARKER) {
solv_type = SOLVABLE_REQUIRES;
marker = 1;
}
queue_init(&q);
queue_init(&q_final);
solvable_lookup_deparray(s, solv_type, &q, marker);
for (int i = 0; i < q.count; i++) {
rel_id = q.elements[i];
if (rel_id != SOLVABLE_PREREQMARKER)
queue_push(&q_final, rel_id);
}
reldeplist = dnf_reldep_list_from_queue (pool, q_final);
queue_free(&q);
queue_free(&q_final);
return reldeplist;
}
/**
* dnf_package_get_delta_from_evr:
* @pkg: a #DnfPackage instance.
* @from_evr: the EVR string of what's installed
*
* Gets the package delta for the package given an existing EVR.
*
* Returns: a #DnfPackageDelta, or %NULL
*
* Since: 0.7.0
*/
DnfPackageDelta *
dnf_package_get_delta_from_evr(DnfPackage *pkg, const char *from_evr)
{
Pool *pool = dnf_package_get_pool(pkg);
Solvable *s = get_solvable(pkg);
DnfPackageDelta *delta = NULL;
Dataiterator di;
const char *name = dnf_package_get_name(pkg);
dataiterator_init(&di, pool, s->repo, SOLVID_META, DELTA_PACKAGE_NAME, name,
SEARCH_STRING);
dataiterator_prepend_keyname(&di, REPOSITORY_DELTAINFO);
while (dataiterator_step(&di)) {
dataiterator_setpos_parent(&di);
if (pool_lookup_id(pool, SOLVID_POS, DELTA_PACKAGE_EVR) != s->evr ||
pool_lookup_id(pool, SOLVID_POS, DELTA_PACKAGE_ARCH) != s->arch)
continue;
const char * base_evr = pool_id2str(pool, pool_lookup_id(pool, SOLVID_POS,
DELTA_BASE_EVR));
if (strcmp(base_evr, from_evr))
continue;
// we have the right delta info, set up DnfPackageDelta *and break out:
delta = dnf_packagedelta_new(pool);
break;
}
dataiterator_free(&di);
return delta;
}
static guint64
lookup_num(DnfPackage *pkg, unsigned type)
{
Solvable *s = get_solvable(pkg);
repo_internalize_trigger(s->repo);
return solvable_lookup_num(s, type, 0);
}
static unsigned long long
lookup_num(HyPackage pkg, unsigned type)
{
Solvable *s = get_solvable(pkg);
repo_internalize_trigger(s->repo);
return solvable_lookup_num(s, type, 0);
}
HyAdvisoryList
hy_package_get_advisories(HyPackage pkg, int cmp_type)
{
Dataiterator di;
Id evr;
int cmp;
HyAdvisory advisory;
Pool *pool = package_pool(pkg);
HyAdvisoryList advisorylist = advisorylist_create(pool);
Solvable *s = get_solvable(pkg);
dataiterator_init(&di, pool, 0, 0, UPDATE_COLLECTION_NAME,
pool_id2str(pool, s->name), SEARCH_STRING);
dataiterator_prepend_keyname(&di, UPDATE_COLLECTION);
while (dataiterator_step(&di)) {
dataiterator_setpos_parent(&di);
if (pool_lookup_id(pool, SOLVID_POS, UPDATE_COLLECTION_ARCH) != s->arch)
continue;
evr = pool_lookup_id(pool, SOLVID_POS, UPDATE_COLLECTION_EVR);
if (!evr)
continue;
cmp = pool_evrcmp(pool, evr, s->evr, EVRCMP_COMPARE);
if ((cmp > 0 && (cmp_type & HY_GT)) ||
(cmp < 0 && (cmp_type & HY_LT)) ||
(cmp == 0 && (cmp_type & HY_EQ))) {
advisory = advisory_create(pool, di.solvid);
advisorylist_add(advisorylist, advisory);
hy_advisory_free(advisory);
dataiterator_skip_solvable(&di);
}
}
dataiterator_free(&di);
return advisorylist;
}
/**
* dnf_package_get_sourcerpm:
* @pkg: a #DnfPackage instance.
*
* Gets the source RPM for the package.
*
* Returns: (transfer none): a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_sourcerpm(DnfPackage *pkg)
{
Solvable *s = get_solvable(pkg);
repo_internalize_trigger(s->repo);
return solvable_lookup_sourcepkg(s);
}
/**
* dnf_package_get_location:
* @pkg: a #DnfPackage instance.
*
* Gets the location (XXX??) for the package. Note that the returned string has
* an undefined lifetime and may become invalid at a later time. You should copy
* the string if storing it into a long-lived data structure.
*
* Returns: (transfer none): string
*
* Since: 0.7.0
*/
const char *
dnf_package_get_location(DnfPackage *pkg)
{
Solvable *s = get_solvable(pkg);
if (s->repo) {
repo_internalize_trigger(s->repo);
}
return solvable_get_location(s, NULL);
}
/**
* hif_package_get_chksum:
* @pkg: a #HifPackage instance.
*
* Gets the checksum for the package.
*
* Returns: raw checksum bytes
*
* Since: 0.7.0
*/
const unsigned char *
hif_package_get_chksum(HifPackage *pkg, int *type)
{
Solvable *s = get_solvable(pkg);
const unsigned char* ret;
ret = solvable_lookup_bin_checksum(s, SOLVABLE_CHECKSUM, type);
if (ret)
*type = checksumt_l2h(*type);
return ret;
}
/**
* SHA1 checksum of the package's header.
*
* Only sane for packages in rpmdb.
*/
const unsigned char *
hy_package_get_hdr_chksum(HyPackage pkg, int *type)
{
Solvable *s = get_solvable(pkg);
const unsigned char *ret;
ret = solvable_lookup_bin_checksum(s, SOLVABLE_HDRID, type);
if (ret)
*type = checksumt_l2h(*type);
return ret;
}
/**
* dnf_package_get_hdr_chksum:
* @pkg: a #DnfPackage instance.
*
* Gets the SHA1 checksum of the packages header.
* This is only set for packages in the rpmdb.
*
* Returns: raw checksum bytes
*
* Since: 0.7.0
*/
const unsigned char *
dnf_package_get_hdr_chksum(DnfPackage *pkg, int *type)
{
Solvable *s = get_solvable(pkg);
const unsigned char *ret;
repo_internalize_trigger(s->repo);
ret = solvable_lookup_bin_checksum(s, SOLVABLE_HDRID, type);
if (ret)
*type = checksumt_l2h(*type);
return ret;
}
static HyReldepList
reldeps_for(HyPackage pkg, Id type)
{
Pool *pool = package_pool(pkg);
Solvable *s = get_solvable(pkg);
HyReldepList reldeplist;
Queue q;
queue_init(&q);
solvable_lookup_deparray(s, type, &q, -1);
reldeplist = reldeplist_from_queue(pool, q);
queue_free(&q);
return reldeplist;
}
HyStringArray
hy_package_get_files(HyPackage pkg)
{
Pool *pool = package_pool(pkg);
Solvable *s = get_solvable(pkg);
Dataiterator di;
int len = 0;
HyStringArray strs = solv_extend(0, 0, 1, sizeof(char*), BLOCK_SIZE);
repo_internalize_trigger(s->repo);
dataiterator_init(&di, pool, s->repo, pkg->id, SOLVABLE_FILELIST, NULL,
SEARCH_FILES | SEARCH_COMPLETE_FILELIST);
while (dataiterator_step(&di)) {
strs[len++] = solv_strdup(di.kv.str);
strs = solv_extend(strs, len, 1, sizeof(char*), BLOCK_SIZE);
}
dataiterator_free(&di);
strs[len++] = NULL;
return strs;
}
HyPackageDelta
hy_package_get_delta_from_evr(HyPackage pkg, const char *from_evr)
{
Pool *pool = package_pool(pkg);
Solvable *s = get_solvable(pkg);
HyPackageDelta delta = NULL;
Dataiterator di;
Id checksum_type;
const unsigned char *checksum;
const char *name = hy_package_get_name(pkg);
dataiterator_init(&di, pool, s->repo, SOLVID_META, DELTA_PACKAGE_NAME, name,
SEARCH_STRING);
dataiterator_prepend_keyname(&di, REPOSITORY_DELTAINFO);
while (dataiterator_step(&di)) {
dataiterator_setpos_parent(&di);
if (pool_lookup_id(pool, SOLVID_POS, DELTA_PACKAGE_EVR) != s->evr ||
pool_lookup_id(pool, SOLVID_POS, DELTA_PACKAGE_ARCH) != s->arch)
continue;
const char * base_evr = pool_id2str(pool, pool_lookup_id(pool, SOLVID_POS,
DELTA_BASE_EVR));
if (strcmp(base_evr, from_evr))
continue;
// we have the right delta info, set up HyPackageDelta and break out:
delta = delta_create();
delta->location = solv_strdup(pool_lookup_deltalocation(pool, SOLVID_POS, 0));
delta->baseurl = solv_strdup(pool_lookup_str(pool, SOLVID_POS, DELTA_LOCATION_BASE));
delta->downloadsize = pool_lookup_num(pool, SOLVID_POS, DELTA_DOWNLOADSIZE, 0);
checksum = pool_lookup_bin_checksum(pool, SOLVID_POS, DELTA_CHECKSUM, &checksum_type);
if (checksum) {
delta->checksum_type = checksumt_l2h(checksum_type);
delta->checksum = solv_memdup((void*)checksum, checksum_type2length(delta->checksum_type));
}
break;
}
dataiterator_free(&di);
return delta;
}
static HifReldepList *
reldeps_for(HifPackage *pkg, Id type)
{
Pool *pool = hif_package_get_pool(pkg);
Solvable *s = get_solvable(pkg);
HifReldepList *reldeplist;
Queue q;
Id marker = -1;
Id solv_type = type;
if (type == SOLVABLE_PREREQMARKER) {
solv_type = SOLVABLE_REQUIRES;
marker = 1;
}
queue_init(&q);
solvable_lookup_deparray(s, solv_type, &q, marker);
reldeplist = hif_reldep_list_from_queue (pool, q);
queue_free(&q);
return reldeplist;
}
/**
* dnf_package_get_baseurl:
* @pkg: a #DnfPackage instance.
*
* Gets the baseurl for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_baseurl(DnfPackage *pkg)
{
Solvable *s = get_solvable(pkg);
return solvable_lookup_str(s, SOLVABLE_MEDIABASE);
}
/**
* dnf_package_get_summary:
* @pkg: a #DnfPackage instance.
*
* Gets the summary for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_summary(DnfPackage *pkg)
{
Solvable *s = get_solvable(pkg);
return solvable_lookup_str(s, SOLVABLE_SUMMARY);
}
/**
* dnf_package_get_url:
* @pkg: a #DnfPackage instance.
*
* Gets the url for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_url(DnfPackage *pkg)
{
return solvable_lookup_str(get_solvable(pkg), SOLVABLE_URL);
}
/**
* dnf_package_get_license:
* @pkg: a #DnfPackage instance.
*
* Gets the license for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_license(DnfPackage *pkg)
{
return solvable_lookup_str(get_solvable(pkg), SOLVABLE_LICENSE);
}
/**
* dnf_package_get_reponame:
* @pkg: a #DnfPackage instance.
*
* Gets the reponame for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_reponame(DnfPackage *pkg)
{
Solvable *s = get_solvable(pkg);
return s->repo->name;
}
/**
* dnf_package_get_evr:
* @pkg: a #DnfPackage instance.
*
* Gets the EVR for the package.
*
* Returns: a string
*
* Since: 0.7.0
*/
const char *
dnf_package_get_evr(DnfPackage *pkg)
{
Pool *pool = dnf_package_get_pool(pkg);
return pool_id2str(pool, get_solvable(pkg)->evr);
}
/**
* dnf_package_get_group:
* @pkg: a #DnfPackage instance.
*
* Gets the group for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_group(DnfPackage *pkg)
{
return solvable_lookup_str(get_solvable(pkg), SOLVABLE_GROUP);
}
/**
* dnf_package_get_description:
* @pkg: a #DnfPackage instance.
*
* Gets the description for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_description(DnfPackage *pkg)
{
return solvable_lookup_str(get_solvable(pkg), SOLVABLE_DESCRIPTION);
}
/**
* dnf_package_installed:
* @pkg: a #DnfPackage instance.
*
* Tests if the package is installed.
*
* Returns: %TRUE if installed
*
* Since: 0.7.0
*/
gboolean
dnf_package_installed(DnfPackage *pkg)
{
Solvable *s = get_solvable(pkg);
return (dnf_package_get_pool(pkg)->installed == s->repo);
}
/**
* dnf_package_get_packager:
* @pkg: a #DnfPackage instance.
*
* Gets the XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX for the package.
*
* Returns: a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_packager(DnfPackage *pkg)
{
return solvable_lookup_str(get_solvable(pkg), SOLVABLE_PACKAGER);
}
const char *
hy_package_get_url(HyPackage pkg)
{
return solvable_lookup_str(get_solvable(pkg), SOLVABLE_URL);
}
/**
* dnf_package_get_nevra:
* @pkg: a #DnfPackage instance.
*
* Gets the package NEVRA. Note that the returned string has an undefined
* lifetime and may become invalid at a later time. You should copy the string
* if storing it into a long-lived data structure.
*
* Returns: (transfer none): a string, or %NULL
*
* Since: 0.7.0
*/
const char *
dnf_package_get_nevra(DnfPackage *pkg)
{
Solvable *s = get_solvable(pkg);
return pool_solvable2str(dnf_package_get_pool(pkg), s);
}
