General Public License for more details.
*/
-#include "config.h"
-
#include <stdio.h>
#include <string.h>
#include <ctype.h>
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)
{
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);
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));
+
+ if (ptr)
+ free(ptr);
+
+ pkg_set_ptr(pkg, blob_id(cur), NULL);
+ break;
- deps = pkg_get_ptr(pkg, PKG_CONFLICTS);
+ case PKG_CONFFILES:
+ ptr = pkg_get_ptr(pkg, blob_id(cur));
- if (deps) {
- for (dep = deps; dep->type; dep++)
- compound_depend_deinit(dep);
+ if (ptr) {
+ conffile_list_deinit(ptr);
+ free(ptr);
+ }
- free(deps);
- pkg_set_ptr(pkg, PKG_CONFLICTS, NULL);
+ pkg_set_ptr(pkg, blob_id(cur), NULL);
+ break;
+ }
}
//conffile_list_deinit(&pkg->conffiles);
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)
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);
int pkg_merge(pkg_t * oldpkg, pkg_t * newpkg)
{
abstract_pkg_t **ab;
- conffile_list_t *cf, head;
if (oldpkg == newpkg) {
return 0;
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)) {
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))
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) {
if (!oldpkg->essential)
oldpkg->essential = newpkg->essential;
+ if (!oldpkg->provided_by_hand)
+ oldpkg->provided_by_hand = newpkg->provided_by_hand;
+
return 0;
}
return ab_pkg;
}
-void set_flags_from_control(pkg_t * pkg)
-{
- char *file_name;
- FILE *fp;
-
- sprintf_alloc(&file_name, "%s/%s.control", pkg->dest->info_dir,
- pkg->name);
-
- fp = fopen(file_name, "r");
- if (fp == NULL) {
- opkg_perror(ERROR, "Failed to open %s", file_name);
- free(file_name);
- return;
- }
-
- free(file_name);
-
- if (pkg_parse_from_stream(pkg, fp, PFM_ALL ^ PFM_ESSENTIAL)) {
- opkg_msg(DEBUG,
- "Unable to read control file for %s. May be empty.\n",
- pkg->name);
- }
-
- fclose(fp);
-
- return;
-}
-
static const char *pkg_state_want_to_str(pkg_state_want_t sw)
{
int i;
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);
}
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");
}
if (p) {
fprintf(fp, "Section: %s\n", p);
}
-#if defined HAVE_SHA256
} else if (strcasecmp(field, "SHA256sum") == 0) {
p = pkg_get_string(pkg, PKG_SHA256SUM);
if (p) {
fprintf(fp, "SHA256sum: %s\n", p);
}
-#endif
} else if (strcasecmp(field, "Size") == 0) {
i = pkg_get_int(pkg, PKG_SIZE);
if (i) {
sprintf_alloc(&cmd, "%s %s", path, args);
free(path);
{
- const char *argv[] = { "sh", "-c", cmd, NULL };
+ const char *argv[] = { "/bin/sh", "-c", cmd, NULL };
err = xsystem(argv);
}
free(cmd);
projects / oweals / opkg-lede.git / blobdiff