cr_Package *
get_package()
{
cr_Package *p;
cr_Dependency *dep;
cr_PackageFile *file;
p = cr_package_new();
p->pkgId = "123456";
p->name = "foo";
p->arch = "x86_64";
p->version = "1.2.3";
p->epoch = "1";
p->release = "2";
p->summary = "foo package";
p->description = "super cool package";
p->url = "http://package.com";
p->time_file = 123456;
p->time_build = 234567;
p->rpm_license = "GPL";
p->rpm_vendor = NULL;
p->rpm_group = NULL;
p->rpm_buildhost = NULL;
p->rpm_sourcerpm = "foo.src.rpm";
p->rpm_header_start = 20;
p->rpm_header_end = 120;
p->rpm_packager = NULL;
p->size_package = 123;
p->size_installed = 20;
p->size_archive = 30;
p->location_href = "foo.rpm";
p->location_base = NULL;
p->checksum_type = "sha256";
dep = cr_dependency_new();
dep->name = "foobar_dep";
dep->flags = NULL;
dep->pre = FALSE;
p->requires = (g_slist_prepend(p->requires, dep));
dep = cr_dependency_new();
dep->name = "foobar_pre_dep";
dep->flags = "LE";
dep->pre = TRUE;
p->requires = g_slist_prepend(p->requires, dep);
file = cr_package_file_new();
file->type = "";
file->path = "/bin/";
file->name = "foo";
p->files = g_slist_prepend(p->files, file);
file = cr_package_file_new();
file->type = "dir";
file->path = "/var/foo/";
file->name = NULL;
p->files = g_slist_prepend(p->files, file);
return p;
}
cr_Package *
get_empty_package()
{
cr_Package *p;
cr_Dependency *dep;
cr_PackageFile *file;
p = cr_package_new();
p->name = "foo";
dep = cr_dependency_new();
dep->name = NULL;
dep->flags = NULL;
dep->pre = FALSE;
p->requires = (g_slist_prepend(p->requires, dep));
dep = cr_dependency_new();
dep->name = NULL;
dep->flags = NULL;
dep->pre = TRUE;
p->requires = g_slist_prepend(p->requires, dep);
file = cr_package_file_new();
file->type = NULL;
file->path = NULL;
file->name = NULL;
p->files = g_slist_prepend(p->files, file);
return p;
}
int
cr_newpkgcb(cr_Package **pkg,
G_GNUC_UNUSED const char *pkgId,
G_GNUC_UNUSED const char *name,
G_GNUC_UNUSED const char *arch,
G_GNUC_UNUSED void *cbdata,
GError **err)
{
assert(pkg && *pkg == NULL);
assert(!err || *err == NULL);
*pkg = cr_package_new();
return CRE_OK;
}
static int
package_init(_PackageObject *self, PyObject *args, PyObject *kwds)
{
char *kwlist[] = {NULL};
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|:package_init", kwlist))
return -1;
if (self->package && self->free_on_destroy) // reinitialization by __init__()
cr_package_free(self->package);
if (self->parent) {
Py_DECREF(self->parent);
self->parent = NULL;
}
self->package = cr_package_new();
if (self->package == NULL) {
PyErr_SetString(CrErr_Exception, "Package initialization failed");
return -1;
}
return 0;
}
static int
primary_newpkgcb(cr_Package **pkg,
G_GNUC_UNUSED const char *pkgId,
G_GNUC_UNUSED const char *name,
G_GNUC_UNUSED const char *arch,
void *cbdata,
G_GNUC_UNUSED GError **err)
{
cr_CbData *cb_data = cbdata;
assert(*pkg == NULL);
if (cb_data->chunk) {
*pkg = cr_package_new_without_chunk();
(*pkg)->chunk = cb_data->chunk;
(*pkg)->loadingflags |= CR_PACKAGE_SINGLE_CHUNK;
} else {
*pkg = cr_package_new();
}
return CR_CB_RET_OK;
}
static int
newpkgcb_skip_fake_bash(cr_Package **pkg,
const char *pkgId,
const char *name,
const char *arch,
void *cbdata,
GError **err)
{
CR_UNUSED(pkgId);
CR_UNUSED(arch);
CR_UNUSED(cbdata);
g_assert(pkg != NULL);
g_assert(*pkg == NULL);
g_assert(pkgId != NULL);
g_assert(!err || *err == NULL);
if (!g_strcmp0(name, "fake_bash"))
return CRE_OK;
*pkg = cr_package_new();
return CR_CB_RET_OK;
}
cr_Package *
cr_package_from_header(Header hdr,
int changelog_limit,
cr_HeaderReadingFlags hdrrflags,
G_GNUC_UNUSED GError **err)
{
cr_Package *pkg;
assert(hdr);
assert(!err || *err == NULL);
// Create new package structure
pkg = cr_package_new();
pkg->loadingflags |= CR_PACKAGE_FROM_HEADER;
pkg->loadingflags |= CR_PACKAGE_LOADED_PRI;
pkg->loadingflags |= CR_PACKAGE_LOADED_FIL;
pkg->loadingflags |= CR_PACKAGE_LOADED_OTH;
// Create rpm tag data container
rpmtd td = rpmtdNew();
headerGetFlags flags = HEADERGET_MINMEM | HEADERGET_EXT;
// Fill package structure
pkg->name = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_NAME));
gint64 is_src = headerGetNumber(hdr, RPMTAG_SOURCEPACKAGE);
if (is_src) {
pkg->arch = cr_safe_string_chunk_insert(pkg->chunk, "src");
} else {
pkg->arch = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_ARCH));
}
pkg->version = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_VERSION));
#define MAX_STR_INT_LEN 24
char tmp_epoch[MAX_STR_INT_LEN];
if (snprintf(tmp_epoch, MAX_STR_INT_LEN, "%llu", (long long unsigned int) headerGetNumber(hdr, RPMTAG_EPOCH)) <= 0) {
tmp_epoch[0] = '\0';
}
pkg->epoch = g_string_chunk_insert_len(pkg->chunk, tmp_epoch, MAX_STR_INT_LEN);
pkg->release = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_RELEASE));
pkg->summary = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_SUMMARY));
pkg->description = cr_safe_string_chunk_insert_null(pkg->chunk, headerGetString(hdr, RPMTAG_DESCRIPTION));
pkg->url = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_URL));
if (headerGet(hdr, RPMTAG_BUILDTIME, td, flags)) {
pkg->time_build = rpmtdGetNumber(td);
}
pkg->rpm_license = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_LICENSE));
pkg->rpm_vendor = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_VENDOR));
pkg->rpm_group = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_GROUP));
pkg->rpm_buildhost = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_BUILDHOST));
pkg->rpm_sourcerpm = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_SOURCERPM));
pkg->rpm_packager = cr_safe_string_chunk_insert(pkg->chunk, headerGetString(hdr, RPMTAG_PACKAGER));
if (headerGet(hdr, RPMTAG_SIZE, td, flags)) {
pkg->size_installed = rpmtdGetNumber(td);
}
if (headerGet(hdr, RPMTAG_ARCHIVESIZE, td, flags)) {
pkg->size_archive = rpmtdGetNumber(td);
}
rpmtdFreeData(td);
rpmtdFree(td);
//
// Fill files
//
rpmtd full_filenames = rpmtdNew(); // Only for filenames_hashtable
rpmtd indexes = rpmtdNew();
rpmtd filenames = rpmtdNew();
rpmtd fileflags = rpmtdNew();
rpmtd filemodes = rpmtdNew();
GHashTable *filenames_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
rpmtd dirnames = rpmtdNew();
// Create list of pointer to directory names
int dir_count;
char **dir_list = NULL;
if (headerGet(hdr, RPMTAG_DIRNAMES, dirnames, flags) && (dir_count = rpmtdCount(dirnames))) {
int x = 0;
dir_list = malloc(sizeof(char *) * dir_count);
while (rpmtdNext(dirnames) != -1) {
dir_list[x] = cr_safe_string_chunk_insert(pkg->chunk, rpmtdGetString(dirnames));
x++;
}
assert(x == dir_count);
}
if (headerGet(hdr, RPMTAG_FILENAMES, full_filenames, flags) &&
headerGet(hdr, RPMTAG_DIRINDEXES, indexes, flags) &&
headerGet(hdr, RPMTAG_BASENAMES, filenames, flags) &&
headerGet(hdr, RPMTAG_FILEFLAGS, fileflags, flags) &&
headerGet(hdr, RPMTAG_FILEMODES, filemodes, flags))
{
rpmtdInit(full_filenames);
rpmtdInit(indexes);
rpmtdInit(filenames);
rpmtdInit(fileflags);
rpmtdInit(filemodes);
while ((rpmtdNext(full_filenames) != -1) &&
(rpmtdNext(indexes) != -1) &&
(rpmtdNext(filenames) != -1) &&
(rpmtdNext(fileflags) != -1) &&
(rpmtdNext(filemodes) != -1))
{
cr_PackageFile *packagefile = cr_package_file_new();
packagefile->name = cr_safe_string_chunk_insert(pkg->chunk,
rpmtdGetString(filenames));
packagefile->path = (dir_list) ? dir_list[(int) rpmtdGetNumber(indexes)] : "";
if (S_ISDIR(rpmtdGetNumber(filemodes))) {
// Directory
packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "dir");
} else if (rpmtdGetNumber(fileflags) & RPMFILE_GHOST) {
// Ghost
packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "ghost");
} else {
// Regular file
packagefile->type = cr_safe_string_chunk_insert(pkg->chunk, "");
}
g_hash_table_replace(filenames_hashtable,
(gpointer) rpmtdGetString(full_filenames),
(gpointer) rpmtdGetString(full_filenames));
pkg->files = g_slist_prepend(pkg->files, packagefile);
}
pkg->files = g_slist_reverse (pkg->files);
rpmtdFreeData(dirnames);
rpmtdFreeData(indexes);
rpmtdFreeData(filenames);
rpmtdFreeData(fileflags);
rpmtdFreeData(filemodes);
}
rpmtdFree(dirnames);
rpmtdFree(indexes);
rpmtdFree(filemodes);
if (dir_list) {
free((void *) dir_list);
}
//
// PCOR (provides, conflicts, obsoletes, requires)
//
rpmtd fileversions = rpmtdNew();
// Struct used as value in ap_hashtable
struct ap_value_struct {
const char *flags;
const char *version;
int pre;
};
// Hastable with filenames from provided
GHashTable *provided_hashtable = g_hash_table_new(g_str_hash, g_str_equal);
// Hashtable with already processed files from requires
GHashTable *ap_hashtable = g_hash_table_new_full(g_str_hash,
g_str_equal,
NULL,
free);
for (int deptype=0; dep_items[deptype].type != DEP_SENTINEL; deptype++) {
if (headerGet(hdr, dep_items[deptype].nametag, filenames, flags) &&
headerGet(hdr, dep_items[deptype].flagstag, fileflags, flags) &&
headerGet(hdr, dep_items[deptype].versiontag, fileversions, flags))
{
// Because we have to select only libc.so with highest version
// e.g. libc.so.6(GLIBC_2.4)
cr_Dependency *libc_require_highest = NULL;
rpmtdInit(filenames);
rpmtdInit(fileflags);
rpmtdInit(fileversions);
while ((rpmtdNext(filenames) != -1) &&
(rpmtdNext(fileflags) != -1) &&
(rpmtdNext(fileversions) != -1))
{
int pre = 0;
const char *filename = rpmtdGetString(filenames);
guint64 num_flags = rpmtdGetNumber(fileflags);
const char *flags = cr_flag_to_str(num_flags);
const char *full_version = rpmtdGetString(fileversions);
// Requires specific stuff
if (deptype == DEP_REQUIRES) {
// Skip requires which start with "rpmlib("
if (!strncmp("rpmlib(", filename, 7)) {
continue;
}
// Skip package primary files
if (g_hash_table_lookup_extended(filenames_hashtable, filename, NULL, NULL)) {
if (cr_is_primary(filename)) {
continue;
}
}
// Skip files which are provided
if (g_hash_table_lookup_extended(provided_hashtable, filename, NULL, NULL)) {
continue;
}
// Calculate pre value
if (num_flags & (RPMSENSE_PREREQ |
RPMSENSE_SCRIPT_PRE |
RPMSENSE_SCRIPT_POST))
{
pre = 1;
}
// Skip duplicate files
gpointer value;
if (g_hash_table_lookup_extended(ap_hashtable, filename, NULL, &value)) {
struct ap_value_struct *ap_value = value;
if (!g_strcmp0(ap_value->flags, flags) &&
!strcmp(ap_value->version, full_version) &&
(ap_value->pre == pre))
{
continue;
}
}
}
// Parse dep string
cr_EVR *evr = cr_str_to_evr(full_version, pkg->chunk);
if ((full_version && *full_version) && !evr->epoch) {
// NULL in epoch mean that the epoch was bad (non-numerical)
_cleanup_free_ gchar *pkg_nevra = cr_package_nevra(pkg);
g_warning("Bad epoch in version string \"%s\" for dependency \"%s\" in package \"%s\"",
full_version, filename, pkg_nevra);
g_warning("Skipping this dependency");
g_free(evr);
continue;
}
// Create dynamic dependency object
cr_Dependency *dependency = cr_dependency_new();
dependency->name = cr_safe_string_chunk_insert(pkg->chunk, filename);
dependency->flags = cr_safe_string_chunk_insert(pkg->chunk, flags);
dependency->epoch = evr->epoch;
dependency->version = evr->version;
dependency->release = evr->release;
g_free(evr);
switch (deptype) {
case DEP_PROVIDES:
g_hash_table_replace(provided_hashtable, dependency->name, dependency->name);
pkg->provides = g_slist_prepend(pkg->provides, dependency);
break;
case DEP_CONFLICTS:
pkg->conflicts = g_slist_prepend(pkg->conflicts, dependency);
break;
case DEP_OBSOLETES:
pkg->obsoletes = g_slist_prepend(pkg->obsoletes, dependency);
break;
case DEP_REQUIRES:
dependency->pre = pre;
// XXX: libc.so filtering ////////////////////////////
if (g_str_has_prefix(dependency->name, "libc.so.6")) {
if (!libc_require_highest)
libc_require_highest = dependency;
else {
if (cr_compare_dependency(libc_require_highest->name,
dependency->name) == 2)
{
g_free(libc_require_highest);
libc_require_highest = dependency;
} else
g_free(dependency);
}
break;
}
// XXX: libc.so filtering - END ///////////////////////
pkg->requires = g_slist_prepend(pkg->requires, dependency);
// Add file into ap_hashtable
struct ap_value_struct *value = malloc(sizeof(struct ap_value_struct));
value->flags = flags;
value->version = full_version;
value->pre = dependency->pre;
g_hash_table_replace(ap_hashtable, dependency->name, value);
break; //case REQUIRES end
case DEP_SUGGESTS:
pkg->suggests = g_slist_prepend(pkg->suggests, dependency);
break;
case DEP_ENHANCES:
pkg->enhances = g_slist_prepend(pkg->enhances, dependency);
break;
case DEP_RECOMMENDS:
pkg->recommends = g_slist_prepend(pkg->recommends, dependency);
break;
case DEP_SUPPLEMENTS:
pkg->supplements = g_slist_prepend(pkg->supplements, dependency);
break;
#ifdef ENABLE_LEGACY_WEAKDEPS
case DEP_OLDSUGGESTS:
if ( num_flags & RPMSENSE_STRONG ) {
pkg->recommends = g_slist_prepend(pkg->recommends, dependency);
} else {
pkg->suggests = g_slist_prepend(pkg->suggests, dependency);
}
break;
case DEP_OLDENHANCES:
if ( num_flags & RPMSENSE_STRONG ) {
pkg->supplements = g_slist_prepend(pkg->supplements, dependency);
} else {
pkg->enhances = g_slist_prepend(pkg->enhances, dependency);
}
break;
#endif
} // Switch end
} // While end
// XXX: libc.so filtering ////////////////////////////////
if (deptype == DEP_REQUIRES && libc_require_highest)
pkg->requires = g_slist_prepend(pkg->requires, libc_require_highest);
// XXX: libc.so filtering - END ////////////////////////////////
}
rpmtdFreeData(filenames);
rpmtdFreeData(fileflags);
rpmtdFreeData(fileversions);
}
pkg->provides = g_slist_reverse (pkg->provides);
pkg->conflicts = g_slist_reverse (pkg->conflicts);
pkg->obsoletes = g_slist_reverse (pkg->obsoletes);
pkg->requires = g_slist_reverse (pkg->requires);
pkg->suggests = g_slist_reverse (pkg->suggests);
pkg->enhances = g_slist_reverse (pkg->enhances);
pkg->recommends = g_slist_reverse (pkg->recommends);
pkg->supplements = g_slist_reverse (pkg->supplements);
g_hash_table_remove_all(filenames_hashtable);
g_hash_table_remove_all(provided_hashtable);
g_hash_table_remove_all(ap_hashtable);
g_hash_table_unref(filenames_hashtable);
g_hash_table_unref(provided_hashtable);
g_hash_table_unref(ap_hashtable);
rpmtdFree(filenames);
rpmtdFree(fileflags);
rpmtdFree(fileversions);
rpmtdFreeData(full_filenames);
rpmtdFree(full_filenames);
//
// Changelogs
//
rpmtd changelogtimes = rpmtdNew();
rpmtd changelognames = rpmtdNew();
rpmtd changelogtexts = rpmtdNew();
if (headerGet(hdr, RPMTAG_CHANGELOGTIME, changelogtimes, flags) &&
headerGet(hdr, RPMTAG_CHANGELOGNAME, changelognames, flags) &&
headerGet(hdr, RPMTAG_CHANGELOGTEXT, changelogtexts, flags))
{
gint64 last_time = G_GINT64_CONSTANT(0);
rpmtdInit(changelogtimes);
rpmtdInit(changelognames);
rpmtdInit(changelogtexts);
while ((rpmtdNext(changelogtimes) != -1) &&
(rpmtdNext(changelognames) != -1) &&
(rpmtdNext(changelogtexts) != -1) &&
(changelog_limit > 0 || changelog_limit == -1))
{
gint64 time = rpmtdGetNumber(changelogtimes);
cr_ChangelogEntry *changelog = cr_changelog_entry_new();
changelog->author = cr_safe_string_chunk_insert(pkg->chunk,
rpmtdGetString(changelognames));
changelog->date = time;
changelog->changelog = cr_safe_string_chunk_insert(pkg->chunk,
rpmtdGetString(changelogtexts));
// Remove space from end of author name
if (changelog->author) {
size_t len, x;
len = strlen(changelog->author);
for (x=(len-1); x > 0; x--) {
if (changelog->author[x] == ' ') {
changelog->author[x] = '\0';
} else {
break;
}
}
}
pkg->changelogs = g_slist_prepend(pkg->changelogs, changelog);
if (changelog_limit != -1)
changelog_limit--;
// If a previous entry has the same time, increment time of the previous
// entry by one. Ugly but works!
if (last_time == time) {
int tmp_time = time;
GSList *previous = pkg->changelogs;
while ((previous = g_slist_next(previous)) != NULL &&
((cr_ChangelogEntry *) (previous->data))->date == tmp_time) {
((cr_ChangelogEntry *) (previous->data))->date++;
tmp_time++;
}
} else {
last_time = time;
}
}
//pkg->changelogs = g_slist_reverse (pkg->changelogs);
}
rpmtdFreeData(changelogtimes);
rpmtdFreeData(changelognames);
rpmtdFreeData(changelogtexts);
rpmtdFree(changelogtimes);
rpmtdFree(changelognames);
rpmtdFree(changelogtexts);
//
// Keys and hdrid (data used for caching when the --cachedir is specified)
//
if (hdrrflags & CR_HDRR_LOADHDRID)
pkg->hdrid = cr_safe_string_chunk_insert(pkg->chunk,
headerGetString(hdr, RPMTAG_HDRID));
if (hdrrflags & CR_HDRR_LOADSIGNATURES) {
rpmtd gpgtd = rpmtdNew();
rpmtd pgptd = rpmtdNew();
if (headerGet(hdr, RPMTAG_SIGGPG, gpgtd, hdrrflags)
&& gpgtd->count > 0)
{
pkg->siggpg = cr_binary_data_new();
pkg->siggpg->size = gpgtd->count;
pkg->siggpg->data = g_string_chunk_insert_len(pkg->chunk,
gpgtd->data,
gpgtd->count);
}
if (headerGet(hdr, RPMTAG_SIGPGP, pgptd, hdrrflags)
&& pgptd->count > 0)
{
pkg->sigpgp = cr_binary_data_new();
pkg->sigpgp->size = pgptd->count;
pkg->sigpgp->data = g_string_chunk_insert_len(pkg->chunk,
pgptd->data,
pgptd->count);
}
rpmtdFree(gpgtd);
rpmtdFree(pgptd);
}
return pkg;
}
cr_Package *
cr_package_copy(cr_Package *orig)
{
cr_Package *pkg = cr_package_new();
pkg->pkgKey = orig->pkgKey;
pkg->pkgId = cr_safe_string_chunk_insert(pkg->chunk, orig->pkgId);
pkg->name = cr_safe_string_chunk_insert(pkg->chunk, orig->name);
pkg->arch = cr_safe_string_chunk_insert(pkg->chunk, orig->arch);
pkg->version = cr_safe_string_chunk_insert(pkg->chunk, orig->version);
pkg->epoch = cr_safe_string_chunk_insert(pkg->chunk, orig->epoch);
pkg->release = cr_safe_string_chunk_insert(pkg->chunk, orig->release);
pkg->summary = cr_safe_string_chunk_insert(pkg->chunk, orig->summary);
pkg->description = cr_safe_string_chunk_insert(pkg->chunk, orig->description);
pkg->url = cr_safe_string_chunk_insert(pkg->chunk, orig->url);
pkg->time_file = orig->time_file;
pkg->time_build = orig->time_build;
pkg->rpm_license = cr_safe_string_chunk_insert(pkg->chunk, orig->rpm_license);
pkg->rpm_vendor = cr_safe_string_chunk_insert(pkg->chunk, orig->rpm_vendor);
pkg->rpm_group = cr_safe_string_chunk_insert(pkg->chunk, orig->rpm_group);
pkg->rpm_buildhost = cr_safe_string_chunk_insert(pkg->chunk, orig->rpm_buildhost);
pkg->rpm_sourcerpm = cr_safe_string_chunk_insert(pkg->chunk, orig->rpm_sourcerpm);
pkg->rpm_header_start = orig->rpm_header_start;
pkg->rpm_header_end = orig->rpm_header_end;
pkg->rpm_packager = cr_safe_string_chunk_insert(pkg->chunk, orig->rpm_packager);
pkg->size_package = orig->size_package;
pkg->size_installed = orig->size_installed;
pkg->size_archive = orig->size_archive;
pkg->location_href = cr_safe_string_chunk_insert(pkg->chunk, orig->location_href);
pkg->location_base = cr_safe_string_chunk_insert(pkg->chunk, orig->location_base);
pkg->checksum_type = cr_safe_string_chunk_insert(pkg->chunk, orig->checksum_type);
pkg->requires = cr_dependency_dup(pkg->chunk, orig->requires);
pkg->provides = cr_dependency_dup(pkg->chunk, orig->provides);
pkg->conflicts = cr_dependency_dup(pkg->chunk, orig->conflicts);
pkg->obsoletes = cr_dependency_dup(pkg->chunk, orig->obsoletes);
pkg->suggests = cr_dependency_dup(pkg->chunk, orig->suggests);
pkg->enhances = cr_dependency_dup(pkg->chunk, orig->enhances);
pkg->recommends = cr_dependency_dup(pkg->chunk, orig->recommends);
pkg->supplements = cr_dependency_dup(pkg->chunk, orig->supplements);
for (GSList *elem = orig->files; elem; elem = g_slist_next(elem)) {
cr_PackageFile *orig_file = elem->data;
cr_PackageFile *file = cr_package_file_new();
file->type = cr_safe_string_chunk_insert(pkg->chunk, orig_file->type);
file->path = cr_safe_string_chunk_insert(pkg->chunk, orig_file->path);
file->name = cr_safe_string_chunk_insert(pkg->chunk, orig_file->name);
pkg->files = g_slist_prepend(pkg->files, file);
}
for (GSList *elem = orig->changelogs; elem; elem = g_slist_next(elem)) {
cr_ChangelogEntry *orig_log = elem->data;
cr_ChangelogEntry *log = cr_changelog_entry_new();
log->author = cr_safe_string_chunk_insert(pkg->chunk, orig_log->author);
log->date = orig_log->date;
log->changelog = cr_safe_string_chunk_insert(pkg->chunk, orig_log->changelog);
pkg->changelogs = g_slist_prepend(pkg->changelogs, log);
}
return pkg;
}
