1 /* opkg_install.c - the opkg 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.
27 #include "pkg_extract.h"
29 #include "opkg_install.h"
30 #include "opkg_configure.h"
31 #include "opkg_download.h"
32 #include "opkg_remove.h"
34 #include "opkg_utils.h"
35 #include "opkg_message.h"
37 #include "opkg_defines.h"
39 #include "sprintf_alloc.h"
40 #include "file_util.h"
42 #include "libbb/libbb.h"
45 satisfy_dependencies_for(pkg_t *pkg)
48 pkg_vec_t *depends = pkg_vec_alloc();
50 char **tmp, **unresolved = NULL;
53 ndepends = pkg_hash_fetch_unsatisfied_dependencies(pkg, depends,
57 opkg_msg(ERROR, "Cannot satisfy the following dependencies for %s:\n",
61 opkg_msg(ERROR, "\t%s", *unresolved);
66 opkg_message(ERROR, "\n");
67 if (! conf->force_depends) {
69 "This could mean that your package list is out of date or that the packages\n"
70 "mentioned above do not yet exist (try 'opkg update'). To proceed in spite\n"
71 "of this problem try again with the '-force-depends' option.\n");
72 pkg_vec_free(depends);
78 pkg_vec_free(depends);
82 /* Mark packages as to-be-installed */
83 for (i=0; i < depends->len; i++) {
84 /* Dependencies should be installed the same place as pkg */
85 if (depends->pkgs[i]->dest == NULL) {
86 depends->pkgs[i]->dest = pkg->dest;
88 depends->pkgs[i]->state_want = SW_INSTALL;
91 for (i = 0; i < depends->len; i++) {
92 dep = depends->pkgs[i];
93 /* The package was uninstalled when we started, but another
94 dep earlier in this loop may have depended on it and pulled
95 it in, so check first. */
96 if ((dep->state_status != SS_INSTALLED)
97 && (dep->state_status != SS_UNPACKED)) {
98 opkg_msg(DEBUG2,"Calling opkg_install_pkg.\n");
99 err = opkg_install_pkg(dep, 0);
100 /* mark this package as having been automatically installed to
101 * satisfy a dependancy */
102 dep->auto_installed = 1;
104 pkg_vec_free(depends);
110 pkg_vec_free(depends);
116 check_conflicts_for(pkg_t *pkg)
119 pkg_vec_t *conflicts = NULL;
120 message_level_t level;
122 if (conf->force_depends) {
128 if (!conf->force_depends)
129 conflicts = pkg_hash_fetch_conflicts(pkg);
132 opkg_msg(level, "The following packages conflict with %s:\n",
135 while (i < conflicts->len)
136 opkg_msg(level, "\t%s", conflicts->pkgs[i++]->name);
137 opkg_msg(level, "\n");
138 pkg_vec_free(conflicts);
145 update_file_ownership(pkg_t *new_pkg, pkg_t *old_pkg)
147 str_list_t *new_list, *old_list;
148 str_list_elt_t *iter, *niter;
150 new_list = pkg_get_installed_files(new_pkg);
151 if (new_list == NULL)
154 for (iter = str_list_first(new_list), niter = str_list_next(new_list, iter);
156 iter = niter, niter = str_list_next(new_list, niter)) {
157 char *new_file = (char *)iter->data;
158 pkg_t *owner = file_hash_get_file_owner(new_file);
160 opkg_msg(ERROR, "Null new_file for new_pkg=%s\n", new_pkg->name);
161 if (!owner || (owner == old_pkg))
162 file_hash_set_file_owner(new_file, new_pkg);
166 old_list = pkg_get_installed_files(old_pkg);
167 if (old_list == NULL) {
168 pkg_free_installed_files(new_pkg);
172 for (iter = str_list_first(old_list), niter = str_list_next(old_list, iter);
174 iter = niter, niter = str_list_next(old_list, niter)) {
175 char *old_file = (char *)iter->data;
176 pkg_t *owner = file_hash_get_file_owner(old_file);
177 if (owner == old_pkg) {
179 hash_table_insert(&conf->obs_file_hash, old_file, old_pkg);
182 pkg_free_installed_files(old_pkg);
184 pkg_free_installed_files(new_pkg);
189 verify_pkg_installable(pkg_t *pkg)
191 unsigned long kbs_available, pkg_size_kbs;
194 if (conf->force_space || pkg->installed_size == 0)
197 root_dir = pkg->dest ? pkg->dest->root_dir :
198 conf->default_dest->root_dir;
199 kbs_available = get_available_kbytes(root_dir);
201 pkg_size_kbs = (pkg->installed_size + 1023)/1024;
203 if (pkg_size_kbs >= kbs_available) {
204 opkg_msg(ERROR, "Only have %dkb available on filesystem %s, "
206 kbs_available, root_dir, pkg->name, pkg_size_kbs);
214 unpack_pkg_control_files(pkg_t *pkg)
217 char *conffiles_file_name;
219 FILE *conffiles_file;
221 sprintf_alloc(&pkg->tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir, pkg->name);
223 pkg->tmp_unpack_dir = mkdtemp(pkg->tmp_unpack_dir);
224 if (pkg->tmp_unpack_dir == NULL) {
225 opkg_perror(ERROR, "Failed to create temporary directory '%s'",
226 pkg->tmp_unpack_dir);
230 err = pkg_extract_control_files_to_dir(pkg, pkg->tmp_unpack_dir);
235 /* XXX: CLEANUP: There might be a cleaner place to read in the
236 conffiles. Seems like I should be able to get everything to go
237 through pkg_init_from_file. If so, maybe it would make sense to
238 move all of unpack_pkg_control_files to that function. */
240 /* Don't need to re-read conffiles if we already have it */
241 if (!nv_pair_list_empty(&pkg->conffiles)) {
245 sprintf_alloc(&conffiles_file_name, "%s/conffiles", pkg->tmp_unpack_dir);
246 if (! file_exists(conffiles_file_name)) {
247 free(conffiles_file_name);
251 conffiles_file = fopen(conffiles_file_name, "r");
252 if (conffiles_file == NULL) {
253 opkg_perror(ERROR, "Failed to open %s", conffiles_file_name);
254 free(conffiles_file_name);
257 free(conffiles_file_name);
261 char *cf_name_in_dest;
263 cf_name = file_read_line_alloc(conffiles_file);
264 if (cf_name == NULL) {
267 if (cf_name[0] == '\0') {
271 /* Prepend dest->root_dir to conffile name.
272 Take pains to avoid multiple slashes. */
273 root_dir = pkg->dest->root_dir;
274 if (conf->offline_root)
275 /* skip the offline_root prefix */
276 root_dir = pkg->dest->root_dir + strlen(conf->offline_root);
277 sprintf_alloc(&cf_name_in_dest, "%s%s", root_dir,
278 cf_name[0] == '/' ? (cf_name + 1) : cf_name);
280 /* Can't get an md5sum now, (file isn't extracted yet).
281 We'll wait until resolve_conffiles */
282 conffile_list_append(&pkg->conffiles, cf_name_in_dest, NULL);
285 free(cf_name_in_dest);
288 fclose(conffiles_file);
294 * Remove packages which were auto_installed due to a dependency by old_pkg,
295 * which are no longer a dependency in the new (upgraded) pkg.
298 pkg_remove_orphan_dependent(pkg_t *pkg, pkg_t *old_pkg)
300 int i, j, k, l, found;
303 struct compound_depend *cd0, *cd1;
304 abstract_pkg_t **dependents;
306 int count0 = old_pkg->pre_depends_count +
307 old_pkg->depends_count +
308 old_pkg->recommends_count +
309 old_pkg->suggests_count;
310 int count1 = pkg->pre_depends_count +
312 pkg->recommends_count +
315 for (i=0; i<count0; i++) {
316 cd0 = &old_pkg->depends[i];
317 if (cd0->type != DEPEND)
319 for (j=0; j<cd0->possibility_count; j++) {
323 for (k=0; k<count1; k++) {
324 cd1 = &pkg->depends[i];
325 if (cd1->type != DEPEND)
327 for (l=0; l<cd1->possibility_count; l++) {
328 if (cd0->possibilities[j]
329 == cd1->possibilities[l]) {
342 * old_pkg has a dependency that pkg does not.
344 p = pkg_hash_fetch_installed_by_name(
345 cd0->possibilities[j]->pkg->name);
350 if (!p->auto_installed)
353 n_deps = pkg_has_installed_dependents(p, &dependents);
354 n_deps--; /* don't count old_pkg */
357 opkg_msg(NOTICE, "%s was autoinstalled and is "
358 "now orphaned, removing.\n",
361 /* p has one installed dependency (old_pkg),
362 * which we need to ignore during removal. */
363 p->state_flag |= SF_REPLACE;
365 opkg_remove_pkg(p, 0);
367 opkg_msg(INFO, "%s was autoinstalled and is "
368 "still required by %d "
369 "installed packages.\n",
378 /* returns number of installed replacees */
380 pkg_get_installed_replacees(pkg_t *pkg, pkg_vec_t *installed_replacees)
382 abstract_pkg_t **replaces = pkg->replaces;
383 int replaces_count = pkg->replaces_count;
385 for (i = 0; i < replaces_count; i++) {
386 abstract_pkg_t *ab_pkg = replaces[i];
387 pkg_vec_t *pkg_vec = ab_pkg->pkgs;
389 for (j = 0; j < pkg_vec->len; j++) {
390 pkg_t *replacee = pkg_vec->pkgs[j];
391 if (!pkg_conflicts(pkg, replacee))
393 if (replacee->state_status == SS_INSTALLED) {
394 pkg_vec_insert(installed_replacees, replacee);
399 return installed_replacees->len;
403 pkg_remove_installed_replacees(pkg_vec_t *replacees)
406 int replaces_count = replacees->len;
407 for (i = 0; i < replaces_count; i++) {
408 pkg_t *replacee = replacees->pkgs[i];
410 replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
411 err = opkg_remove_pkg(replacee, 0);
418 /* to unwind the removal: make sure they are installed */
420 pkg_remove_installed_replacees_unwind(pkg_vec_t *replacees)
423 int replaces_count = replacees->len;
424 for (i = 0; i < replaces_count; i++) {
425 pkg_t *replacee = replacees->pkgs[i];
426 if (replacee->state_status != SS_INSTALLED) {
427 opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
428 err = opkg_install_pkg(replacee, 0);
436 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
438 opkg_install_check_downgrade(pkg_t *pkg, pkg_t *old_pkg, int message)
441 char message_out[15];
442 char *old_version = pkg_version_str_alloc(old_pkg);
443 char *new_version = pkg_version_str_alloc(pkg);
444 int cmp = pkg_compare_versions(old_pkg, pkg);
447 memset(message_out,'\x0',15);
448 strncpy (message_out,"Upgrading ",strlen("Upgrading "));
449 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
450 cmp = -1 ; /* then we force opkg to downgrade */
451 strncpy (message_out,"Downgrading ",strlen("Downgrading ")); /* We need to use a value < 0 because in the 0 case we are asking to */
452 /* reinstall, and some check could fail asking the "force-reinstall" option */
456 if(!conf->download_only)
458 "Not downgrading package %s on %s from %s to %s.\n",
459 old_pkg->name, old_pkg->dest->name, old_version, new_version);
461 } else if (cmp < 0) {
462 if(!conf->download_only)
463 opkg_msg(NOTICE, "%s%s on %s from %s to %s...\n",
464 message_out, pkg->name, old_pkg->dest->name, old_version, new_version);
465 pkg->dest = old_pkg->dest;
467 } else /* cmp == 0 */ {
468 if (conf->force_reinstall) {
469 if(!conf->download_only)
470 opkg_msg(NOTICE, "Reinstalling %s (%s) on %s...\n",
471 pkg->name, new_version, old_pkg->dest->name);
472 pkg->dest = old_pkg->dest;
475 if(!conf->download_only)
476 opkg_msg(NOTICE, "%s (%s) already install on %s."
477 " Not reinstalling.\n",
478 pkg->name, new_version, old_pkg->dest->name);
486 char message_out[15] ;
487 memset(message_out,'\x0',15);
489 strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
491 strncpy( message_out,"Installing ",strlen("Installing ") );
492 char *version = pkg_version_str_alloc(pkg);
494 if(!conf->download_only)
495 opkg_msg(NOTICE, "%s%s (%s) to %s...\n", message_out,
496 pkg->name, version, pkg->dest->name);
504 prerm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
506 /* DPKG_INCOMPATIBILITY:
507 dpkg does some things here that we don't do yet. Do we care?
509 1. If a version of the package is already installed, call
510 old-prerm upgrade new-version
511 2. If the script runs but exits with a non-zero exit status
512 new-prerm failed-upgrade old-version
513 Error unwind, for both the above cases:
514 old-postinst abort-upgrade new-version
520 prerm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
522 /* DPKG_INCOMPATIBILITY:
523 dpkg does some things here that we don't do yet. Do we care?
524 (See prerm_upgrade_old_package for details)
530 prerm_deconfigure_conflictors(pkg_t *pkg, pkg_vec_t *conflictors)
532 /* DPKG_INCOMPATIBILITY:
533 dpkg does some things here that we don't do yet. Do we care?
534 2. If a 'conflicting' package is being removed at the same time:
535 1. If any packages depended on that conflicting package and
536 --auto-deconfigure is specified, call, for each such package:
537 deconfigured's-prerm deconfigure \
538 in-favour package-being-installed version \
539 removing conflicting-package version
541 deconfigured's-postinst abort-deconfigure \
542 in-favour package-being-installed-but-failed version \
543 removing conflicting-package version
545 The deconfigured packages are marked as requiring
546 configuration, so that if --install is used they will be
547 configured again if possible.
548 2. To prepare for removal of the conflicting package, call:
549 conflictor's-prerm remove in-favour package new-version
551 conflictor's-postinst abort-remove in-favour package new-version
557 prerm_deconfigure_conflictors_unwind(pkg_t *pkg, pkg_vec_t *conflictors)
559 /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
560 do yet. Do we care? (See prerm_deconfigure_conflictors for
566 preinst_configure(pkg_t *pkg, pkg_t *old_pkg)
572 char *old_version = pkg_version_str_alloc(old_pkg);
573 sprintf_alloc(&preinst_args, "upgrade %s", old_version);
575 } else if (pkg->state_status == SS_CONFIG_FILES) {
576 char *pkg_version = pkg_version_str_alloc(pkg);
577 sprintf_alloc(&preinst_args, "install %s", pkg_version);
580 preinst_args = xstrdup("install");
583 err = pkg_run_script(pkg, "preinst", preinst_args);
585 opkg_msg(ERROR, "Aborting installation of %s.\n", pkg->name);
595 preinst_configure_unwind(pkg_t *pkg, pkg_t *old_pkg)
597 /* DPKG_INCOMPATIBILITY:
598 dpkg does the following error unwind, should we?
599 pkg->postrm abort-upgrade old-version
600 OR pkg->postrm abort-install old-version
601 OR pkg->postrm abort-install
607 backup_filename_alloc(const char *file_name)
611 sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
618 backup_make_backup(const char *file_name)
623 backup = backup_filename_alloc(file_name);
624 err = file_copy(file_name, backup);
626 opkg_msg(ERROR, "Failed to copy %s to %s\n",
636 backup_exists_for(const char *file_name)
641 backup = backup_filename_alloc(file_name);
643 ret = file_exists(backup);
651 backup_remove(const char *file_name)
655 backup = backup_filename_alloc(file_name);
663 backup_modified_conffiles(pkg_t *pkg, pkg_t *old_pkg)
666 conffile_list_elt_t *iter;
669 if (conf->noaction) return 0;
671 /* Backup all modified conffiles */
673 for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
677 cf_name = root_filename_alloc(cf->name);
679 /* Don't worry if the conffile is just plain gone */
680 if (file_exists(cf_name) && conffile_has_been_modified(cf)) {
681 err = backup_make_backup(cf_name);
690 /* Backup all conffiles that were not conffiles in old_pkg */
691 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
693 cf = (conffile_t *)iter->data;
694 cf_name = root_filename_alloc(cf->name);
695 /* Ignore if this was a conffile in old_pkg as well */
696 if (pkg_get_conffile(old_pkg, cf->name)) {
700 if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
701 err = backup_make_backup(cf_name);
713 backup_modified_conffiles_unwind(pkg_t *pkg, pkg_t *old_pkg)
715 conffile_list_elt_t *iter;
718 for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
719 backup_remove(((nv_pair_t *)iter->data)->name);
723 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
724 backup_remove(((nv_pair_t *)iter->data)->name);
732 check_data_file_clashes(pkg_t *pkg, pkg_t *old_pkg)
734 /* DPKG_INCOMPATIBILITY:
735 opkg takes a slightly different approach than dpkg at this
736 point. dpkg installs each file in the new package while
737 creating a backup for any file that is replaced, (so that it
738 can unwind if necessary). To avoid complexity and redundant
739 storage, opkg doesn't do any installation until later, (at the
740 point at which dpkg removes the backups.
742 But, we do have to check for data file clashes, since after
743 installing a package with a file clash, removing either of the
744 packages involved in the clash has the potential to break the
747 str_list_t *files_list;
748 str_list_elt_t *iter, *niter;
752 files_list = pkg_get_installed_files(pkg);
753 if (files_list == NULL)
756 for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
758 iter = niter, niter = str_list_next(files_list, iter)) {
760 char *filename = (char *) iter->data;
761 root_filename = root_filename_alloc(filename);
762 if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
766 if (backup_exists_for(root_filename)) {
770 /* Pre-existing files are OK if force-overwrite was asserted. */
771 if (conf->force_overwrite) {
772 /* but we need to change who owns this file */
773 file_hash_set_file_owner(filename, pkg);
777 owner = file_hash_get_file_owner(filename);
779 /* Pre-existing files are OK if owned by the pkg being upgraded. */
780 if (owner && old_pkg) {
781 if (strcmp(owner->name, old_pkg->name) == 0) {
786 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
788 opkg_msg(DEBUG2, "Checking replaces for %s in package %s\n",
789 filename, owner->name);
790 if (pkg_replaces(pkg, owner)) {
793 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
794 then it's ok to overwrite. */
795 if (strcmp(owner->name,pkg->name)==0){
796 opkg_msg(INFO, "Replacing pre-existing file %s"
797 " owned by package %s\n",
798 filename, owner->name);
803 /* Pre-existing files are OK if they are obsolete */
804 obs = hash_table_get(&conf->obs_file_hash, filename);
806 opkg_msg(INFO, "Pre-exiting file %s is obsolete."
808 filename, obs->name);
812 /* We have found a clash. */
813 opkg_msg(ERROR, "Package %s wants to install file %s\n"
814 "\tBut that file is already provided by package ",
815 pkg->name, filename);
817 opkg_msg(ERROR, "%s\n", owner->name);
819 opkg_msg(ERROR, "<no package>\n"
820 "Please move this file out of the way and try again.\n");
826 pkg_free_installed_files(pkg);
832 * XXX: This function sucks, as does the below comment.
835 check_data_file_clashes_change(pkg_t *pkg, pkg_t *old_pkg)
837 /* Basically that's the worst hack I could do to be able to change ownership of
838 file list, but, being that we have no way to unwind the mods, due to structure
839 of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
840 What we do here is change the ownership of file in hash if a replace ( or similar events
842 Only the action that are needed to change name should be considered.
843 @@@ To change after 1.0 release.
845 str_list_t *files_list;
846 str_list_elt_t *iter, *niter;
848 char *root_filename = NULL;
850 files_list = pkg_get_installed_files(pkg);
851 if (files_list == NULL)
854 for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
856 iter = niter, niter = str_list_next(files_list, niter)) {
857 char *filename = (char *) iter->data;
860 root_filename = NULL;
862 root_filename = root_filename_alloc(filename);
863 if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
866 owner = file_hash_get_file_owner(filename);
868 if (conf->force_overwrite) {
869 /* but we need to change who owns this file */
870 file_hash_set_file_owner(filename, pkg);
875 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
877 if (pkg_replaces(pkg, owner)) {
878 /* It's now time to change the owner of that file.
879 It has been "replaced" from the new "Replaces", then I need to inform lists file about that. */
880 opkg_msg(INFO, "Replacing pre-existing file %s "
881 "owned by package %s\n",
882 filename, owner->name);
883 file_hash_set_file_owner(filename, pkg);
892 root_filename = NULL;
894 pkg_free_installed_files(pkg);
900 check_data_file_clashes_unwind(pkg_t *pkg, pkg_t *old_pkg)
902 /* Nothing to do since check_data_file_clashes doesn't change state */
907 postrm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
909 /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
910 1. If the package is being upgraded, call
911 old-postrm upgrade new-version
912 2. If this fails, attempt:
913 new-postrm failed-upgrade old-version
914 Error unwind, for both cases:
915 old-preinst abort-upgrade new-version */
920 postrm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
922 /* DPKG_INCOMPATIBILITY:
923 dpkg does some things here that we don't do yet. Do we care?
924 (See postrm_upgrade_old_pkg for details)
930 remove_obsolesced_files(pkg_t *pkg, pkg_t *old_pkg)
933 str_list_t *old_files;
935 str_list_t *new_files;
937 hash_table_t new_files_table;
939 old_files = pkg_get_installed_files(old_pkg);
940 if (old_files == NULL)
943 new_files = pkg_get_installed_files(pkg);
944 if (new_files == NULL) {
945 pkg_free_installed_files(old_pkg);
949 new_files_table.entries = NULL;
950 hash_table_init("new_files" , &new_files_table, 20);
951 for (nf = str_list_first(new_files); nf; nf = str_list_next(new_files, nf)) {
953 hash_table_insert(&new_files_table, nf->data, nf->data);
956 for (of = str_list_first(old_files); of; of = str_list_next(old_files, of)) {
959 old = (char *)of->data;
960 new = (char *) hash_table_get (&new_files_table, old);
964 if (file_is_dir(old)) {
967 owner = file_hash_get_file_owner(old);
968 if (owner != old_pkg) {
969 /* in case obsolete file no longer belongs to old_pkg */
973 /* old file is obsolete */
974 opkg_msg(INFO, "Removing obsolete file %s.\n", old);
975 if (!conf->noaction) {
978 opkg_perror(ERROR, "unlinking %s failed", old);
983 hash_table_deinit(&new_files_table);
984 pkg_free_installed_files(old_pkg);
985 pkg_free_installed_files(pkg);
991 install_maintainer_scripts(pkg_t *pkg, pkg_t *old_pkg)
996 sprintf_alloc(&prefix, "%s.", pkg->name);
997 ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
1005 remove_disappeared(pkg_t *pkg)
1007 /* DPKG_INCOMPATIBILITY:
1008 This is a fairly sophisticated dpkg operation. Shall we
1011 /* Any packages all of whose files have been overwritten during the
1012 installation, and which aren't required for dependencies, are
1013 considered to have been removed. For each such package
1014 1. disappearer's-postrm disappear overwriter overwriter-version
1015 2. The package's maintainer scripts are removed
1016 3. It is noted in the status database as being in a sane state,
1017 namely not installed (any conffiles it may have are ignored,
1018 rather than being removed by dpkg). Note that disappearing
1019 packages do not have their prerm called, because dpkg doesn't
1020 know in advance that the package is going to vanish.
1026 install_data_files(pkg_t *pkg)
1030 /* opkg takes a slightly different approach to data file backups
1031 than dpkg. Rather than removing backups at this point, we
1032 actually do the data file installation now. See comments in
1033 check_data_file_clashes() for more details. */
1035 opkg_msg(INFO, "Extracting data files to %s.\n", pkg->dest->root_dir);
1036 err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
1041 /* The "Essential" control field may only be present in the control
1042 * file and not in the Packages list. Ensure we capture it regardless.
1044 * XXX: This should be fixed outside of opkg, in the Package list.
1046 set_flags_from_control(pkg) ;
1048 opkg_msg(DEBUG, "Calling pkg_write_filelist.\n");
1049 err = pkg_write_filelist(pkg);
1053 /* XXX: FEATURE: opkg should identify any files which existed
1054 before installation and which were overwritten, (see
1055 check_data_file_clashes()). What it must do is remove any such
1056 files from the filelist of the old package which provided the
1057 file. Otherwise, if the old package were removed at some point
1058 it would break the new package. Removing the new package will
1059 also break the old one, but this cannot be helped since the old
1060 package's file has already been deleted. This is the importance
1061 of check_data_file_clashes(), and only allowing opkg to install
1062 a clashing package with a user force. */
1068 resolve_conffiles(pkg_t *pkg)
1070 conffile_list_elt_t *iter;
1075 if (conf->noaction) return 0;
1077 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
1078 char *root_filename;
1079 cf = (conffile_t *)iter->data;
1080 root_filename = root_filename_alloc(cf->name);
1082 /* Might need to initialize the md5sum for each conffile */
1083 if (cf->value == NULL) {
1084 cf->value = file_md5sum_alloc(root_filename);
1087 if (!file_exists(root_filename)) {
1088 free(root_filename);
1092 cf_backup = backup_filename_alloc(root_filename);
1094 if (file_exists(cf_backup)) {
1095 /* Let's compute md5 to test if files are changed */
1096 md5sum = file_md5sum_alloc(cf_backup);
1097 if (md5sum && cf->value && strcmp(cf->value,md5sum) != 0 ) {
1098 if (conf->force_maintainer) {
1099 opkg_msg(NOTICE, "Conffile %s using maintainer's setting.\n",
1103 sprintf_alloc(&new_conffile, "%s-opkg", root_filename);
1104 opkg_msg(NOTICE, "Existing conffile %s "
1105 "is different from the conffile in the new package."
1106 " The new conffile will be placed at %s.\n",
1107 root_filename, new_conffile);
1108 rename(root_filename, new_conffile);
1109 rename(cf_backup, root_filename);
1119 free(root_filename);
1127 opkg_install_by_name(const char *pkg_name)
1131 char *old_version, *new_version;
1133 old = pkg_hash_fetch_installed_by_name(pkg_name);
1135 opkg_msg(DEBUG2, "Old versions from pkg_hash_fetch %s.\n",
1138 new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name);
1142 opkg_msg(DEBUG2, "Versions from pkg_hash_fetch:");
1144 opkg_msg(DEBUG2, " old %s ", old->version);
1145 opkg_msg(DEBUG2, " new %s\n", new->version);
1147 new->state_flag |= SF_USER;
1149 old_version = pkg_version_str_alloc(old);
1150 new_version = pkg_version_str_alloc(new);
1152 cmp = pkg_compare_versions(old, new);
1153 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
1154 opkg_msg(DEBUG, "Forcing downgrade\n");
1155 cmp = -1 ; /* then we force opkg to downgrade */
1156 /* We need to use a value < 0 because in the 0 case we are asking to */
1157 /* reinstall, and some check could fail asking the "force-reinstall" option */
1159 opkg_msg(DEBUG, "Comparing visible versions of pkg %s:"
1160 "\n\t%s is installed "
1161 "\n\t%s is available "
1162 "\n\t%d was comparison result\n",
1163 pkg_name, old_version, new_version, cmp);
1164 if (cmp == 0 && !conf->force_reinstall) {
1166 "Package %s (%s) installed in %s is up to date.\n",
1167 old->name, old_version, old->dest->name);
1171 } else if (cmp > 0) {
1173 "Not downgrading package %s on %s from %s to %s.\n",
1174 old->name, old->dest->name, old_version, new_version);
1178 } else if (cmp < 0) {
1179 new->dest = old->dest;
1180 old->state_want = SW_DEINSTALL; /* Here probably the problem for bug 1277 */
1186 opkg_msg(DEBUG2,"Calling opkg_install_pkg.\n");
1187 return opkg_install_pkg(new, 0);
1191 * @brief Really install a pkg_t
1194 opkg_install_pkg(pkg_t *pkg, int from_upgrade)
1198 pkg_t *old_pkg = NULL;
1199 pkg_vec_t *replacees;
1200 abstract_pkg_t *ab_pkg = NULL;
1206 sigset_t newset, oldset;
1209 message = 1; /* Coming from an upgrade, and should change the output message */
1211 opkg_msg(DEBUG2, "Calling pkg_arch_supported.\n");
1213 if (!pkg_arch_supported(pkg)) {
1214 opkg_msg(ERROR, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1215 pkg->architecture, pkg->name);
1218 if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
1219 err = satisfy_dependencies_for(pkg);
1223 opkg_msg(NOTICE, "Package %s is already installed on %s.\n",
1224 pkg->name, pkg->dest->name);
1228 if (pkg->dest == NULL) {
1229 pkg->dest = conf->default_dest;
1232 old_pkg = pkg_hash_fetch_installed_by_name(pkg->name);
1234 err = opkg_install_check_downgrade(pkg, old_pkg, message);
1238 pkg->state_want = SW_INSTALL;
1240 old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependencies */
1243 err = check_conflicts_for(pkg);
1247 /* this setup is to remove the upgrade scenario in the end when
1248 installing pkg A, A deps B & B deps on A. So both B and A are
1249 installed. Then A's installation is started resulting in an
1250 uncecessary upgrade */
1251 if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0)
1254 err = verify_pkg_installable(pkg);
1258 if (pkg->local_filename == NULL) {
1259 if(!conf->cache && conf->download_only){
1261 if(getcwd(cwd, sizeof(cwd)) != NULL)
1262 err = opkg_download_pkg(pkg, cwd);
1266 err = opkg_download_pkg(pkg, conf->tmp_dir);
1269 opkg_msg(ERROR, "Failed to download %s. "
1270 "Perhaps you need to run 'opkg update'?\n",
1276 /* check that the repository is valid */
1277 #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
1278 char *list_file_name, *sig_file_name, *lists_dir;
1280 /* check to ensure the package has come from a repository */
1281 if (conf->check_signature && pkg->src)
1283 sprintf_alloc (&lists_dir, "%s",
1284 (conf->restrict_to_default_dest)
1285 ? conf->default_dest->lists_dir
1287 sprintf_alloc (&list_file_name, "%s/%s", lists_dir, pkg->src->name);
1288 sprintf_alloc (&sig_file_name, "%s/%s.sig", lists_dir, pkg->src->name);
1290 if (file_exists (sig_file_name))
1292 if (opkg_verify_file (list_file_name, sig_file_name)){
1293 opkg_msg(ERROR, "Failed to verify the signature of %s.\n",
1298 opkg_msg(ERROR, "Signature file is missing for %s. "
1299 "Perhaps you need to run 'opkg update'?\n",
1305 free (list_file_name);
1306 free (sig_file_name);
1310 /* Check for md5 values */
1313 file_md5 = file_md5sum_alloc(pkg->local_filename);
1314 if (file_md5 && strcmp(file_md5, pkg->md5sum))
1316 opkg_msg(ERROR, "Package %s md5sum mismatch. "
1317 "Either the opkg or the package index are corrupt. "
1318 "Try 'opkg update'.\n",
1328 /* Check for sha256 value */
1331 file_sha256 = file_sha256sum_alloc(pkg->local_filename);
1332 if (file_sha256 && strcmp(file_sha256, pkg->sha256sum))
1334 opkg_msg(ERROR, "Package %s sha256sum mismatch. "
1335 "Either the opkg or the package index are corrupt. "
1336 "Try 'opkg update'.\n",
1345 if(conf->download_only) {
1346 if (conf->nodeps == 0) {
1347 err = satisfy_dependencies_for(pkg);
1354 if (pkg->tmp_unpack_dir == NULL) {
1355 if (unpack_pkg_control_files(pkg) == -1) {
1356 opkg_msg(ERROR, "Failed to unpack control files from %s.\n",
1357 pkg->local_filename);
1362 err = update_file_ownership(pkg, old_pkg);
1366 if (conf->nodeps == 0) {
1367 err = satisfy_dependencies_for(pkg);
1370 if (pkg->state_status == SS_UNPACKED)
1371 /* Circular dependency has installed it for us. */
1375 replacees = pkg_vec_alloc();
1376 pkg_get_installed_replacees(pkg, replacees);
1378 /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1380 sigemptyset(&newset);
1381 sigaddset(&newset, SIGINT);
1382 sigprocmask(SIG_BLOCK, &newset, &oldset);
1384 opkg_state_changed++;
1385 pkg->state_flag |= SF_FILELIST_CHANGED;
1388 pkg_remove_orphan_dependent(pkg, old_pkg);
1390 /* XXX: BUG: we really should treat replacement more like an upgrade
1391 * Instead, we're going to remove the replacees
1393 err = pkg_remove_installed_replacees(replacees);
1395 goto UNWIND_REMOVE_INSTALLED_REPLACEES;
1397 err = prerm_upgrade_old_pkg(pkg, old_pkg);
1399 goto UNWIND_PRERM_UPGRADE_OLD_PKG;
1401 err = prerm_deconfigure_conflictors(pkg, replacees);
1403 goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
1405 err = preinst_configure(pkg, old_pkg);
1407 goto UNWIND_PREINST_CONFIGURE;
1409 err = backup_modified_conffiles(pkg, old_pkg);
1411 goto UNWIND_BACKUP_MODIFIED_CONFFILES;
1413 err = check_data_file_clashes(pkg, old_pkg);
1415 goto UNWIND_CHECK_DATA_FILE_CLASHES;
1417 err = postrm_upgrade_old_pkg(pkg, old_pkg);
1419 goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
1424 /* point of no return: no unwinding after this */
1425 if (old_pkg && !conf->force_reinstall) {
1426 old_pkg->state_want = SW_DEINSTALL;
1428 if (old_pkg->state_flag & SF_NOPRUNE) {
1429 opkg_msg(INFO, "Not removing obsolesced files because "
1430 "package %s marked noprune.\n",
1433 opkg_msg(INFO, "Removing obsolesced files for %s\n",
1435 if (remove_obsolesced_files(pkg, old_pkg)) {
1436 opkg_msg(ERROR, "Failed to determine "
1437 "obsolete files from previously "
1438 "installed %s\n", old_pkg->name);
1442 /* removing files from old package, to avoid ghost files */
1443 remove_data_files_and_list(old_pkg);
1444 remove_maintainer_scripts(old_pkg);
1448 opkg_msg(INFO, "Installing maintainer scripts.\n");
1449 if (install_maintainer_scripts(pkg, old_pkg)) {
1450 opkg_msg(ERROR, "Failed to extract maintainer scripts for %s."
1451 " Package debris may remain!\n",
1456 /* the following just returns 0 */
1457 remove_disappeared(pkg);
1459 opkg_msg(INFO, "Installing data files for %s.\n", pkg->name);
1461 if (install_data_files(pkg)) {
1462 opkg_msg(ERROR, "Failed to extract data files for %s. "
1463 "Package debris may remain!\n",
1468 err = check_data_file_clashes_change(pkg, old_pkg);
1470 opkg_msg(ERROR, "check_data_file_clashes_change() failed for "
1471 "for files belonging to %s.\n",
1475 opkg_msg(INFO, "Resolving conf files for %s\n", pkg->name);
1476 resolve_conffiles(pkg);
1478 pkg->state_status = SS_UNPACKED;
1479 old_state_flag = pkg->state_flag;
1480 pkg->state_flag &= ~SF_PREFER;
1481 opkg_msg(DEBUG, "pkg=%s old_state_flag=%x state_flag=%x\n",
1482 pkg->name, old_state_flag, pkg->state_flag);
1484 if (old_pkg && !conf->force_reinstall) {
1485 old_pkg->state_status = SS_NOT_INSTALLED;
1488 time(&pkg->installed_time);
1490 ab_pkg = pkg->parent;
1492 ab_pkg->state_status = pkg->state_status;
1494 sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1495 pkg_vec_free (replacees);
1499 UNWIND_POSTRM_UPGRADE_OLD_PKG:
1500 postrm_upgrade_old_pkg_unwind(pkg, old_pkg);
1501 UNWIND_CHECK_DATA_FILE_CLASHES:
1502 check_data_file_clashes_unwind(pkg, old_pkg);
1503 UNWIND_BACKUP_MODIFIED_CONFFILES:
1504 backup_modified_conffiles_unwind(pkg, old_pkg);
1505 UNWIND_PREINST_CONFIGURE:
1506 preinst_configure_unwind(pkg, old_pkg);
1507 UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1508 prerm_deconfigure_conflictors_unwind(pkg, replacees);
1509 UNWIND_PRERM_UPGRADE_OLD_PKG:
1510 prerm_upgrade_old_pkg_unwind(pkg, old_pkg);
1511 UNWIND_REMOVE_INSTALLED_REPLACEES:
1512 pkg_remove_installed_replacees_unwind(replacees);
1515 sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1517 pkg_vec_free (replacees);