1 /* opkg_cmd.c - the itsy package management system
5 Copyright (C) 2001 University of Southern California
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 2, or (at
10 your option) any later version.
12 This program is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 General Public License for more details.
30 #include "opkg_conf.h"
32 #include "opkg_message.h"
35 #include "pkg_parse.h"
36 #include "sprintf_alloc.h"
38 #include "file_util.h"
40 #include "libbb/libbb.h"
45 #include "opkg_download.h"
46 #include "opkg_install.h"
47 #include "opkg_upgrade.h"
48 #include "opkg_remove.h"
49 #include "opkg_configure.h"
50 #include "opkg_message.h"
54 static void *p_userdata = NULL;
57 static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv);
58 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv);
59 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv);
60 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv);
61 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv);
62 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv);
63 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv);
64 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv);
65 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv);
66 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv);
67 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv);
68 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv);
69 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv);
70 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv);
71 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv);
72 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv);
73 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv);
74 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv);
75 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv);
76 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv);
77 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv);
78 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv);
79 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv);
80 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv);
81 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv);
83 /* XXX: CLEANUP: The usage strings should be incorporated into this
84 array for easier maintenance */
85 static opkg_cmd_t cmds[] = {
86 {"update", 0, (opkg_cmd_fun_t)opkg_update_cmd},
87 {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd},
88 {"list", 0, (opkg_cmd_fun_t)opkg_list_cmd},
89 {"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd},
90 {"info", 0, (opkg_cmd_fun_t)opkg_info_cmd},
91 {"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd},
92 {"status", 0, (opkg_cmd_fun_t)opkg_status_cmd},
93 {"install_pending", 0, (opkg_cmd_fun_t)opkg_install_pending_cmd},
94 {"install", 1, (opkg_cmd_fun_t)opkg_install_cmd},
95 {"remove", 1, (opkg_cmd_fun_t)opkg_remove_cmd},
96 {"purge", 1, (opkg_cmd_fun_t)opkg_purge_cmd},
97 {"configure", 0, (opkg_cmd_fun_t)opkg_configure_cmd},
98 {"files", 1, (opkg_cmd_fun_t)opkg_files_cmd},
99 {"search", 1, (opkg_cmd_fun_t)opkg_search_cmd},
100 {"download", 1, (opkg_cmd_fun_t)opkg_download_cmd},
101 {"compare_versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd},
102 {"compare-versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd},
103 {"print-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
104 {"print_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
105 {"print-installation-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
106 {"print_installation_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
107 {"depends", 1, (opkg_cmd_fun_t)opkg_depends_cmd},
108 {"whatdepends", 1, (opkg_cmd_fun_t)opkg_whatdepends_cmd},
109 {"whatdependsrec", 1, (opkg_cmd_fun_t)opkg_whatdepends_recursively_cmd},
110 {"whatrecommends", 1, (opkg_cmd_fun_t)opkg_whatrecommends_cmd},
111 {"whatsuggests", 1, (opkg_cmd_fun_t)opkg_whatsuggests_cmd},
112 {"whatprovides", 1, (opkg_cmd_fun_t)opkg_whatprovides_cmd},
113 {"whatreplaces", 1, (opkg_cmd_fun_t)opkg_whatreplaces_cmd},
114 {"whatconflicts", 1, (opkg_cmd_fun_t)opkg_whatconflicts_cmd},
117 int opkg_state_changed;
118 static void write_status_files_if_changed(opkg_conf_t *conf)
120 if (opkg_state_changed && !conf->noaction) {
121 opkg_message(conf, OPKG_INFO,
122 " writing status file\n");
123 opkg_conf_write_status_files(conf);
124 pkg_write_changed_filelists(conf);
126 opkg_message(conf, OPKG_NOTICE, "Nothing to be done\n");
131 static int num_cmds = sizeof(cmds) / sizeof(opkg_cmd_t);
133 opkg_cmd_t *opkg_cmd_find(const char *name)
138 for (i=0; i < num_cmds; i++) {
140 if (strcmp(name, cmd->name) == 0) {
149 int opkg_cmd_exec(opkg_cmd_t *cmd, opkg_conf_t *conf, int argc, const char **argv, void *userdata)
152 p_userdata = userdata;
155 result = (cmd->fun)(conf, argc, argv);
158 opkg_message(conf, OPKG_NOTICE, "An error ocurred, return value: %d.\n", result);
162 reverse_error_list(&error_list);
164 opkg_message(conf, OPKG_NOTICE, "Collected errors:\n");
165 /* Here we print the errors collected and free the list */
166 while (error_list != NULL) {
167 opkg_message(conf, OPKG_NOTICE, "%s",error_list->errmsg);
168 error_list = error_list->next;
171 free_error_list(&error_list);
179 int opkg_cmd_exec(opkg_cmd_t *cmd, opkg_conf_t *conf, int argc, const char **argv)
181 return (cmd->fun)(conf, argc, argv);
185 static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv)
190 pkg_src_list_elt_t *iter;
194 sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir);
196 if (! file_is_dir(lists_dir)) {
197 if (file_exists(lists_dir)) {
198 opkg_message(conf, OPKG_ERROR,
199 "%s: ERROR: %s exists, but is not a directory\n",
200 __FUNCTION__, lists_dir);
204 err = file_mkdir_hier(lists_dir, 0755);
206 opkg_message(conf, OPKG_ERROR,
207 "%s: ERROR: failed to make directory %s: %s\n",
208 __FUNCTION__, lists_dir, strerror(errno));
215 for (iter = conf->pkg_src_list.head; iter; iter = iter->next) {
216 char *url, *list_file_name;
220 if (src->extra_data) /* debian style? */
221 sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
222 src->gzip ? "Packages.gz" : "Packages");
224 sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages");
226 sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
232 tmp = strdup ("/tmp/opkg.XXXXXX");
234 if (mkdtemp (tmp) == NULL) {
240 sprintf_alloc (&tmp_file_name, "%s/%s.gz", tmp, src->name);
241 err = opkg_download(conf, url, tmp_file_name);
243 opkg_message (conf, OPKG_NOTICE, "Inflating %s\n", url);
244 in = fopen (tmp_file_name, "r");
245 out = fopen (list_file_name, "w");
254 unlink (tmp_file_name);
259 err = opkg_download(conf, url, list_file_name);
263 opkg_message(conf, OPKG_NOTICE,
264 "Updated list of available packages in %s\n",
268 free(list_file_name);
272 #ifdef CONFIG_CLEAR_SW_INSTALL_FLAG
274 /* clear SW_INSTALL on any package where state is SS_NOT_INSTALLED.
275 * this is a hack to work around poor bookkeeping in old opkg upgrade code
281 pkg_vec_t *available = pkg_vec_alloc();
282 pkg_hash_fetch_available(&conf->pkg_hash, available);
283 opkg_message(conf, OPKG_DEBUG, "Clearing SW_INSTALL for SS_NOT_INSTALLED packages.\n");
284 for (i = 0; i < available->len; i++) {
285 pkg_t *pkg = available->pkgs[i];
286 if (pkg->state_want == SW_INSTALL && pkg->state_status == SS_NOT_INSTALLED) {
287 opkg_message(conf, OPKG_DEBUG, "Clearing SW_INSTALL on package %s.\n", pkg->name);
288 pkg->state_want = SW_UNKNOWN;
292 pkg_vec_free(available);
294 write_status_files_if_changed(conf);
303 /* scan the args passed and cache the local filenames of the packages */
304 int opkg_multiple_files_scan(opkg_conf_t *conf, int argc, char **argv)
310 * First scan through package names/urls
311 * For any urls, download the packages and install in database.
312 * For any files, install package info in database.
314 for (i = 0; i < argc; i ++) {
315 char *filename = argv [i];
316 //char *tmp = basename (tmp);
317 //int tmplen = strlen (tmp);
319 //if (strcmp (tmp + (tmplen - strlen (OPKG_PKG_EXTENSION)), OPKG_PKG_EXTENSION) != 0)
321 //if (strcmp (tmp + (tmplen - strlen (DPKG_PKG_EXTENSION)), DPKG_PKG_EXTENSION) != 0)
324 opkg_message(conf, OPKG_DEBUG2, "Debug mfs: %s \n",filename );
326 err = opkg_prepare_url_for_install(conf, filename, &argv[i]);
333 struct opkg_intercept
339 typedef struct opkg_intercept *opkg_intercept_t;
341 opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf)
343 opkg_intercept_t ctx;
347 ctx = malloc (sizeof (*ctx));
348 ctx->oldpath = strdup (getenv ("PATH"));
350 sprintf_alloc (&newpath, "%s/opkg/intercept:%s", DATADIR, ctx->oldpath);
351 setenv ("PATH", newpath, 1);
356 sprintf_alloc (&ctx->statedir, "/tmp/opkg-intercept-%d-%d", getpid (), gen);
357 if (mkdir (ctx->statedir, 0770) < 0) {
358 if (errno == EEXIST) {
359 free (ctx->statedir);
363 perror (ctx->statedir);
366 setenv ("OPKG_INTERCEPT_DIR", ctx->statedir, 1);
370 int opkg_finalize_intercepts(opkg_intercept_t ctx)
376 setenv ("PATH", ctx->oldpath, 1);
379 dir = opendir (ctx->statedir);
382 while (de = readdir (dir), de != NULL) {
385 if (de->d_name[0] == '.')
388 sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
389 if (access (path, X_OK) == 0) {
398 perror (ctx->statedir);
400 sprintf_alloc (&cmd, "rm -rf %s", ctx->statedir);
404 free (ctx->statedir);
410 int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
418 opkg_message(conf, OPKG_INFO,
419 "Configuring unpacked packages\n");
422 all = pkg_vec_alloc();
423 pkg_hash_fetch_available(&conf->pkg_hash, all);
425 ic = opkg_prep_intercepts (conf);
427 for(i = 0; i < all->len; i++) {
430 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
433 if (pkg->state_status == SS_UNPACKED) {
434 opkg_message(conf, OPKG_NOTICE,
435 "Configuring %s\n", pkg->name);
437 r = opkg_configure(conf, pkg);
439 pkg->state_status = SS_INSTALLED;
440 pkg->parent->state_status = SS_INSTALLED;
441 pkg->state_flag &= ~SF_PREFER;
449 r = opkg_finalize_intercepts (ic);
457 static opkg_conf_t *global_conf;
459 static void sigint_handler(int sig)
461 signal(sig, SIG_DFL);
462 opkg_message(NULL, OPKG_NOTICE,
463 "opkg: interrupted. writing out status database\n");
464 write_status_files_if_changed(global_conf);
468 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv)
475 signal(SIGINT, sigint_handler);
478 * Now scan through package names and install
480 for (i=0; i < argc; i++) {
483 opkg_message(conf, OPKG_DEBUG2, "Debug install_cmd: %s \n",arg );
484 err = opkg_prepare_url_for_install(conf, arg, &argv[i]);
485 if (err != EINVAL && err != 0)
488 pkg_info_preinstall_check(conf);
490 for (i=0; i < argc; i++) {
492 if (conf->multiple_providers)
493 err = opkg_install_multi_by_name(conf, arg);
495 err = opkg_install_by_name(conf, arg);
497 if (err == OPKG_PKG_HAS_NO_CANDIDATE) {
498 opkg_message(conf, OPKG_ERROR,
499 "Cannot find package %s.\n"
500 "Check the spelling or perhaps run 'opkg update'\n",
505 /* recheck to verify that all dependences are satisfied */
506 if (0) opkg_satisfy_all_dependences(conf);
508 opkg_configure_packages(conf, NULL);
510 write_status_files_if_changed(conf);
515 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv)
522 signal(SIGINT, sigint_handler);
525 for (i=0; i < argc; i++) {
528 err = opkg_prepare_url_for_install(conf, arg, &arg);
529 if (err != EINVAL && err != 0)
532 pkg_info_preinstall_check(conf);
534 for (i=0; i < argc; i++) {
536 if (conf->restrict_to_default_dest) {
537 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
541 opkg_message(conf, OPKG_NOTICE,
542 "Package %s not installed in %s\n",
543 argv[i], conf->default_dest->name);
547 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
551 opkg_upgrade_pkg(conf, pkg);
553 opkg_install_by_name(conf, arg);
557 pkg_vec_t *installed = pkg_vec_alloc();
559 pkg_info_preinstall_check(conf);
561 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
562 for (i = 0; i < installed->len; i++) {
563 pkg = installed->pkgs[i];
564 opkg_upgrade_pkg(conf, pkg);
566 pkg_vec_free(installed);
569 /* recheck to verify that all dependences are satisfied */
570 if (0) opkg_satisfy_all_dependences(conf);
572 opkg_configure_packages(conf, NULL);
574 write_status_files_if_changed(conf);
579 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv)
585 pkg_info_preinstall_check(conf);
586 for (i = 0; i < argc; i++) {
589 pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, arg);
591 opkg_message(conf, OPKG_ERROR,
592 "Cannot find package %s.\n"
593 "Check the spelling or perhaps run 'opkg update'\n",
598 err = opkg_download_pkg(conf, pkg, ".");
601 opkg_message(conf, OPKG_ERROR,
602 "Failed to download %s\n", pkg->name);
604 opkg_message(conf, OPKG_NOTICE,
605 "Downloaded %s as %s\n",
606 pkg->name, pkg->local_filename);
614 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv)
617 pkg_vec_t *available;
619 char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
621 char *pkg_name = NULL;
627 available = pkg_vec_alloc();
628 pkg_hash_fetch_available(&conf->pkg_hash, available);
629 for (i=0; i < available->len; i++) {
630 pkg = available->pkgs[i];
631 /* if we have package name or pattern and pkg does not match, then skip it */
632 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
634 if (pkg->description) {
635 strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
637 desc_short[0] = '\0';
639 desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
640 newline = strchr(desc_short, '\n');
645 printf("%s - %s\n", pkg->name, desc_short);
648 version_str = pkg_version_str_alloc(pkg);
649 opkg_cb_list(pkg->name,desc_short,
657 pkg_vec_free(available);
663 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv)
666 pkg_vec_t *available;
668 char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
670 char *pkg_name = NULL;
676 available = pkg_vec_alloc();
677 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
678 for (i=0; i < available->len; i++) {
679 pkg = available->pkgs[i];
680 /* if we have package name or pattern and pkg does not match, then skip it */
681 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
683 if (pkg->description) {
684 strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
686 desc_short[0] = '\0';
688 desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
689 newline = strchr(desc_short, '\n');
694 printf("%s - %s\n", pkg->name, desc_short);
697 version_str = pkg_version_str_alloc(pkg);
698 opkg_cb_list(pkg->name,desc_short,
710 static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int installed_only)
713 pkg_vec_t *available;
715 char *pkg_name = NULL;
716 char **pkg_fields = NULL;
718 char *buff ; // = (char *)malloc(1);
724 pkg_fields = &argv[1];
728 available = pkg_vec_alloc();
730 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
732 pkg_hash_fetch_available(&conf->pkg_hash, available);
733 for (i=0; i < available->len; i++) {
734 pkg = available->pkgs[i];
735 if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
740 for (j = 0; j < n_fields; j++)
741 pkg_print_field(pkg, stdout, pkg_fields[j]);
743 pkg_print_info(pkg, stdout);
747 buff = pkg_formatted_info(pkg);
749 if (opkg_cb_status) opkg_cb_status(pkg->name,
754 We should not forget that actually the pointer is allocated.
755 We need to free it :) ( Thanks florian for seeing the error )
760 if (conf->verbosity > 1) {
761 conffile_list_elt_t *iter;
762 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
763 conffile_t *cf = iter->data;
764 int modified = conffile_has_been_modified(conf, cf);
765 opkg_message(conf, OPKG_NOTICE, "conffile=%s md5sum=%s modified=%d\n",
766 cf->name, cf->value, modified);
774 pkg_vec_free(available);
779 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv)
781 return opkg_info_status_cmd(conf, argc, argv, 0);
784 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv)
786 return opkg_info_status_cmd(conf, argc, argv, 1);
789 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv)
794 char *pkg_name = NULL;
798 err = opkg_configure_packages (conf, pkg_name);
801 err = opkg_configure_packages (conf, NULL);
804 write_status_files_if_changed(conf);
809 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv)
815 sprintf_alloc(&globpattern, "%s/*" OPKG_PKG_EXTENSION, conf->pending_dir);
816 err = glob(globpattern, 0, NULL, &globbuf);
822 opkg_message(conf, OPKG_NOTICE,
823 "The following packages in %s will now be installed.\n",
825 for (i = 0; i < globbuf.gl_pathc; i++) {
826 opkg_message(conf, OPKG_NOTICE,
827 "%s%s", i == 0 ? "" : " ", globbuf.gl_pathv[i]);
829 opkg_message(conf, OPKG_NOTICE, "\n");
830 for (i = 0; i < globbuf.gl_pathc; i++) {
831 err = opkg_install_from_file(conf, globbuf.gl_pathv[i]);
833 err = unlink(globbuf.gl_pathv[i]);
835 opkg_message(conf, OPKG_ERROR,
836 "%s: ERROR: failed to unlink %s: %s\n",
837 __FUNCTION__, globbuf.gl_pathv[i], strerror(err));
847 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv)
851 pkg_t *pkg_to_remove;
852 pkg_vec_t *available;
853 char *pkg_name = NULL;
855 signal(SIGINT, sigint_handler);
857 // ENH: Add the "no pkg removed" just in case.
861 available = pkg_vec_alloc();
862 pkg_info_preinstall_check(conf);
864 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
865 for (i=0; i < argc; i++) {
866 pkg_name = malloc(strlen(argv[i])+2);
867 strcpy(pkg_name,argv[i]);
868 for (a=0; a < available->len; a++) {
869 pkg = available->pkgs[a];
870 if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
873 if (conf->restrict_to_default_dest) {
874 pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
878 pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
882 opkg_message(conf, OPKG_ERROR, "Package %s is not installed.\n", pkg->name);
885 if (pkg->state_status == SS_NOT_INSTALLED) { // Added the control, so every already removed package could be skipped
886 opkg_message(conf, OPKG_ERROR, "Package seems to be %s not installed (STATUS = NOT_INSTALLED).\n", pkg->name);
889 opkg_remove_pkg(conf, pkg_to_remove,0);
894 pkg_vec_free(available);
896 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
898 int flagged_pkg_count = 0;
901 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed_pkgs);
903 for (i = 0; i < installed_pkgs->len; i++) {
904 pkg_t *pkg = installed_pkgs->pkgs[i];
905 if (pkg->state_flag & SF_USER) {
908 if (!pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL))
909 opkg_message(conf, OPKG_NOTICE, "Non-user leaf package: %s\n", pkg->name);
912 if (!flagged_pkg_count) {
913 opkg_message(conf, OPKG_NOTICE, "No packages flagged as installed by user, \n"
914 "so refusing to uninstall unflagged non-leaf packages\n");
918 /* find packages not flagged SF_USER (i.e., installed to
919 * satisfy a dependence) and not having any dependents, and
923 for (i = 0; i < installed_pkgs->len; i++) {
924 pkg_t *pkg = installed_pkgs->pkgs[i];
925 if (!(pkg->state_flag & SF_USER)
926 && !pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL)) {
928 opkg_message(conf, OPKG_NOTICE, "Removing non-user leaf package %s\n");
929 opkg_remove_pkg(conf, pkg,0);
934 pkg_vec_free(installed_pkgs);
938 opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
940 write_status_files_if_changed(conf);
944 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv)
950 signal(SIGINT, sigint_handler);
952 pkg_info_preinstall_check(conf);
954 for (i=0; i < argc; i++) {
955 if (conf->restrict_to_default_dest) {
956 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
960 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
964 opkg_message(conf, OPKG_ERROR,
965 "Package %s is not installed.\n", argv[i]);
968 opkg_purge_pkg(conf, pkg);
971 write_status_files_if_changed(conf);
975 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv)
979 const char *flags = argv[0];
982 signal(SIGINT, sigint_handler);
984 for (i=1; i < argc; i++) {
985 if (conf->restrict_to_default_dest) {
986 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
990 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
994 opkg_message(conf, OPKG_ERROR,
995 "Package %s is not installed.\n", argv[i]);
998 if (( strcmp(flags,"hold")==0)||( strcmp(flags,"noprune")==0)||
999 ( strcmp(flags,"user")==0)||( strcmp(flags,"ok")==0)) {
1000 pkg->state_flag = pkg_state_flag_from_str(flags);
1002 /* pb_ asked this feature 03292004 */
1003 /* Actually I will use only this two, but this is an open for various status */
1004 if (( strcmp(flags,"installed")==0)||( strcmp(flags,"unpacked")==0)){
1005 pkg->state_status = pkg_state_status_from_str(flags);
1007 opkg_state_changed++;
1008 opkg_message(conf, OPKG_NOTICE,
1009 "Setting flags for package %s to %s\n",
1013 write_status_files_if_changed(conf);
1017 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
1020 str_list_t *installed_files;
1021 str_list_elt_t *iter;
1023 size_t buff_len = 8192;
1027 buff = (char *)malloc(buff_len);
1028 if ( buff == NULL ) {
1029 fprintf( stderr,"%s: Unable to allocate memory \n",__FUNCTION__);
1037 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
1040 opkg_message(conf, OPKG_ERROR,
1041 "Package %s not installed.\n", argv[0]);
1045 installed_files = pkg_get_installed_files(pkg);
1046 pkg_version = pkg_version_str_alloc(pkg);
1049 printf("Package %s (%s) is installed on %s and has the following files:\n",
1050 pkg->name, pkg_version, pkg->dest->name);
1051 for (iter = installed_files->head; iter; iter = iter->next) {
1057 used_len = snprintf(buff, buff_len, "Package %s (%s) is installed on %s and has the following files:\n",
1058 pkg->name, pkg_version, pkg->dest->name) + 1;
1059 if (used_len > buff_len) {
1061 buff = realloc (buff, buff_len);
1064 for (iter = installed_files->head; iter; iter = iter->next) {
1065 used_len += strlen (iter->data) + 1;
1066 while (buff_len <= used_len) {
1068 buff = realloc (buff, buff_len);
1070 strncat(buff, iter->data, buff_len);
1071 strncat(buff, "\n", buff_len);
1073 if (opkg_cb_list) opkg_cb_list(pkg->name,
1075 pkg_version_str_alloc(pkg),
1083 pkg_free_installed_files(pkg);
1088 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv)
1092 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1093 const char *rel_str = "depends on";
1096 pkg_info_preinstall_check(conf);
1098 if (conf->query_all)
1099 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1101 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1102 for (i = 0; i < argc; i++) {
1103 const char *target = argv[i];
1106 opkg_message(conf, OPKG_ERROR, "target=%s\n", target);
1108 for (j = 0; j < available_pkgs->len; j++) {
1109 pkg_t *pkg = available_pkgs->pkgs[j];
1110 if (fnmatch(target, pkg->name, 0) == 0) {
1112 int count = pkg->depends_count + pkg->pre_depends_count;
1113 opkg_message(conf, OPKG_ERROR, "What %s (arch=%s) %s\n",
1114 target, pkg->architecture, rel_str);
1115 for (k = 0; k < count; k++) {
1116 compound_depend_t *cdepend = &pkg->depends[k];
1118 for (l = 0; l < cdepend->possibility_count; l++) {
1119 depend_t *possibility = cdepend->possibilities[l];
1120 opkg_message(conf, OPKG_ERROR, " %s", possibility->pkg->name);
1121 if (conf->verbosity > 0) {
1122 // char *ver = abstract_pkg_version_str_alloc(possibility->pkg);
1123 opkg_message(conf, OPKG_NOTICE, " %s", possibility->version);
1124 if (possibility->version) {
1125 char *typestr = NULL;
1126 switch (possibility->constraint) {
1127 case NONE: typestr = "none"; break;
1128 case EARLIER: typestr = "<"; break;
1129 case EARLIER_EQUAL: typestr = "<="; break;
1130 case EQUAL: typestr = "="; break;
1131 case LATER_EQUAL: typestr = ">="; break;
1132 case LATER: typestr = ">"; break;
1134 opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1138 opkg_message(conf, OPKG_ERROR, "\n");
1144 pkg_vec_free(available_pkgs);
1149 enum what_field_type {
1158 static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int recursive, int argc, char **argv)
1162 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1163 const char *rel_str = NULL;
1167 switch (what_field_type) {
1168 case WHATDEPENDS: rel_str = "depends on"; break;
1169 case WHATCONFLICTS: rel_str = "conflicts with"; break;
1170 case WHATSUGGESTS: rel_str = "suggests"; break;
1171 case WHATRECOMMENDS: rel_str = "recommends"; break;
1172 case WHATPROVIDES: rel_str = "provides"; break;
1173 case WHATREPLACES: rel_str = "replaces"; break;
1176 if (conf->query_all)
1177 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1179 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1181 /* mark the root set */
1182 pkg_vec_clear_marks(available_pkgs);
1183 opkg_message(conf, OPKG_NOTICE, "Root set:\n");
1184 for (i = 0; i < argc; i++) {
1185 const char *dependee_pattern = argv[i];
1186 pkg_vec_mark_if_matches(available_pkgs, dependee_pattern);
1188 for (i = 0; i < available_pkgs->len; i++) {
1189 pkg_t *pkg = available_pkgs->pkgs[i];
1190 if (pkg->state_flag & SF_MARKED) {
1191 /* mark the parent (abstract) package */
1192 pkg_mark_provides(pkg);
1193 opkg_message(conf, OPKG_NOTICE, " %s\n", pkg->name);
1197 opkg_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str);
1202 for (j = 0; j < available_pkgs->len; j++) {
1203 pkg_t *pkg = available_pkgs->pkgs[j];
1205 int count = ((what_field_type == WHATCONFLICTS)
1206 ? pkg->conflicts_count
1207 : pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count);
1208 /* skip this package if it is already marked */
1209 if (pkg->parent->state_flag & SF_MARKED) {
1212 for (k = 0; k < count; k++) {
1213 compound_depend_t *cdepend =
1214 (what_field_type == WHATCONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
1216 for (l = 0; l < cdepend->possibility_count; l++) {
1217 depend_t *possibility = cdepend->possibilities[l];
1218 if (possibility->pkg->state_flag & SF_MARKED) {
1219 /* mark the depending package so we won't visit it again */
1220 pkg->state_flag |= SF_MARKED;
1221 pkg_mark_provides(pkg);
1224 opkg_message(conf, OPKG_NOTICE, " %s", pkg->name);
1225 if (conf->verbosity > 0) {
1226 char *ver = pkg_version_str_alloc(pkg);
1227 opkg_message(conf, OPKG_NOTICE, " %s", ver);
1228 opkg_message(conf, OPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
1229 if (possibility->version) {
1230 char *typestr = NULL;
1231 switch (possibility->constraint) {
1232 case NONE: typestr = "none"; break;
1233 case EARLIER: typestr = "<"; break;
1234 case EARLIER_EQUAL: typestr = "<="; break;
1235 case EQUAL: typestr = "="; break;
1236 case LATER_EQUAL: typestr = ">="; break;
1237 case LATER: typestr = ">"; break;
1239 opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1242 if (!pkg_dependence_satisfiable(conf, possibility))
1243 opkg_message(conf, OPKG_NOTICE, " unsatisfiable");
1245 opkg_message(conf, OPKG_NOTICE, "\n");
1253 } while (changed && recursive);
1254 pkg_vec_free(available_pkgs);
1260 int pkg_mark_provides(pkg_t *pkg)
1262 int provides_count = pkg->provides_count;
1263 abstract_pkg_t **provides = pkg->provides;
1265 pkg->parent->state_flag |= SF_MARKED;
1266 for (i = 0; i < provides_count; i++) {
1267 provides[i]->state_flag |= SF_MARKED;
1272 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv)
1274 return opkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 1, argc, argv);
1276 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv)
1278 return opkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 0, argc, argv);
1281 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv)
1283 return opkg_what_depends_conflicts_cmd(conf, WHATSUGGESTS, 0, argc, argv);
1286 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv)
1288 return opkg_what_depends_conflicts_cmd(conf, WHATRECOMMENDS, 0, argc, argv);
1291 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv)
1293 return opkg_what_depends_conflicts_cmd(conf, WHATCONFLICTS, 0, argc, argv);
1296 static int opkg_what_provides_replaces_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int argc, char **argv)
1300 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1301 const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
1304 pkg_info_preinstall_check(conf);
1306 if (conf->query_all)
1307 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1309 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1310 for (i = 0; i < argc; i++) {
1311 const char *target = argv[i];
1314 opkg_message(conf, OPKG_ERROR, "What %s %s\n",
1316 for (j = 0; j < available_pkgs->len; j++) {
1317 pkg_t *pkg = available_pkgs->pkgs[j];
1319 int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
1320 for (k = 0; k < count; k++) {
1321 abstract_pkg_t *apkg =
1322 ((what_field_type == WHATPROVIDES)
1324 : pkg->replaces[k]);
1325 if (fnmatch(target, apkg->name, 0) == 0) {
1326 opkg_message(conf, OPKG_ERROR, " %s", pkg->name);
1327 if (strcmp(target, apkg->name) != 0)
1328 opkg_message(conf, OPKG_ERROR, "\t%s %s\n", rel_str, apkg->name);
1329 opkg_message(conf, OPKG_ERROR, "\n");
1334 pkg_vec_free(available_pkgs);
1339 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv)
1341 return opkg_what_provides_replaces_cmd(conf, WHATPROVIDES, argc, argv);
1344 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv)
1346 return opkg_what_provides_replaces_cmd(conf, WHATREPLACES, argc, argv);
1349 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv)
1353 pkg_vec_t *installed;
1355 str_list_t *installed_files;
1356 str_list_elt_t *iter;
1357 char *installed_file;
1363 installed = pkg_vec_alloc();
1364 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
1366 for (i=0; i < installed->len; i++) {
1367 pkg = installed->pkgs[i];
1369 installed_files = pkg_get_installed_files(pkg);
1371 for (iter = installed_files->head; iter; iter = iter->next) {
1372 installed_file = iter->data;
1373 if (fnmatch(argv[0], installed_file, 0)==0) {
1375 printf("%s: %s\n", pkg->name, installed_file);
1377 if (opkg_cb_list) opkg_cb_list(pkg->name,
1379 pkg_version_str_alloc(pkg),
1380 pkg->state_status, p_userdata);
1385 pkg_free_installed_files(pkg);
1388 /* XXX: CLEANUP: It's not obvious from the name of
1389 pkg_hash_fetch_all_installed that we need to call
1390 pkg_vec_free to avoid a memory leak. */
1391 pkg_vec_free(installed);
1396 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv)
1399 /* this is a bit gross */
1401 parseVersion(&p1, argv[0]);
1402 parseVersion(&p2, argv[2]);
1403 return pkg_version_satisfied(&p1, &p2, argv[1]);
1405 opkg_message(conf, OPKG_ERROR,
1406 "opkg compare_versions <v1> <op> <v2>\n"
1407 "<op> is one of <= >= << >> =\n");
1412 #ifndef HOST_CPU_STR
1413 #define HOST_CPU_STR__(X) #X
1414 #define HOST_CPU_STR_(X) HOST_CPU_STR__(X)
1415 #define HOST_CPU_STR HOST_CPU_STR_(HOST_CPU_FOO)
1418 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv)
1420 nv_pair_list_elt_t *l;
1422 l = conf->arch_list.head;
1424 nv_pair_t *nv = l->data;
1425 printf("arch %s %s\n", nv->name, nv->value);