#include "opkg_conf.h"
#include "opkg_cmd.h"
#include "opkg_message.h"
+#include "release.h"
#include "pkg.h"
#include "pkg_dest.h"
#include "pkg_parse.h"
opkg_msg(INFO, "Writing status file.\n");
opkg_conf_write_status_files();
pkg_write_changed_filelists();
- } else {
+ } else {
opkg_msg(DEBUG, "Nothing to be done.\n");
}
}
pkg_src_list_elt_t *iter;
pkg_src_t *src;
-
+
sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir);
-
+
if (! file_is_dir(lists_dir)) {
if (file_exists(lists_dir)) {
opkg_msg(ERROR, "%s exists, but is not a directory.\n",
if (err) {
free(lists_dir);
return -1;
- }
- }
+ }
+ }
failures = 0;
}
+ for (iter = void_list_first(&conf->dist_src_list); iter; iter = void_list_next(&conf->dist_src_list, iter)) {
+ char *url, *list_file_name;
+
+ src = (pkg_src_t *)iter->data;
+
+ sprintf_alloc(&url, "%s/dists/%s/Release", src->value, src->name);
+
+ sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
+ err = opkg_download(url, list_file_name, NULL, NULL, 0);
+ if (!err) {
+ opkg_msg(NOTICE, "Downloaded release files for dist %s.\n",
+ src->name);
+ release_t *release = release_new();
+ err = release_init_from_file(release, list_file_name);
+ if (!err) {
+ if (!release_comps_supported(release, src->extra_data))
+ err = -1;
+ }
+ if (!err) {
+ err = release_download(release, src, lists_dir, tmp);
+ }
+ release_deinit(release);
+ if (err)
+ unlink(list_file_name);
+ }
+
+ if (err)
+ failures++;
+
+ free(list_file_name);
+ free(url);
+ }
+
for (iter = void_list_first(&conf->pkg_src_list); iter; iter = void_list_next(&conf->pkg_src_list, iter)) {
char *url, *list_file_name;
src = (pkg_src_t *)iter->data;
+ if (src->extra_data && strcmp(src->extra_data, "__dummy__ "))
+ continue;
+
if (src->extra_data) /* debian style? */
- sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
+ sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
src->gzip ? "Packages.gz" : "Packages");
else
sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages");
if (src->gzip) {
char *tmp_file_name;
FILE *in, *out;
-
+
sprintf_alloc (&tmp_file_name, "%s/%s.gz", tmp, src->name);
- err = opkg_download(url, tmp_file_name, NULL, NULL);
+ err = opkg_download(url, tmp_file_name, NULL, NULL, 0);
if (err == 0) {
opkg_msg(NOTICE, "Inflating %s.\n", url);
in = fopen (tmp_file_name, "r");
}
free(tmp_file_name);
} else
- err = opkg_download(url, list_file_name, NULL, NULL);
+ err = opkg_download(url, list_file_name, NULL, NULL, 0);
if (err) {
failures++;
} else {
/* Put the signature in the right place */
sprintf_alloc (&tmp_file_name, "%s/%s.sig", lists_dir, src->name);
- err = opkg_download(url, tmp_file_name, NULL, NULL);
+ err = opkg_download(url, tmp_file_name, NULL, NULL, 0);
if (err) {
failures++;
opkg_msg(NOTICE, "Signature check failed.\n");
else
opkg_msg(NOTICE, "Signature check failed.\n");
}
+ if (err) {
+ /* The signature was wrong so delete it */
+ opkg_msg(NOTICE, "Remove wrong Signature file.\n");
+ unlink (tmp_file_name);
+ unlink (list_file_name);
+ }
/* We shouldn't unlink the signature ! */
// unlink (tmp_file_name);
free (tmp_file_name);
if (de->d_name[0] == '.')
continue;
-
+
sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
if (access (path, X_OK) == 0) {
const char *argv[] = {"sh", "-c", path, NULL};
closedir(dir);
} else
opkg_perror(ERROR, "Failed to open dir %s", ctx->statedir);
-
+
rm_r(ctx->statedir);
free (ctx->statedir);
free (ctx);
}
/* For package pkg do the following: If it is already visited, return. If not,
- add it in visited list and recurse to its deps. Finally, add it to ordered
+ add it in visited list and recurse to its deps. Finally, add it to ordered
list.
pkg_vec all contains all available packages in repos.
- pkg_vec visited contains packages already visited by this function, and is
+ pkg_vec visited contains packages already visited by this function, and is
used to end recursion and avoid an infinite loop on graph cycles.
pkg_vec ordered will finally contain the ordered set of packages.
*/
/* If it's just an available package, that is, not installed and not even
unpacked, skip it */
- /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
- would do here. However, if there is an intermediate node (pkg) that is
- configured and installed between two unpacked packages, the latter
+ /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
+ would do here. However, if there is an intermediate node (pkg) that is
+ configured and installed between two unpacked packages, the latter
won't be properly reordered, unless all installed/unpacked pkgs are
checked */
- if (pkg->state_status == SS_NOT_INSTALLED)
+ if (pkg->state_status == SS_NOT_INSTALLED)
return 0;
/* If the package has already been visited (by this function), skip it */
- for(j = 0; j < visited->len; j++)
+ for(j = 0; j < visited->len; j++)
if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) {
opkg_msg(DEBUG, "pkg %s already visited, skipping.\n", pkg->name);
return 0;
}
-
+
pkg_vec_insert(visited, pkg);
count = pkg->pre_depends_count + pkg->depends_count + \
opkg_msg(DEBUG, "pkg %s.\n", pkg->name);
- /* Iterate over all the dependencies of pkg. For each one, find a package
+ /* Iterate over all the dependencies of pkg. For each one, find a package
that is either installed or unpacked and satisfies this dependency.
- (there should only be one such package per dependency installed or
+ (there should only be one such package per dependency installed or
unpacked). Then recurse to the dependency package */
for (j=0; j < count ; j++) {
compound_depend = &pkg->depends[j];
l = 0;
if (dependents != NULL)
while (l < abpkg->provided_by->len && dependents[l] != NULL) {
- opkg_msg(DEBUG, "Descending on pkg %s.\n",
+ opkg_msg(DEBUG, "Descending on pkg %s.\n",
dependents [l]->name);
-
+
/* find whether dependent l is installed or unpacked,
* and then find which package in the list satisfies it */
for(m = 0; m < all->len; m++) {
dep = all->pkgs[m];
if ( dep->state_status != SS_NOT_INSTALLED)
if ( ! strcmp(dep->name, dependents[l]->name)) {
- opkg_recurse_pkgs_in_order(dep, all,
+ opkg_recurse_pkgs_in_order(dep, all,
visited, ordered);
/* Stop the outer loop */
l = abpkg->provided_by->len;
}
}
- /* When all recursions from this node down, are over, and all
+ /* When all recursions from this node down, are over, and all
dependencies have been added in proper order in the ordered array, add
also the package pkg to ordered array */
pkg_vec_insert(ordered, pkg);
err = -1;
goto error;
}
-
+
for(i = 0; i < ordered->len; i++) {
pkg = ordered->pkgs[i];
- if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
+ if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
continue;
if (pkg->state_status == SS_UNPACKED) {
for (i=0; i < argc; i++) {
arg = argv[i];
- if (opkg_install_by_name(arg) != 0) {
+ if (opkg_install_by_name(arg)) {
opkg_msg(ERROR, "Cannot install package %s.\n", arg);
err = -1;
}
}
- if (opkg_configure_packages(NULL) != 0)
+ if (opkg_configure_packages(NULL))
err = -1;
write_status_files_if_changed();
err = -1;
}
}
- } else {
- pkg_vec_t *installed = pkg_vec_alloc();
-
- pkg_info_preinstall_check();
-
- pkg_hash_fetch_all_installed(installed);
- for (i = 0; i < installed->len; i++) {
- pkg = installed->pkgs[i];
- if (opkg_upgrade_pkg(pkg))
- err = -1;
- }
- pkg_vec_free(installed);
}
if (opkg_configure_packages(NULL))
for (i=0; i < available->len; i++) {
pkg = available->pkgs[i];
/* if we have package name or pattern and pkg does not match, then skip it */
- if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
+ if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
continue;
print_pkg(pkg);
}
for (i=0; i < available->len; i++) {
pkg = available->pkgs[i];
/* if we have package name or pattern and pkg does not match, then skip it */
- if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
+ if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
continue;
print_pkg(pkg);
}
return 0;
}
+static int
+opkg_list_changed_conffiles_cmd(int argc, char **argv)
+{
+ int i ;
+ pkg_vec_t *available;
+ pkg_t *pkg;
+ char *pkg_name = NULL;
+ conffile_list_elt_t *iter;
+ conffile_t *cf;
+
+ if (argc > 0) {
+ pkg_name = argv[0];
+ }
+ available = pkg_vec_alloc();
+ pkg_hash_fetch_all_installed(available);
+ pkg_vec_sort(available, pkg_compare_names);
+ for (i=0; i < available->len; i++) {
+ pkg = available->pkgs[i];
+ /* if we have package name or pattern and pkg does not match, then skip it */
+ if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
+ continue;
+ if (nv_pair_list_empty(&pkg->conffiles))
+ continue;
+ for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
+ cf = (conffile_t *)iter->data;
+ if (cf->name && cf->value && conffile_has_been_modified(cf))
+ printf("%s\n", cf->name);
+ }
+ }
+ pkg_vec_free(available);
+ return 0;
+}
+
static int
opkg_list_upgradable_cmd(int argc, char **argv)
{
} else {
pkg_to_remove = pkg_hash_fetch_installed_by_name(pkg->name);
}
-
+
if (pkg_to_remove == NULL) {
opkg_msg(ERROR, "Package %s is not installed.\n", pkg->name);
continue;
int i;
pkg_t *pkg;
const char *flags = argv[0];
-
+
signal(SIGINT, sigint_handler);
for (i=1; i < argc; i++) {
pkg->state_flag = pkg_state_flag_from_str(flags);
}
- /*
+ /*
* Useful if a package is installed in an offline_root, and
* should be configured by opkg-cl configure at a later date.
*/
case RECOMMEND: rel_str = "recommends"; break;
default: return -1;
}
-
+
available_pkgs = pkg_vec_alloc();
if (conf->query_all)
& SF_MARKED)
!= SF_MARKED)
continue;
-
+
/* mark the depending package so we
* won't visit it again */
pkg->state_flag |= SF_MARKED;
pkg_mark_provides(pkg);
changed++;
- ver = pkg_version_str_alloc(pkg);
+ ver = pkg_version_str_alloc(pkg);
opkg_msg(NOTICE, "\t%s %s\t%s %s",
pkg->name,
ver,
if (!pkg_dependence_satisfiable(possibility))
opkg_msg(NOTICE,
" unsatisfiable");
- opkg_msg(NOTICE, "\n");
+ opkg_message(NOTICE, "\n");
goto next_package;
}
}
pkg_vec_t *available_pkgs = pkg_vec_alloc();
const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
int i;
-
+
pkg_info_preinstall_check();
if (conf->query_all)
int k;
int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
for (k = 0; k < count; k++) {
- abstract_pkg_t *apkg =
- ((what_field_type == WHATPROVIDES)
+ abstract_pkg_t *apkg =
+ ((what_field_type == WHATPROVIDES)
? pkg->provides[k]
: pkg->replaces[k]);
if (fnmatch(target, apkg->name, 0) == 0) {
if (strcmp(target, apkg->name) != 0)
opkg_msg(NOTICE, "\t%s %s\n",
rel_str, apkg->name);
- opkg_msg(NOTICE, "\n");
+ opkg_message(NOTICE, "\n");
}
}
}
if (argc < 1) {
return -1;
}
-
+
installed = pkg_vec_alloc();
pkg_hash_fetch_all_installed(installed);
pkg_vec_sort(installed, pkg_compare_names);
if (argc == 3) {
/* this is a bit gross */
struct pkg p1, p2;
- parse_version(&p1, argv[0]);
- parse_version(&p2, argv[2]);
+ parse_version(&p1, argv[0]);
+ parse_version(&p2, argv[2]);
return pkg_version_satisfied(&p1, &p2, argv[1]);
} else {
opkg_msg(ERROR,
array for easier maintenance */
static opkg_cmd_t cmds[] = {
{"update", 0, (opkg_cmd_fun_t)opkg_update_cmd, PFM_DESCRIPTION|PFM_SOURCE},
- {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd, PFM_DESCRIPTION|PFM_SOURCE},
+ {"upgrade", 1, (opkg_cmd_fun_t)opkg_upgrade_cmd, PFM_DESCRIPTION|PFM_SOURCE},
{"list", 0, (opkg_cmd_fun_t)opkg_list_cmd, PFM_SOURCE},
{"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd, PFM_SOURCE},
{"list-installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd, PFM_SOURCE},
{"list_upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd, PFM_SOURCE},
{"list-upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd, PFM_SOURCE},
+ {"list_changed_conffiles", 0, (opkg_cmd_fun_t)opkg_list_changed_conffiles_cmd, PFM_SOURCE},
+ {"list-changed-conffiles", 0, (opkg_cmd_fun_t)opkg_list_changed_conffiles_cmd, PFM_SOURCE},
{"info", 0, (opkg_cmd_fun_t)opkg_info_cmd, 0},
{"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd, PFM_DESCRIPTION|PFM_SOURCE},
{"status", 0, (opkg_cmd_fun_t)opkg_status_cmd, PFM_DESCRIPTION|PFM_SOURCE},