#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");
sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
- 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);
- if (err == 0) {
- opkg_msg(NOTICE, "Inflating %s.\n", url);
- in = fopen (tmp_file_name, "r");
- out = fopen (list_file_name, "w");
- if (in && out)
- unzip (in, out);
- else
- err = 1;
- if (in)
- fclose (in);
- if (out)
- fclose (out);
- unlink (tmp_file_name);
- }
- free(tmp_file_name);
- } else
- err = opkg_download(url, list_file_name, NULL, NULL);
- if (err) {
+ if (opkg_download(url, list_file_name, NULL, NULL, 0)) {
failures++;
} else {
opkg_msg(NOTICE, "Updated list of available packages in %s.\n",
list_file_name);
}
free(url);
-#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
+#if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) || defined(HAVE_USIGN)
if (conf->check_signature) {
/* download detached signitures to verify the package lists */
/* get the url for the sig file */
/* 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 < all->len; i++) {
- pkg = all->pkgs[i];
- if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
+ for(i = 0; i < ordered->len; i++) {
+ pkg = ordered->pkgs[i];
+
+ if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase))
continue;
if (pkg->state_status == SS_UNPACKED) {
pkg->state_flag &= ~SF_PREFER;
opkg_state_changed++;
} else {
- if (!err)
- err = r;
+ err = -1;
}
}
}
- r = opkg_finalize_intercepts (ic);
- if (r && !err)
- err = r;
+ if (opkg_finalize_intercepts (ic))
+ err = -1;
error:
pkg_vec_free(all);
return err;
}
+static int
+opkg_remove_cmd(int argc, char **argv);
+
static int
opkg_install_cmd(int argc, char **argv)
{
int i;
char *arg;
- int err=0;
+ int err = 0;
+
+ if (conf->force_reinstall) {
+ int saved_force_depends = conf->force_depends;
+ conf->force_depends = 1;
+ (void)opkg_remove_cmd(argc, argv);
+ conf->force_depends = saved_force_depends;
+ conf->force_reinstall = 0;
+ }
signal(SIGINT, sigint_handler);
arg = argv[i];
opkg_msg(DEBUG2, "%s\n", arg);
- err = opkg_prepare_url_for_install(arg, &argv[i]);
- if (err)
- return err;
+ if (opkg_prepare_url_for_install(arg, &argv[i]))
+ return -1;
}
pkg_info_preinstall_check();
for (i=0; i < argc; i++) {
arg = argv[i];
- err = opkg_install_by_name(arg);
- if (err) {
+ if (opkg_install_by_name(arg)) {
opkg_msg(ERROR, "Cannot install package %s.\n", arg);
+ err = -1;
}
}
- opkg_configure_packages(NULL);
+ if (opkg_configure_packages(NULL))
+ err = -1;
write_status_files_if_changed();
{
int i;
pkg_t *pkg;
- int err;
+ int err = 0;
signal(SIGINT, sigint_handler);
for (i=0; i < argc; i++) {
char *arg = argv[i];
- err = opkg_prepare_url_for_install(arg, &arg);
- if (err)
- return err;
+ if (opkg_prepare_url_for_install(arg, &arg))
+ return -1;
}
pkg_info_preinstall_check();
} else {
pkg = pkg_hash_fetch_installed_by_name(argv[i]);
}
- if (pkg)
- opkg_upgrade_pkg(pkg);
- else {
- opkg_install_by_name(arg);
+ if (pkg) {
+ if (opkg_upgrade_pkg(pkg))
+ err = -1;
+ } else {
+ if (opkg_install_by_name(arg))
+ 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];
- opkg_upgrade_pkg(pkg);
- }
- pkg_vec_free(installed);
}
- opkg_configure_packages(NULL);
+ if (opkg_configure_packages(NULL))
+ err = -1;
write_status_files_if_changed();
- return 0;
+ return err;
}
static int
opkg_download_cmd(int argc, char **argv)
{
- int i, err;
+ int i, err = 0;
char *arg;
pkg_t *pkg;
continue;
}
- err = opkg_download_pkg(pkg, ".");
+ if (opkg_download_pkg(pkg, "."))
+ err = -1;
if (err) {
opkg_msg(ERROR, "Failed to download %s.\n", pkg->name);
}
}
- return 0;
+ return err;
}
static int
-opkg_list_cmd(int argc, char **argv)
+opkg_list_find_cmd(int argc, char **argv, int use_desc)
{
int i;
pkg_vec_t *available;
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, conf->nocase) &&
+ (!use_desc || !pkg->description || fnmatch(pkg_name, pkg->description, conf->nocase)))
continue;
print_pkg(pkg);
}
return 0;
}
+static int
+opkg_list_cmd(int argc, char **argv)
+{
+ return opkg_list_find_cmd(argc, argv, 0);
+}
+
+static int
+opkg_find_cmd(int argc, char **argv)
+{
+ return opkg_list_find_cmd(argc, argv, 1);
+}
+
static int
opkg_list_installed_cmd(int argc, char **argv)
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, conf->nocase))
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, conf->nocase))
+ 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)
{
for (i=0; i < available->len; i++) {
pkg = available->pkgs[i];
- if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
+ if (pkg_name && fnmatch(pkg_name, pkg->name, conf->nocase)) {
continue;
}
static int
opkg_remove_cmd(int argc, char **argv)
{
- int i, a, done;
+ int i, a, done, err = 0;
pkg_t *pkg;
pkg_t *pkg_to_remove;
pkg_vec_t *available;
for (i=0; i<argc; i++) {
for (a=0; a<available->len; a++) {
pkg = available->pkgs[a];
- if (fnmatch(argv[i], pkg->name, 0)) {
+ if (fnmatch(argv[i], pkg->name, conf->nocase)) {
continue;
}
if (conf->restrict_to_default_dest) {
} 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;
}
- if (pkg->state_status == SS_NOT_INSTALLED) { // Added the control, so every already removed package could be skipped
+ if (pkg->state_status == SS_NOT_INSTALLED) {
opkg_msg(ERROR, "Package %s not installed.\n", pkg->name);
continue;
}
- opkg_remove_pkg(pkg_to_remove, 0);
- done = 1;
+
+ if (opkg_remove_pkg(pkg_to_remove, 0))
+ err = -1;
+ else
+ done = 1;
}
}
opkg_msg(NOTICE, "No packages removed.\n");
write_status_files_if_changed();
- return 0;
+ return err;
}
static int
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.
*/
for (j=0; j<available_pkgs->len; j++) {
pkg = available_pkgs->pkgs[j];
- if (fnmatch(argv[i], pkg->name, 0) != 0)
+ if (fnmatch(argv[i], pkg->name, conf->nocase) != 0)
continue;
depends_count = pkg->depends_count +
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 (fnmatch(target, apkg->name, conf->nocase) == 0) {
opkg_msg(NOTICE, " %s", pkg->name);
- if (strcmp(target, apkg->name) != 0)
+ if ((conf->nocase ? strcasecmp(target, apkg->name) : 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);
for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
installed_file = (char *)iter->data;
- if (fnmatch(argv[0], installed_file, 0)==0)
+ if (fnmatch(argv[0], installed_file, conf->nocase)==0)
print_pkg(pkg);
}
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},
{"configure", 0, (opkg_cmd_fun_t)opkg_configure_cmd, PFM_DESCRIPTION|PFM_SOURCE},
{"files", 1, (opkg_cmd_fun_t)opkg_files_cmd, PFM_DESCRIPTION|PFM_SOURCE},
{"search", 1, (opkg_cmd_fun_t)opkg_search_cmd, PFM_DESCRIPTION|PFM_SOURCE},
+ {"find", 1, (opkg_cmd_fun_t)opkg_find_cmd, PFM_SOURCE},
{"download", 1, (opkg_cmd_fun_t)opkg_download_cmd, PFM_DESCRIPTION|PFM_SOURCE},
{"compare_versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd, PFM_DESCRIPTION|PFM_SOURCE},
{"compare-versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd, PFM_DESCRIPTION|PFM_SOURCE},