libopkg: flag package with SF_NEED_DETAIL in pkg_init_from_file()

[oweals/opkg-lede.git] / libopkg / pkg.c

diff --git a/libopkg/pkg.c b/libopkg/pkg.c
index 0731bd0f1972fea8ff290e7b5c7e835c9c8bfbab..a76e152d4420c49153eac0eaff2316cc055a3ad6 100644 (file)
--- a/libopkg/pkg.c
+++ b/libopkg/pkg.c
@@ -212,6 +212,48 @@ int pkg_get_arch_priority(const pkg_t *pkg)
        return 0;
 }
 
+char *pkg_get_md5(const pkg_t *pkg)
+{
+       char *p = pkg_get_raw(pkg, PKG_MD5SUM);
+
+       if (!p)
+               return NULL;
+
+       return checksum_bin2hex(p, 16);
+}
+
+char *pkg_set_md5(pkg_t *pkg, const char *cksum)
+{
+       size_t len;
+       char *p = checksum_hex2bin(cksum, &len);
+
+       if (!p || len != 16)
+               return NULL;
+
+       return pkg_set_raw(pkg, PKG_MD5SUM, p, len);
+}
+
+char *pkg_get_sha256(const pkg_t *pkg)
+{
+       char *p = pkg_get_raw(pkg, PKG_SHA256SUM);
+
+       if (!p)
+               return NULL;
+
+       return checksum_bin2hex(p, 32);
+}
+
+char *pkg_set_sha256(pkg_t *pkg, const char *cksum)
+{
+       size_t len;
+       char *p = checksum_hex2bin(cksum, &len);
+
+       if (!p || len != 32)
+               return NULL;
+
+       return pkg_set_raw(pkg, PKG_SHA256SUM, p, len);
+}
+
 
 static void compound_depend_deinit(compound_depend_t * depends)
 {
@@ -227,7 +269,10 @@ static void compound_depend_deinit(compound_depend_t * depends)
 
 void pkg_deinit(pkg_t * pkg)
 {
+       int rem;
+       struct blob_attr *cur;
        compound_depend_t *deps, *dep;
+       void *ptr;
 
        if (pkg->name)
                free(pkg->name);
@@ -242,24 +287,43 @@ void pkg_deinit(pkg_t * pkg)
        pkg->state_flag = SF_OK;
        pkg->state_status = SS_NOT_INSTALLED;
 
-       deps = pkg_get_ptr(pkg, PKG_DEPENDS);
+       blob_for_each_attr(cur, pkg->blob.head, rem) {
+               switch (blob_id(cur)) {
+               case PKG_DEPENDS:
+               case PKG_CONFLICTS:
+                       deps = pkg_get_ptr(pkg, blob_id(cur));
+
+                       if (deps) {
+                               for (dep = deps; dep->type; dep++)
+                                       compound_depend_deinit(dep);
 
-       if (deps) {
-               for (dep = deps; dep->type; dep++)
-                       compound_depend_deinit(dep);
+                               free(deps);
+                       }
 
-               free(deps);
-               pkg_set_ptr(pkg, PKG_DEPENDS, NULL);
-       }
+                       pkg_set_ptr(pkg, blob_id(cur), NULL);
+                       break;
+
+               case PKG_REPLACES:
+               case PKG_PROVIDES:
+                       ptr = pkg_get_ptr(pkg, blob_id(cur));
 
-       deps = pkg_get_ptr(pkg, PKG_CONFLICTS);
+                       if (ptr)
+                               free(ptr);
 
-       if (deps) {
-               for (dep = deps; dep->type; dep++)
-                       compound_depend_deinit(dep);
+                       pkg_set_ptr(pkg, blob_id(cur), NULL);
+                       break;
 
-               free(deps);
-               pkg_set_ptr(pkg, PKG_CONFLICTS, NULL);
+               case PKG_CONFFILES:
+                       ptr = pkg_get_ptr(pkg, blob_id(cur));
+
+                       if (ptr) {
+                               conffile_list_deinit(ptr);
+                               free(ptr);
+                       }
+
+                       pkg_set_ptr(pkg, blob_id(cur), NULL);
+                       break;
+               }
        }
 
        //conffile_list_deinit(&pkg->conffiles);
@@ -271,7 +335,7 @@ void pkg_deinit(pkg_t * pkg)
        pkg_free_installed_files(pkg);
        pkg->essential = 0;
 
-       //blob_buf_free(&pkg->blob);
+       blob_buf_free(&pkg->blob);
 }
 
 int pkg_init_from_file(pkg_t * pkg, const char *filename)
@@ -282,6 +346,11 @@ int pkg_init_from_file(pkg_t * pkg, const char *filename)
 
        pkg_init(pkg);
 
+       if (!(pkg->state_flag & SF_NEED_DETAIL)) {
+               opkg_msg(DEBUG, "applying abpkg flag to %s\n", filename);
+               pkg->state_flag |= SF_NEED_DETAIL;
+       }
+
        pkg_set_string(pkg, PKG_LOCAL_FILENAME, filename);
 
        tmp = xstrdup(filename);
@@ -334,7 +403,6 @@ err0:
 int pkg_merge(pkg_t * oldpkg, pkg_t * newpkg)
 {
        abstract_pkg_t **ab;
-       conffile_list_t *cf, head;
 
        if (oldpkg == newpkg) {
                return 0;
@@ -366,6 +434,9 @@ int pkg_merge(pkg_t * oldpkg, pkg_t * newpkg)
        if (!ab || !ab[0] || !ab[1]) {
                pkg_set_ptr(oldpkg, PKG_PROVIDES, pkg_get_ptr(newpkg, PKG_PROVIDES));
                pkg_set_ptr(newpkg, PKG_PROVIDES, NULL);
+
+               if (ab)
+                       free(ab);
        }
 
        if (!pkg_get_ptr(oldpkg, PKG_CONFLICTS)) {
@@ -384,10 +455,10 @@ int pkg_merge(pkg_t * oldpkg, pkg_t * newpkg)
                pkg_set_string(oldpkg, PKG_LOCAL_FILENAME, pkg_get_string(newpkg, PKG_LOCAL_FILENAME));
        if (!pkg_get_string(oldpkg, PKG_TMP_UNPACK_DIR))
                pkg_set_string(oldpkg, PKG_TMP_UNPACK_DIR, pkg_get_string(newpkg, PKG_TMP_UNPACK_DIR));
-       if (!pkg_get_string(oldpkg, PKG_MD5SUM))
-               pkg_set_string(oldpkg, PKG_MD5SUM, pkg_get_string(newpkg, PKG_MD5SUM));
-       if (!pkg_get_string(oldpkg, PKG_SHA256SUM))
-               pkg_set_string(oldpkg, PKG_SHA256SUM, pkg_get_string(newpkg, PKG_SHA256SUM));
+       if (!pkg_get_md5(oldpkg))
+               pkg_set_md5(oldpkg, pkg_get_md5(newpkg));
+       if (!pkg_get_sha256(oldpkg))
+               pkg_set_sha256(oldpkg, pkg_get_sha256(newpkg));
        if (!pkg_get_int(oldpkg, PKG_SIZE))
                pkg_set_int(oldpkg, PKG_SIZE, pkg_get_int(newpkg, PKG_SIZE));
        if (!pkg_get_int(oldpkg, PKG_INSTALLED_SIZE))
@@ -398,12 +469,8 @@ int pkg_merge(pkg_t * oldpkg, pkg_t * newpkg)
                pkg_set_string(oldpkg, PKG_SOURCE, pkg_get_string(newpkg, PKG_SOURCE));
 
        if (!pkg_get_ptr(oldpkg, PKG_CONFFILES)) {
-               cf = pkg_get_ptr(newpkg, PKG_CONFFILES);
-               if (cf) {
-                       conffile_list_init(&head);
-                       list_splice_init(&cf->head, &head.head);
-                       pkg_set_raw(oldpkg, PKG_CONFFILES, &head, sizeof(head));
-               }
+               pkg_set_ptr(oldpkg, PKG_CONFFILES, pkg_get_ptr(newpkg, PKG_CONFFILES));
+               pkg_set_ptr(newpkg, PKG_CONFFILES, NULL);
        }
 
        if (!oldpkg->installed_files) {
@@ -716,7 +783,7 @@ void pkg_formatted_field(FILE * fp, pkg_t * pkg, const char *field)
                                fprintf(fp, "Maintainer: %s\n", p);
                        }
                } else if (strcasecmp(field, "MD5sum") == 0) {
-                       p = pkg_get_string(pkg, PKG_MD5SUM);
+                       p = pkg_get_md5(pkg);
                        if (p) {
                                fprintf(fp, "MD5Sum: %s\n", p);
                        }
@@ -734,10 +801,9 @@ void pkg_formatted_field(FILE * fp, pkg_t * pkg, const char *field)
                        ab_pkg = pkg_get_ptr(pkg, PKG_PROVIDES);
                        if (ab_pkg && ab_pkg[0] && ab_pkg[1]) {
                                fprintf(fp, "Provides:");
-                               for (i = 0, ab_pkg++; *ab_pkg; i++, ab_pkg++) {
-                                       fprintf(fp, "%s %s", i == 0 ? "" : ",",
-                                               (*ab_pkg)->name);
-                                       ab_pkg++;
+                               for (i = 1; ab_pkg[i]; i++) {
+                                       fprintf(fp, "%s %s", i == 1 ? "" : ",",
+                                               ab_pkg[i]->name);
                                }
                                fprintf(fp, "\n");
                        }