X-Git-Url: https://git.librecmc.org/?p=oweals%2Fopkg-lede.git;a=blobdiff_plain;f=libopkg%2Fpkg.c;h=64ee70a00c401244e8a8e7c1d0c06a2a142d1250;hp=278b7271d8893717cad42f48d8301296af9c9c47;hb=88772de23af57eac5c19670fde72d8e905109088;hpb=cc67a2a72b7b9eb1477c7afdff2ab4409689bb05 diff --git a/libopkg/pkg.c b/libopkg/pkg.c index 278b727..64ee70a 100644 --- a/libopkg/pkg.c +++ b/libopkg/pkg.c @@ -15,12 +15,13 @@ General Public License for more details. */ -#include "includes.h" -#include -#include +#include "config.h" + +#include #include -#include -#include +#include +#include +#include #include "pkg.h" @@ -38,8 +39,8 @@ typedef struct enum_map enum_map_t; struct enum_map { - int value; - char *str; + unsigned int value; + const char *str; }; static const enum_map_t pkg_state_want_map[] = { @@ -95,17 +96,15 @@ pkg_init(pkg_t *pkg) pkg->recommends_str = NULL; pkg->suggests_count = 0; pkg->recommends_count = 0; - + active_list_init(&pkg->list); - /* Abhaya: added init for conflicts fields */ pkg->conflicts = NULL; pkg->conflicts_count = 0; - /* added for replaces. Jamey 7/23/2002 */ pkg->replaces = NULL; pkg->replaces_count = 0; - + pkg->pre_depends_count = 0; pkg->pre_depends_str = NULL; pkg->provides_count = 0; @@ -117,8 +116,8 @@ pkg_init(pkg_t *pkg) #if defined HAVE_SHA256 pkg->sha256sum = NULL; #endif - pkg->size = NULL; - pkg->installed_size = NULL; + pkg->size = 0; + pkg->installed_size = 0; pkg->priority = NULL; pkg->source = NULL; conffile_list_init(&pkg->conffiles); @@ -190,7 +189,7 @@ pkg_deinit(pkg_t *pkg) if (pkg->description) free(pkg->description); pkg->description = NULL; - + pkg->state_want = SW_UNKNOWN; pkg->state_flag = SF_OK; pkg->state_status = SS_NOT_INSTALLED; @@ -223,11 +222,11 @@ pkg_deinit(pkg_t *pkg) pkg->pre_depends_count = 0; pkg->provides_count = 0; - + if (pkg->filename) free(pkg->filename); pkg->filename = NULL; - + if (pkg->local_filename) free(pkg->local_filename); pkg->local_filename = NULL; @@ -249,14 +248,6 @@ pkg_deinit(pkg_t *pkg) pkg->sha256sum = NULL; #endif - if (pkg->size) - free(pkg->size); - pkg->size = NULL; - - if (pkg->installed_size) - free(pkg->installed_size); - pkg->installed_size = NULL; - if (pkg->priority) free(pkg->priority); pkg->priority = NULL; @@ -280,42 +271,52 @@ pkg_deinit(pkg_t *pkg) } int -pkg_init_from_file(opkg_conf_t *conf, pkg_t *pkg, const char *filename) +pkg_init_from_file(pkg_t *pkg, const char *filename) { int fd, err = 0; FILE *control_file; - char *control_path; + char *control_path, *tmp; pkg_init(pkg); pkg->local_filename = xstrdup(filename); - sprintf_alloc(&control_path, "%s/%s.control.XXXXXX", + tmp = xstrdup(filename); + sprintf_alloc(&control_path, "%s/%s.control.XXXXXX", conf->tmp_dir, - basename(filename)); + basename(tmp)); + free(tmp); fd = mkstemp(control_path); if (fd == -1) { - perror_msg("%s: mkstemp(%s)", __FUNCTION__, control_path); + opkg_perror(ERROR, "Failed to make temp file %s", control_path); err = -1; goto err0; } control_file = fdopen(fd, "r+"); if (control_file == NULL) { - perror_msg("%s: fdopen", __FUNCTION__, control_path); + opkg_perror(ERROR, "Failed to fdopen %s", control_path); close(fd); err = -1; goto err1; } err = pkg_extract_control_file_to_stream(pkg, control_file); - if (err) + if (err) { + opkg_msg(ERROR, "Failed to extract control file from %s.\n", + filename); goto err2; + } rewind(control_file); - if (pkg_parse_from_stream(pkg, control_file, PFM_ALL)) + if ((err = pkg_parse_from_stream(pkg, control_file, 0))) { + if (err == 1) { + opkg_msg(ERROR, "Malformed package file %s.\n", + filename); + } err = -1; + } err2: fclose(control_file); @@ -328,15 +329,8 @@ err0: } /* Merge any new information in newpkg into oldpkg */ -/* XXX: CLEANUP: This function shouldn't actually modify anything in - newpkg, but should leave it usable. This rework is so that - pkg_hash_insert doesn't clobber the pkg that you pass into it. */ -/* - * uh, i thought that i had originally written this so that it took - * two pkgs and returned a new one? we can do that again... -sma - */ int -pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status) +pkg_merge(pkg_t *oldpkg, pkg_t *newpkg) { if (oldpkg == newpkg) { return 0; @@ -359,18 +353,6 @@ pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status) oldpkg->maintainer = xstrdup(newpkg->maintainer); if(!oldpkg->description) oldpkg->description = xstrdup(newpkg->description); - if (set_status) { - /* merge the state_flags from the new package */ - oldpkg->state_want = newpkg->state_want; - oldpkg->state_status = newpkg->state_status; - oldpkg->state_flag = newpkg->state_flag; - } else { - if (oldpkg->state_want == SW_UNKNOWN) - oldpkg->state_want = newpkg->state_want; - if (oldpkg->state_status == SS_NOT_INSTALLED) - oldpkg->state_status = newpkg->state_status; - oldpkg->state_flag |= newpkg->state_flag; - } if (!oldpkg->depends_count && !oldpkg->pre_depends_count && !oldpkg->recommends_count && !oldpkg->suggests_count) { oldpkg->depends_count = newpkg->depends_count; @@ -428,22 +410,24 @@ pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status) oldpkg->sha256sum = xstrdup(newpkg->sha256sum); #endif if (!oldpkg->size) - oldpkg->size = xstrdup(newpkg->size); + oldpkg->size = newpkg->size; if (!oldpkg->installed_size) - oldpkg->installed_size = xstrdup(newpkg->installed_size); + oldpkg->installed_size = newpkg->installed_size; if (!oldpkg->priority) oldpkg->priority = xstrdup(newpkg->priority); if (!oldpkg->source) oldpkg->source = xstrdup(newpkg->source); + if (nv_pair_list_empty(&oldpkg->conffiles)){ list_splice_init(&newpkg->conffiles.head, &oldpkg->conffiles.head); - conffile_list_init(&newpkg->conffiles); } + if (!oldpkg->installed_files){ oldpkg->installed_files = newpkg->installed_files; oldpkg->installed_files_ref_cnt = newpkg->installed_files_ref_cnt; newpkg->installed_files = NULL; } + if (!oldpkg->essential) oldpkg->essential = newpkg->essential; @@ -470,7 +454,7 @@ abstract_pkg_new(void) } void -set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){ +set_flags_from_control(pkg_t *pkg){ char *file_name; FILE *fp; @@ -478,16 +462,16 @@ set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){ fp = fopen(file_name, "r"); if (fp == NULL) { - opkg_message(conf, OPKG_ERROR, "%s: fopen(%s): %s\n", - __FUNCTION__, file_name, strerror(errno)); + opkg_perror(ERROR, "Failed to open %s", file_name); free(file_name); return; } free(file_name); - if (pkg_parse_from_stream(pkg, fp, PFM_ESSENTIAL)) { - opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->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); @@ -495,7 +479,7 @@ set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){ return; } -static char * +static const char * pkg_state_want_to_str(pkg_state_want_t sw) { int i; @@ -506,8 +490,7 @@ pkg_state_want_to_str(pkg_state_want_t sw) } } - fprintf(stderr, "%s: ERROR: Illegal value for state_want: %d\n", - __FUNCTION__, sw); + opkg_msg(ERROR, "Internal error: state_want=%d\n", sw); return ""; } @@ -522,8 +505,7 @@ pkg_state_want_from_str(char *str) } } - fprintf(stderr, "%s: ERROR: Illegal value for state_want string: %s\n", - __FUNCTION__, str); + opkg_msg(ERROR, "Internal error: state_want=%s\n", str); return SW_UNKNOWN; } @@ -531,7 +513,7 @@ static char * pkg_state_flag_to_str(pkg_state_flag_t sf) { int i; - int len; + unsigned int len; char *str; /* clear the temporary flags before converting to string */ @@ -567,13 +549,15 @@ pkg_state_flag_from_str(const char *str) { int i; int sf = SF_OK; + const char *sfname; + unsigned int sfname_len; if (strcmp(str, "ok") == 0) { return SF_OK; } for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) { - const char *sfname = pkg_state_flag_map[i].str; - int sfname_len = strlen(sfname); + sfname = pkg_state_flag_map[i].str; + sfname_len = strlen(sfname); if (strncmp(str, sfname, sfname_len) == 0) { sf |= pkg_state_flag_map[i].value; str += sfname_len; @@ -588,7 +572,7 @@ pkg_state_flag_from_str(const char *str) return sf; } -static char * +static const char * pkg_state_status_to_str(pkg_state_status_t ss) { int i; @@ -599,8 +583,7 @@ pkg_state_status_to_str(pkg_state_status_t ss) } } - fprintf(stderr, "%s: ERROR: Illegal value for state_status: %d\n", - __FUNCTION__, ss); + opkg_msg(ERROR, "Internal error: state_status=%d\n", ss); return ""; } @@ -615,8 +598,7 @@ pkg_state_status_from_str(const char *str) } } - fprintf(stderr, "%s: ERROR: Illegal value for state_status string: %s\n", - __FUNCTION__, str); + opkg_msg(ERROR, "Internal error: state_status=%s\n", str); return SS_NOT_INSTALLED; } @@ -660,8 +642,8 @@ pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field) fprintf(fp, "Conffiles:\n"); for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) { if (((conffile_t *)iter->data)->name && ((conffile_t *)iter->data)->value) { - fprintf(fp, " %s %s\n", - ((conffile_t *)iter->data)->name, + fprintf(fp, " %s %s\n", + ((conffile_t *)iter->data)->name, ((conffile_t *)iter->data)->value); } } @@ -723,7 +705,7 @@ pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field) case 'i': case 'I': if (strcasecmp(field, "Installed-Size") == 0) { - fprintf(fp, "Installed-Size: %s\n", pkg->installed_size); + fprintf(fp, "Installed-Size: %ld\n", pkg->installed_size); } else if (strcasecmp(field, "Installed-Time") == 0 && pkg->installed_time) { fprintf(fp, "Installed-Time: %lu\n", pkg->installed_time); } @@ -732,7 +714,7 @@ pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field) case 'M': if (strcasecmp(field, "Maintainer") == 0) { if (pkg->maintainer) { - fprintf(fp, "maintainer: %s\n", pkg->maintainer); + fprintf(fp, "Maintainer: %s\n", pkg->maintainer); } } else if (strcasecmp(field, "MD5sum") == 0) { if (pkg->md5sum) { @@ -749,7 +731,7 @@ pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field) } else if (strcasecmp(field, "Priority") == 0) { fprintf(fp, "Priority: %s\n", pkg->priority); } else if (strcasecmp(field, "Provides") == 0) { - if (pkg->provides_count) { + if (pkg->provides_count > 1) { fprintf(fp, "Provides:"); for(i = 1; i < pkg->provides_count; i++) { fprintf(fp, "%s %s", i == 1 ? "" : ",", @@ -803,7 +785,7 @@ pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field) #endif } else if (strcasecmp(field, "Size") == 0) { if (pkg->size) { - fprintf(fp, "Size: %s\n", pkg->size); + fprintf(fp, "Size: %ld\n", pkg->size); } } else if (strcasecmp(field, "Source") == 0) { if (pkg->source) { @@ -858,7 +840,7 @@ pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field) return; UNKNOWN_FMT_FIELD: - fprintf(stderr, "%s: ERROR: Unknown field name: %s\n", __FUNCTION__, field); + opkg_msg(ERROR, "Internal error: field=%s\n", field); } void @@ -895,26 +877,6 @@ pkg_print_status(pkg_t * pkg, FILE * file) return; } - /* XXX: QUESTION: Do we actually want more fields here? The - original idea was to save space by installing only what was - needed for actual computation, (package, version, status, - essential, conffiles). The assumption is that all other fields - can be found in th available file. - - But, someone proposed the idea to make it possible to - reconstruct a .opk from an installed package, (ie. for beaming - from one handheld to another). So, maybe we actually want a few - more fields here, (depends, suggests, etc.), so that that would - be guaranteed to work even in the absence of more information - from the available file. - - 28-MAR-03: kergoth and I discussed this yesterday. We think - the essential info needs to be here for all installed packages - because they may not appear in the Packages files on various - feeds. Furthermore, one should be able to install from URL or - local storage without requiring a Packages file from any feed. - -Jamey - */ pkg_formatted_field(file, pkg, "Package"); pkg_formatted_field(file, pkg, "Version"); pkg_formatted_field(file, pkg, "Depends"); @@ -1027,7 +989,7 @@ pkg_version_satisfied(pkg_t *it, pkg_t *ref, const char *op) return r == 0; } - fprintf(stderr, "unknown operator: %s", op); + opkg_msg(ERROR, "Unknown operator: %s.\n", op); return 0; } @@ -1039,11 +1001,11 @@ pkg_name_version_and_architecture_compare(const void *p1, const void *p2) int namecmp; int vercmp; if (!a->name || !b->name) { - fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->name=%p b=%p b->name=%p\n", - a, a->name, b, b->name); + opkg_msg(ERROR, "Internal error: a->name=%p, b->name=%p.\n", + a->name, b->name); return 0; } - + namecmp = strcmp(a->name, b->name); if (namecmp) return namecmp; @@ -1051,8 +1013,8 @@ pkg_name_version_and_architecture_compare(const void *p1, const void *p2) if (vercmp) return vercmp; if (!a->arch_priority || !b->arch_priority) { - fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->arch_priority=%i b=%p b->arch_priority=%i\n", - a, a->arch_priority, b, b->arch_priority); + opkg_msg(ERROR, "Internal error: a->arch_priority=%i b->arch_priority=%i.\n", + a->arch_priority, b->arch_priority); return 0; } if (a->arch_priority > b->arch_priority) @@ -1068,8 +1030,8 @@ abstract_pkg_name_compare(const void *p1, const void *p2) const abstract_pkg_t *a = *(const abstract_pkg_t **)p1; const abstract_pkg_t *b = *(const abstract_pkg_t **)p2; if (!a->name || !b->name) { - fprintf(stderr, "abstract_pkg_name_compare: a=%p a->name=%p b=%p b->name=%p\n", - a, a->name, b, b->name); + opkg_msg(ERROR, "Internal error: a->name=%p b->name=%p.\n", + a->name, b->name); return 0; } return strcmp(a->name, b->name); @@ -1103,14 +1065,15 @@ pkg_version_str_alloc(pkg_t *pkg) * XXX: this should be broken into two functions */ str_list_t * -pkg_get_installed_files(opkg_conf_t *conf, pkg_t *pkg) +pkg_get_installed_files(pkg_t *pkg) { int err, fd; char *list_file_name = NULL; FILE *list_file = NULL; char *line; char *installed_file_name; - int rootdirlen = 0; + unsigned int rootdirlen = 0; + int list_from_package; pkg->installed_files_ref_cnt++; @@ -1120,30 +1083,36 @@ pkg_get_installed_files(opkg_conf_t *conf, pkg_t *pkg) pkg->installed_files = str_list_alloc(); - /* For uninstalled packages, get the file list directly from the package. - For installed packages, look at the package.list file in the database. - */ - if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) { + /* + * For installed packages, look at the package.list file in the database. + * For uninstalled packages, get the file list directly from the package. + */ + if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) + list_from_package = 1; + else + list_from_package = 0; + + if (list_from_package) { if (pkg->local_filename == NULL) { return pkg->installed_files; } /* XXX: CLEANUP: Maybe rewrite this to avoid using a temporary file. In other words, change deb_extract so that it can simply return the file list as a char *[] rather than - insisting on writing in to a FILE * as it does now. */ + insisting on writing it to a FILE * as it does now. */ sprintf_alloc(&list_file_name, "%s/%s.list.XXXXXX", conf->tmp_dir, pkg->name); fd = mkstemp(list_file_name); if (fd == -1) { - opkg_message(conf, OPKG_ERROR, "%s: mkstemp(%s): %s", - __FUNCTION__, list_file_name, strerror(errno)); + opkg_perror(ERROR, "Failed to make temp file %s.", + list_file_name); free(list_file_name); return pkg->installed_files; } list_file = fdopen(fd, "r+"); if (list_file == NULL) { - opkg_message(conf, OPKG_ERROR, "%s: fdopen: %s", - __FUNCTION__, strerror(errno)); + opkg_perror(ERROR, "Failed to fdopen temp file %s.", + list_file_name); close(fd); unlink(list_file_name); free(list_file_name); @@ -1151,13 +1120,14 @@ pkg_get_installed_files(opkg_conf_t *conf, pkg_t *pkg) } err = pkg_extract_data_file_names_to_stream(pkg, list_file); if (err) { - opkg_message(conf, OPKG_ERROR, "%s: Error extracting file list " - "from %s: %s\n", __FUNCTION__, - pkg->local_filename, strerror(err)); + opkg_msg(ERROR, "Error extracting file list from %s.\n", + pkg->local_filename); fclose(list_file); unlink(list_file_name); free(list_file_name); - return pkg->installed_files; + str_list_deinit(pkg->installed_files); + pkg->installed_files = NULL; + return NULL; } rewind(list_file); } else { @@ -1165,8 +1135,8 @@ pkg_get_installed_files(opkg_conf_t *conf, pkg_t *pkg) pkg->dest->info_dir, pkg->name); list_file = fopen(list_file_name, "r"); if (list_file == NULL) { - opkg_message(conf, OPKG_ERROR, "%s: fopen(%s): %s\n", - __FUNCTION__, list_file_name, strerror(errno)); + opkg_perror(ERROR, "Failed to open %s", + list_file_name); free(list_file_name); return pkg->installed_files; } @@ -1178,14 +1148,14 @@ pkg_get_installed_files(opkg_conf_t *conf, pkg_t *pkg) while (1) { char *file_name; - + line = file_read_line_alloc(list_file); if (line == NULL) { break; } file_name = line; - if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) { + if (list_from_package) { if (*file_name == '.') { file_name++; } @@ -1211,7 +1181,7 @@ pkg_get_installed_files(opkg_conf_t *conf, pkg_t *pkg) fclose(list_file); - if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) { + if (list_from_package) { unlink(list_file_name); free(list_file_name); } @@ -1240,7 +1210,7 @@ pkg_free_installed_files(pkg_t *pkg) } void -pkg_remove_installed_files_list(opkg_conf_t *conf, pkg_t *pkg) +pkg_remove_installed_files_list(pkg_t *pkg) { char *list_file_name; @@ -1275,8 +1245,7 @@ pkg_get_conffile(pkg_t *pkg, const char *file_name) } int -pkg_run_script(opkg_conf_t *conf, pkg_t *pkg, - const char *script, const char *args) +pkg_run_script(pkg_t *pkg, const char *script, const char *args) { int err; char *path; @@ -1285,52 +1254,33 @@ pkg_run_script(opkg_conf_t *conf, pkg_t *pkg, if (conf->noaction) return 0; - /* XXX: CLEANUP: There must be a better way to handle maintainer - scripts when running with offline_root mode and/or a dest other - than '/'. I've been playing around with some clever chroot - tricks and I might come up with something workable. */ - /* - * Attempt to provide a restricted environment for offline operation - * Need the following set as a minimum: - * OPKG_OFFLINE_ROOT = absolute path to root dir - * D = absolute path to root dir (for OE generated postinst) - * PATH = something safe (a restricted set of utilities) - */ - - if (conf->offline_root) { - if (conf->offline_root_path) { - setenv("PATH", conf->offline_root_path, 1); - } else { - opkg_message(conf, OPKG_NOTICE, - "(offline root mode: not running %s.%s)\n", pkg->name, script); - return 0; - } - setenv("OPKG_OFFLINE_ROOT", conf->offline_root, 1); - setenv("D", conf->offline_root, 1); - } - /* XXX: FEATURE: When conf->offline_root is set, we should run the maintainer script within a chroot environment. */ + if (conf->offline_root && !conf->force_postinstall) { + opkg_msg(INFO, "Offline root mode: not running %s.%s.\n", + pkg->name, script); + return 0; + } /* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages have scripts in pkg->tmp_unpack_dir. */ if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) { if (pkg->dest == NULL) { - fprintf(stderr, "%s: ERROR: installed package %s has a NULL dest\n", - __FUNCTION__, pkg->name); - return EINVAL; + opkg_msg(ERROR, "Internal error: %s has a NULL dest.\n", + pkg->name); + return -1; } sprintf_alloc(&path, "%s/%s.%s", pkg->dest->info_dir, pkg->name, script); } else { if (pkg->tmp_unpack_dir == NULL) { - fprintf(stderr, "%s: ERROR: uninstalled package %s has a NULL tmp_unpack_dir\n", - __FUNCTION__, pkg->name); - return EINVAL; + opkg_msg(ERROR, "Internal error: %s has a NULL tmp_unpack_dir.\n", + pkg->name); + return -1; } sprintf_alloc(&path, "%s/%s", pkg->tmp_unpack_dir, script); } - opkg_message(conf, OPKG_INFO, "Running script %s\n", path); + opkg_msg(INFO, "Running script %s.\n", path); setenv("PKG_ROOT", pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir, 1); @@ -1349,7 +1299,8 @@ pkg_run_script(opkg_conf_t *conf, pkg_t *pkg, free(cmd); if (err) { - fprintf(stderr, "%s script returned status %d\n", script, err); + opkg_msg(ERROR, "package \"%s\" %s script returned status %d.\n", + pkg->name, script, err); return err; } @@ -1357,7 +1308,7 @@ pkg_run_script(opkg_conf_t *conf, pkg_t *pkg, } int -pkg_arch_supported(opkg_conf_t *conf, pkg_t *pkg) +pkg_arch_supported(pkg_t *pkg) { nv_pair_list_elt_t *l; @@ -1367,84 +1318,40 @@ pkg_arch_supported(opkg_conf_t *conf, pkg_t *pkg) list_for_each_entry(l , &conf->arch_list.head, node) { nv_pair_t *nv = (nv_pair_t *)l->data; if (strcmp(nv->name, pkg->architecture) == 0) { - opkg_message(conf, OPKG_DEBUG, "arch %s (priority %s) supported for pkg %s\n", nv->name, nv->value, pkg->name); + opkg_msg(DEBUG, "Arch %s (priority %s) supported for pkg %s.\n", + nv->name, nv->value, pkg->name); return 1; } } - opkg_message(conf, OPKG_DEBUG, "arch %s unsupported for pkg %s\n", pkg->architecture, pkg->name); - return 0; -} - -int -pkg_get_arch_priority(opkg_conf_t *conf, const char *archname) -{ - nv_pair_list_elt_t *l; - - list_for_each_entry(l , &conf->arch_list.head, node) { - nv_pair_t *nv = (nv_pair_t *)l->data; - if (strcmp(nv->name, archname) == 0) { - int priority = strtol(nv->value, NULL, 0); - return priority; - } - } + opkg_msg(DEBUG, "Arch %s unsupported for pkg %s.\n", + pkg->architecture, pkg->name); return 0; } void -pkg_info_preinstall_check(opkg_conf_t *conf) +pkg_info_preinstall_check(void) { int i; - hash_table_t *pkg_hash = &conf->pkg_hash; - pkg_vec_t *available_pkgs = pkg_vec_alloc(); pkg_vec_t *installed_pkgs = pkg_vec_alloc(); - opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: updating arch priority for each package\n"); - pkg_hash_fetch_available(pkg_hash, available_pkgs); - /* update arch_priority for each package */ - for (i = 0; i < available_pkgs->len; i++) { - pkg_t *pkg = available_pkgs->pkgs[i]; - int arch_priority = 1; - if (!pkg) - continue; - // opkg_message(conf, OPKG_DEBUG2, " package %s version=%s arch=%p:", pkg->name, pkg->version, pkg->architecture); - if (pkg->architecture) - arch_priority = pkg_get_arch_priority(conf, pkg->architecture); - else - opkg_message(conf, OPKG_ERROR, "pkg_info_preinstall_check: no architecture for package %s\n", pkg->name); - // opkg_message(conf, OPKG_DEBUG2, "%s arch_priority=%d\n", pkg->architecture, arch_priority); - pkg->arch_priority = arch_priority; - } - - for (i = 0; i < available_pkgs->len; i++) { - pkg_t *pkg = available_pkgs->pkgs[i]; - if (!pkg->arch_priority && (pkg->state_flag || (pkg->state_want != SW_UNKNOWN))) { - /* clear flags and want for any uninstallable package */ - opkg_message(conf, OPKG_DEBUG, "Clearing state_want and state_flag for pkg=%s (arch_priority=%d flag=%d want=%d)\n", - pkg->name, pkg->arch_priority, pkg->state_flag, pkg->state_want); - pkg->state_want = SW_UNKNOWN; - pkg->state_flag = 0; - } - } - pkg_vec_free(available_pkgs); - /* update the file owner data structure */ - opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: update file owner list\n"); - pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs); + opkg_msg(INFO, "Updating file owner list.\n"); + pkg_hash_fetch_all_installed(installed_pkgs); for (i = 0; i < installed_pkgs->len; i++) { pkg_t *pkg = installed_pkgs->pkgs[i]; - str_list_t *installed_files = pkg_get_installed_files(conf, pkg); /* this causes installed_files to be cached */ + str_list_t *installed_files = pkg_get_installed_files(pkg); /* this causes installed_files to be cached */ str_list_elt_t *iter, *niter; if (installed_files == NULL) { - opkg_message(conf, OPKG_ERROR, "No installed files for pkg %s\n", pkg->name); + opkg_msg(ERROR, "Failed to determine installed " + "files for pkg %s.\n", pkg->name); break; } - for (iter = str_list_first(installed_files), niter = str_list_next(installed_files, iter); - iter; + for (iter = str_list_first(installed_files), niter = str_list_next(installed_files, iter); + iter; iter = niter, niter = str_list_next(installed_files, iter)) { char *installed_file = (char *) iter->data; - // opkg_message(conf, OPKG_DEBUG2, "pkg %s: file=%s\n", pkg->name, installed_file); - file_hash_set_file_owner(conf, installed_file, pkg); + file_hash_set_file_owner(installed_file, pkg); } pkg_free_installed_files(pkg); } @@ -1452,12 +1359,11 @@ pkg_info_preinstall_check(opkg_conf_t *conf) } struct pkg_write_filelist_data { - opkg_conf_t *conf; pkg_t *pkg; FILE *stream; }; -void +static void pkg_write_filelist_helper(const char *key, void *entry_, void *data_) { struct pkg_write_filelist_data *data = data_; @@ -1468,7 +1374,7 @@ pkg_write_filelist_helper(const char *key, void *entry_, void *data_) } int -pkg_write_filelist(opkg_conf_t *conf, pkg_t *pkg) +pkg_write_filelist(pkg_t *pkg) { struct pkg_write_filelist_data data; char *list_file_name; @@ -1476,19 +1382,18 @@ pkg_write_filelist(opkg_conf_t *conf, pkg_t *pkg) sprintf_alloc(&list_file_name, "%s/%s.list", pkg->dest->info_dir, pkg->name); - opkg_message(conf, OPKG_INFO, "%s: creating %s file for pkg %s\n", - __FUNCTION__, list_file_name, pkg->name); + opkg_msg(INFO, "Creating %s file for pkg %s.\n", + list_file_name, pkg->name); data.stream = fopen(list_file_name, "w"); if (!data.stream) { - opkg_message(conf, OPKG_ERROR, "%s: fopen(%s, \"w\"): %s\n", - __FUNCTION__, list_file_name, strerror(errno)); + opkg_perror(ERROR, "Failed to open %s", + list_file_name); free(list_file_name); return -1; } data.pkg = pkg; - data.conf = conf; hash_table_foreach(&conf->file_hash, pkg_write_filelist_helper, &data); fclose(data.stream); free(list_file_name); @@ -1499,23 +1404,21 @@ pkg_write_filelist(opkg_conf_t *conf, pkg_t *pkg) } int -pkg_write_changed_filelists(opkg_conf_t *conf) +pkg_write_changed_filelists(void) { pkg_vec_t *installed_pkgs = pkg_vec_alloc(); - hash_table_t *pkg_hash = &conf->pkg_hash; int i, err, ret = 0; if (conf->noaction) return 0; - opkg_message(conf, OPKG_INFO, "%s: saving changed filelists\n", - __FUNCTION__); + opkg_msg(INFO, "Saving changed filelists.\n"); - pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs); + pkg_hash_fetch_all_installed(installed_pkgs); for (i = 0; i < installed_pkgs->len; i++) { pkg_t *pkg = installed_pkgs->pkgs[i]; if (pkg->state_flag & SF_FILELIST_CHANGED) { - err = pkg_write_filelist(conf, pkg); + err = pkg_write_filelist(pkg); if (err) ret = -1; }