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.
28 #include "pkg_extract.h"
30 #include "opkg_install.h"
31 #include "opkg_configure.h"
32 #include "opkg_download.h"
33 #include "opkg_remove.h"
35 #include "opkg_utils.h"
36 #include "opkg_message.h"
38 #include "opkg_defines.h"
40 #include "sprintf_alloc.h"
41 #include "file_util.h"
43 #include "libbb/libbb.h"
45 static int 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
,
58 "Cannot satisfy the following dependencies for %s:\n",
62 opkg_message(ERROR
, "\t%s", *unresolved
);
67 opkg_message(ERROR
, "\n");
68 if (!conf
->force_depends
) {
70 "This could mean that your package list is out of date or that the packages\n"
71 "mentioned above do not yet exist (try 'opkg update'). To proceed in spite\n"
72 "of this problem try again with the '-force-depends' option.\n");
73 pkg_vec_free(depends
);
79 pkg_vec_free(depends
);
83 /* Mark packages as to-be-installed */
84 for (i
= 0; i
< depends
->len
; i
++) {
85 /* Dependencies should be installed the same place as pkg */
86 if (depends
->pkgs
[i
]->dest
== NULL
) {
87 depends
->pkgs
[i
]->dest
= pkg
->dest
;
89 depends
->pkgs
[i
]->state_want
= SW_INSTALL
;
92 for (i
= 0; i
< depends
->len
; i
++) {
93 dep
= depends
->pkgs
[i
];
94 /* The package was uninstalled when we started, but another
95 dep earlier in this loop may have depended on it and pulled
96 it in, so check first. */
97 if ((dep
->state_status
!= SS_INSTALLED
)
98 && (dep
->state_status
!= SS_UNPACKED
)) {
99 opkg_msg(DEBUG2
, "Calling opkg_install_pkg.\n");
100 err
= opkg_install_pkg(dep
, 0);
101 /* mark this package as having been automatically installed to
102 * satisfy a dependancy */
103 dep
->auto_installed
= 1;
105 pkg_vec_free(depends
);
111 pkg_vec_free(depends
);
116 static int 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_message(level
, "\n");
138 pkg_vec_free(conflicts
);
144 static int update_file_ownership(pkg_t
* new_pkg
, pkg_t
* old_pkg
)
146 str_list_t
*new_list
, *old_list
;
147 str_list_elt_t
*iter
, *niter
;
149 new_list
= pkg_get_installed_files(new_pkg
);
150 if (new_list
== NULL
)
153 for (iter
= str_list_first(new_list
), niter
=
154 str_list_next(new_list
, iter
); iter
;
155 iter
= niter
, niter
= str_list_next(new_list
, niter
)) {
156 char *new_file
= (char *)iter
->data
;
157 pkg_t
*owner
= file_hash_get_file_owner(new_file
);
158 pkg_t
*obs
= hash_table_get(&conf
->obs_file_hash
, new_file
);
161 "%s: new_pkg=%s wants file %s, from owner=%s\n",
162 __func__
, new_pkg
->name
, new_file
,
163 owner
? owner
->name
: "<NULL>");
165 if (!owner
|| (owner
== old_pkg
) || obs
)
166 file_hash_set_file_owner(new_file
, new_pkg
);
170 old_list
= pkg_get_installed_files(old_pkg
);
171 if (old_list
== NULL
) {
172 pkg_free_installed_files(new_pkg
);
176 for (iter
= str_list_first(old_list
), niter
=
177 str_list_next(old_list
, iter
); iter
;
178 iter
= niter
, niter
= str_list_next(old_list
, niter
)) {
179 char *old_file
= (char *)iter
->data
;
180 pkg_t
*owner
= file_hash_get_file_owner(old_file
);
181 if (!owner
|| (owner
== old_pkg
)) {
183 hash_table_insert(&conf
->obs_file_hash
,
187 pkg_free_installed_files(old_pkg
);
189 pkg_free_installed_files(new_pkg
);
193 static int verify_pkg_installable(pkg_t
* pkg
)
195 unsigned long kbs_available
, pkg_size_kbs
;
196 char *root_dir
= NULL
;
199 if (conf
->force_space
|| pkg
->installed_size
== 0)
203 if (!strcmp(pkg
->dest
->name
, "root") && conf
->overlay_root
204 && !stat(conf
->overlay_root
, &s
) && (s
.st_mode
& S_IFDIR
))
205 root_dir
= conf
->overlay_root
;
207 root_dir
= pkg
->dest
->root_dir
;
211 root_dir
= conf
->default_dest
->root_dir
;
213 kbs_available
= get_available_kbytes(root_dir
);
215 pkg_size_kbs
= (pkg
->installed_size
+ 1023) / 1024;
217 if (pkg_size_kbs
>= kbs_available
) {
218 opkg_msg(ERROR
, "Only have %ldkb available on filesystem %s, "
219 "pkg %s needs %ld\n",
220 kbs_available
, root_dir
, pkg
->name
, pkg_size_kbs
);
227 static int unpack_pkg_control_files(pkg_t
* pkg
)
230 char *conffiles_file_name
;
232 FILE *conffiles_file
;
234 sprintf_alloc(&pkg
->tmp_unpack_dir
, "%s/%s-XXXXXX", conf
->tmp_dir
,
237 pkg
->tmp_unpack_dir
= mkdtemp(pkg
->tmp_unpack_dir
);
238 if (pkg
->tmp_unpack_dir
== NULL
) {
239 opkg_perror(ERROR
, "Failed to create temporary directory '%s'",
240 pkg
->tmp_unpack_dir
);
244 err
= pkg_extract_control_files_to_dir(pkg
, pkg
->tmp_unpack_dir
);
249 /* XXX: CLEANUP: There might be a cleaner place to read in the
250 conffiles. Seems like I should be able to get everything to go
251 through pkg_init_from_file. If so, maybe it would make sense to
252 move all of unpack_pkg_control_files to that function. */
254 /* Don't need to re-read conffiles if we already have it */
255 if (!nv_pair_list_empty(&pkg
->conffiles
)) {
259 sprintf_alloc(&conffiles_file_name
, "%s/conffiles",
260 pkg
->tmp_unpack_dir
);
261 if (!file_exists(conffiles_file_name
)) {
262 free(conffiles_file_name
);
266 conffiles_file
= fopen(conffiles_file_name
, "r");
267 if (conffiles_file
== NULL
) {
268 opkg_perror(ERROR
, "Failed to open %s", conffiles_file_name
);
269 free(conffiles_file_name
);
272 free(conffiles_file_name
);
276 char *cf_name_in_dest
;
279 cf_name
= file_read_line_alloc(conffiles_file
);
280 if (cf_name
== NULL
) {
283 if (cf_name
[0] == '\0') {
286 for (i
= strlen(cf_name
) - 1;
287 (i
>= 0) && (cf_name
[i
] == ' ' || cf_name
[i
] == '\t');
292 /* Prepend dest->root_dir to conffile name.
293 Take pains to avoid multiple slashes. */
294 root_dir
= pkg
->dest
->root_dir
;
295 if (conf
->offline_root
)
296 /* skip the offline_root prefix */
298 pkg
->dest
->root_dir
+ strlen(conf
->offline_root
);
299 sprintf_alloc(&cf_name_in_dest
, "%s%s", root_dir
,
300 cf_name
[0] == '/' ? (cf_name
+ 1) : cf_name
);
302 /* Can't get an md5sum now, (file isn't extracted yet).
303 We'll wait until resolve_conffiles */
304 conffile_list_append(&pkg
->conffiles
, cf_name_in_dest
, NULL
);
307 free(cf_name_in_dest
);
310 fclose(conffiles_file
);
316 * Remove packages which were auto_installed due to a dependency by old_pkg,
317 * which are no longer a dependency in the new (upgraded) pkg.
319 static int pkg_remove_orphan_dependent(pkg_t
* pkg
, pkg_t
* old_pkg
)
321 int i
, j
, k
, l
, found
, r
, err
= 0;
324 struct compound_depend
*cd0
, *cd1
;
325 abstract_pkg_t
**dependents
;
327 int count0
= old_pkg
->pre_depends_count
+
328 old_pkg
->depends_count
+
329 old_pkg
->recommends_count
+ old_pkg
->suggests_count
;
330 int count1
= pkg
->pre_depends_count
+
331 pkg
->depends_count
+ pkg
->recommends_count
+ pkg
->suggests_count
;
333 for (i
= 0; i
< count0
; i
++) {
334 cd0
= &old_pkg
->depends
[i
];
335 if (cd0
->type
!= DEPEND
)
337 for (j
= 0; j
< cd0
->possibility_count
; j
++) {
341 for (k
= 0; k
< count1
; k
++) {
342 cd1
= &pkg
->depends
[k
];
343 if (cd1
->type
!= DEPEND
)
345 for (l
= 0; l
< cd1
->possibility_count
; l
++) {
346 if (cd0
->possibilities
[j
]
347 == cd1
->possibilities
[l
]) {
360 * old_pkg has a dependency that pkg does not.
362 p
= pkg_hash_fetch_installed_by_name(cd0
->
369 if (!p
->auto_installed
)
372 n_deps
= pkg_has_installed_dependents(p
, &dependents
);
373 n_deps
--; /* don't count old_pkg */
376 opkg_msg(NOTICE
, "%s was autoinstalled and is "
377 "now orphaned, removing.\n", p
->name
);
379 /* p has one installed dependency (old_pkg),
380 * which we need to ignore during removal. */
381 p
->state_flag
|= SF_REPLACE
;
383 r
= opkg_remove_pkg(p
, 0);
387 opkg_msg(INFO
, "%s was autoinstalled and is "
388 "still required by %d "
389 "installed packages.\n",
398 /* returns number of installed replacees */
400 pkg_get_installed_replacees(pkg_t
* pkg
, pkg_vec_t
* installed_replacees
)
402 abstract_pkg_t
**replaces
= pkg
->replaces
;
403 int replaces_count
= pkg
->replaces_count
;
405 for (i
= 0; i
< replaces_count
; i
++) {
406 abstract_pkg_t
*ab_pkg
= replaces
[i
];
407 pkg_vec_t
*pkg_vec
= ab_pkg
->pkgs
;
409 for (j
= 0; j
< pkg_vec
->len
; j
++) {
410 pkg_t
*replacee
= pkg_vec
->pkgs
[j
];
411 if (!pkg_conflicts(pkg
, replacee
))
413 if (replacee
->state_status
== SS_INSTALLED
) {
414 pkg_vec_insert(installed_replacees
,
420 return installed_replacees
->len
;
423 static int pkg_remove_installed_replacees(pkg_vec_t
* replacees
)
426 int replaces_count
= replacees
->len
;
427 for (i
= 0; i
< replaces_count
; i
++) {
428 pkg_t
*replacee
= replacees
->pkgs
[i
];
430 replacee
->state_flag
|= SF_REPLACE
; /* flag it so remove won't complain */
431 err
= opkg_remove_pkg(replacee
, 0);
438 /* to unwind the removal: make sure they are installed */
439 static int pkg_remove_installed_replacees_unwind(pkg_vec_t
* replacees
)
442 int replaces_count
= replacees
->len
;
443 for (i
= 0; i
< replaces_count
; i
++) {
444 pkg_t
*replacee
= replacees
->pkgs
[i
];
445 if (replacee
->state_status
!= SS_INSTALLED
) {
446 opkg_msg(DEBUG2
, "Calling opkg_install_pkg.\n");
447 err
= opkg_install_pkg(replacee
, 0);
455 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
457 opkg_install_check_downgrade(pkg_t
* pkg
, pkg_t
* old_pkg
, int message
)
460 char message_out
[15];
461 char *old_version
= pkg_version_str_alloc(old_pkg
);
462 char *new_version
= pkg_version_str_alloc(pkg
);
463 int cmp
= pkg_compare_versions(old_pkg
, pkg
);
466 memset(message_out
, '\x0', 15);
467 strncpy(message_out
, "Upgrading ", strlen("Upgrading "));
468 if ((conf
->force_downgrade
== 1) && (cmp
> 0)) { /* We've been asked to allow downgrade and version is precedent */
469 cmp
= -1; /* then we force opkg to downgrade */
470 strncpy(message_out
, "Downgrading ", strlen("Downgrading ")); /* We need to use a value < 0 because in the 0 case we are asking to */
471 /* reinstall, and some check could fail asking the "force-reinstall" option */
475 if (!conf
->download_only
)
477 "Not downgrading package %s on %s from %s to %s.\n",
478 old_pkg
->name
, old_pkg
->dest
->name
,
479 old_version
, new_version
);
481 } else if (cmp
< 0) {
482 if (!conf
->download_only
)
484 "%s%s on %s from %s to %s...\n",
485 message_out
, pkg
->name
,
486 old_pkg
->dest
->name
, old_version
,
488 pkg
->dest
= old_pkg
->dest
;
490 } else { /* cmp == 0 */
492 if (!conf
->download_only
)
494 "%s (%s) already install on %s.\n",
495 pkg
->name
, new_version
,
496 old_pkg
->dest
->name
);
503 char message_out
[15];
504 memset(message_out
, '\x0', 15);
506 strncpy(message_out
, "Upgrading ",
507 strlen("Upgrading "));
509 strncpy(message_out
, "Installing ",
510 strlen("Installing "));
511 char *version
= pkg_version_str_alloc(pkg
);
513 if (!conf
->download_only
)
514 opkg_msg(NOTICE
, "%s%s (%s) to %s...\n", message_out
,
515 pkg
->name
, version
, pkg
->dest
->name
);
521 static int prerm_upgrade_old_pkg(pkg_t
* pkg
, pkg_t
* old_pkg
)
523 /* DPKG_INCOMPATIBILITY:
524 dpkg does some things here that we don't do yet. Do we care?
526 1. If a version of the package is already installed, call
527 old-prerm upgrade new-version
528 2. If the script runs but exits with a non-zero exit status
529 new-prerm failed-upgrade old-version
530 Error unwind, for both the above cases:
531 old-postinst abort-upgrade new-version
537 if (!old_pkg
|| !pkg
)
540 new_version
= pkg_version_str_alloc(pkg
);
542 sprintf_alloc(&script_args
, "upgrade %s", new_version
);
544 err
= pkg_run_script(old_pkg
, "prerm", script_args
);
547 opkg_msg(ERROR
, "prerm script for package \"%s\" failed\n",
554 static int prerm_upgrade_old_pkg_unwind(pkg_t
* pkg
, pkg_t
* old_pkg
)
556 /* DPKG_INCOMPATIBILITY:
557 dpkg does some things here that we don't do yet. Do we care?
558 (See prerm_upgrade_old_package for details)
563 static int prerm_deconfigure_conflictors(pkg_t
* pkg
, pkg_vec_t
* conflictors
)
565 /* DPKG_INCOMPATIBILITY:
566 dpkg does some things here that we don't do yet. Do we care?
567 2. If a 'conflicting' package is being removed at the same time:
568 1. If any packages depended on that conflicting package and
569 --auto-deconfigure is specified, call, for each such package:
570 deconfigured's-prerm deconfigure \
571 in-favour package-being-installed version \
572 removing conflicting-package version
574 deconfigured's-postinst abort-deconfigure \
575 in-favour package-being-installed-but-failed version \
576 removing conflicting-package version
578 The deconfigured packages are marked as requiring
579 configuration, so that if --install is used they will be
580 configured again if possible.
581 2. To prepare for removal of the conflicting package, call:
582 conflictor's-prerm remove in-favour package new-version
584 conflictor's-postinst abort-remove in-favour package new-version
590 prerm_deconfigure_conflictors_unwind(pkg_t
* pkg
, pkg_vec_t
* conflictors
)
592 /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
593 do yet. Do we care? (See prerm_deconfigure_conflictors for
598 static int preinst_configure(pkg_t
* pkg
, pkg_t
* old_pkg
)
604 char *old_version
= pkg_version_str_alloc(old_pkg
);
605 sprintf_alloc(&preinst_args
, "upgrade %s", old_version
);
607 } else if (pkg
->state_status
== SS_CONFIG_FILES
) {
608 char *pkg_version
= pkg_version_str_alloc(pkg
);
609 sprintf_alloc(&preinst_args
, "install %s", pkg_version
);
612 preinst_args
= xstrdup("install");
615 err
= pkg_run_script(pkg
, "preinst", preinst_args
);
617 opkg_msg(ERROR
, "Aborting installation of %s.\n", pkg
->name
);
626 static int preinst_configure_unwind(pkg_t
* pkg
, pkg_t
* old_pkg
)
628 /* DPKG_INCOMPATIBILITY:
629 dpkg does the following error unwind, should we?
630 pkg->postrm abort-upgrade old-version
631 OR pkg->postrm abort-install old-version
632 OR pkg->postrm abort-install
637 static char *backup_filename_alloc(const char *file_name
)
641 sprintf_alloc(&backup
, "%s%s", file_name
, OPKG_BACKUP_SUFFIX
);
646 static int backup_make_backup(const char *file_name
)
651 backup
= backup_filename_alloc(file_name
);
652 err
= file_copy(file_name
, backup
);
654 opkg_msg(ERROR
, "Failed to copy %s to %s\n", file_name
, backup
);
662 static int backup_exists_for(const char *file_name
)
667 backup
= backup_filename_alloc(file_name
);
669 ret
= file_exists(backup
);
676 static int backup_remove(const char *file_name
)
680 backup
= backup_filename_alloc(file_name
);
687 static int backup_modified_conffiles(pkg_t
* pkg
, pkg_t
* old_pkg
)
690 conffile_list_elt_t
*iter
;
696 /* Backup all modified conffiles */
698 for (iter
= nv_pair_list_first(&old_pkg
->conffiles
); iter
;
699 iter
= nv_pair_list_next(&old_pkg
->conffiles
, iter
)) {
703 cf_name
= root_filename_alloc(cf
->name
);
705 /* Don't worry if the conffile is just plain gone */
706 if (file_exists(cf_name
)
707 && conffile_has_been_modified(cf
)) {
708 err
= backup_make_backup(cf_name
);
717 /* Backup all conffiles that were not conffiles in old_pkg */
718 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
;
719 iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
721 cf
= (conffile_t
*) iter
->data
;
722 cf_name
= root_filename_alloc(cf
->name
);
723 /* Ignore if this was a conffile in old_pkg as well */
724 if (pkg_get_conffile(old_pkg
, cf
->name
)) {
728 if (file_exists(cf_name
) && (!backup_exists_for(cf_name
))) {
729 err
= backup_make_backup(cf_name
);
740 static int backup_modified_conffiles_unwind(pkg_t
* pkg
, pkg_t
* old_pkg
)
742 conffile_list_elt_t
*iter
;
745 for (iter
= nv_pair_list_first(&old_pkg
->conffiles
); iter
;
746 iter
= nv_pair_list_next(&old_pkg
->conffiles
, iter
)) {
747 backup_remove(((nv_pair_t
*) iter
->data
)->name
);
751 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
;
752 iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
753 backup_remove(((nv_pair_t
*) iter
->data
)->name
);
759 static int check_data_file_clashes(pkg_t
* pkg
, pkg_t
* old_pkg
)
761 /* DPKG_INCOMPATIBILITY:
762 opkg takes a slightly different approach than dpkg at this
763 point. dpkg installs each file in the new package while
764 creating a backup for any file that is replaced, (so that it
765 can unwind if necessary). To avoid complexity and redundant
766 storage, opkg doesn't do any installation until later, (at the
767 point at which dpkg removes the backups.
769 But, we do have to check for data file clashes, since after
770 installing a package with a file clash, removing either of the
771 packages involved in the clash has the potential to break the
774 str_list_t
*files_list
;
775 str_list_elt_t
*iter
, *niter
;
779 files_list
= pkg_get_installed_files(pkg
);
780 if (files_list
== NULL
)
783 for (iter
= str_list_first(files_list
), niter
=
784 str_list_next(files_list
, iter
); iter
;
785 iter
= niter
, niter
= str_list_next(files_list
, iter
)) {
786 filename
= (char *)iter
->data
;
787 if (file_exists(filename
) && (!file_is_dir(filename
))) {
791 if (backup_exists_for(filename
)) {
795 /* Pre-existing files are OK if force-overwrite was asserted. */
796 if (conf
->force_overwrite
) {
797 /* but we need to change who owns this file */
798 file_hash_set_file_owner(filename
, pkg
);
802 owner
= file_hash_get_file_owner(filename
);
804 /* Pre-existing files are OK if owned by the pkg being upgraded. */
805 if (owner
&& old_pkg
) {
806 if (strcmp(owner
->name
, old_pkg
->name
) == 0) {
811 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
814 "Checking replaces for %s in package %s\n",
815 filename
, owner
->name
);
816 if (pkg_replaces(pkg
, owner
)) {
819 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
820 then it's ok to overwrite. */
821 if (strcmp(owner
->name
, pkg
->name
) == 0) {
823 "Replacing pre-existing file %s"
824 " owned by package %s\n",
825 filename
, owner
->name
);
830 /* Pre-existing files are OK if they are obsolete */
831 obs
= hash_table_get(&conf
->obs_file_hash
, filename
);
834 "Pre-exiting file %s is obsolete."
835 " obs_pkg=%s\n", filename
, obs
->name
);
839 /* We have found a clash. */
840 opkg_msg(ERROR
, "Package %s wants to install file %s\n"
841 "\tBut that file is already provided by package ",
842 pkg
->name
, filename
);
844 opkg_message(ERROR
, "%s\n", owner
->name
);
846 opkg_message(ERROR
, "<no package>\n"
847 "Please move this file out of the way and try again.\n");
852 pkg_free_installed_files(pkg
);
858 * XXX: This function sucks, as does the below comment.
860 static int check_data_file_clashes_change(pkg_t
* pkg
, pkg_t
* old_pkg
)
862 /* Basically that's the worst hack I could do to be able to change ownership of
863 file list, but, being that we have no way to unwind the mods, due to structure
864 of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
865 What we do here is change the ownership of file in hash if a replace ( or similar events
867 Only the action that are needed to change name should be considered.
868 @@@ To change after 1.0 release.
870 str_list_t
*files_list
;
871 str_list_elt_t
*iter
, *niter
;
873 char *root_filename
= NULL
;
875 files_list
= pkg_get_installed_files(pkg
);
876 if (files_list
== NULL
)
879 for (iter
= str_list_first(files_list
), niter
=
880 str_list_next(files_list
, iter
); iter
;
881 iter
= niter
, niter
= str_list_next(files_list
, niter
)) {
882 char *filename
= (char *)iter
->data
;
885 root_filename
= NULL
;
887 root_filename
= root_filename_alloc(filename
);
888 if (file_exists(root_filename
) && (!file_is_dir(root_filename
))) {
891 owner
= file_hash_get_file_owner(filename
);
893 if (conf
->force_overwrite
) {
894 /* but we need to change who owns this file */
895 file_hash_set_file_owner(filename
, pkg
);
899 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
901 if (pkg_replaces(pkg
, owner
)) {
902 /* It's now time to change the owner of that file.
903 It has been "replaced" from the new "Replaces", then I need to inform lists file about that. */
905 "Replacing pre-existing file %s "
906 "owned by package %s\n",
907 filename
, owner
->name
);
908 file_hash_set_file_owner(filename
, pkg
);
917 root_filename
= NULL
;
919 pkg_free_installed_files(pkg
);
924 static int check_data_file_clashes_unwind(pkg_t
* pkg
, pkg_t
* old_pkg
)
926 /* Nothing to do since check_data_file_clashes doesn't change state */
930 static int postrm_upgrade_old_pkg(pkg_t
* pkg
, pkg_t
* old_pkg
)
932 /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
933 1. If the package is being upgraded, call
934 old-postrm upgrade new-version
935 2. If this fails, attempt:
936 new-postrm failed-upgrade old-version
937 Error unwind, for both cases:
938 old-preinst abort-upgrade new-version */
943 if (!old_pkg
|| !pkg
)
946 new_version
= pkg_version_str_alloc(pkg
);
948 sprintf_alloc(&script_args
, "upgrade %s", new_version
);
950 err
= pkg_run_script(old_pkg
, "postrm", script_args
);
953 opkg_msg(ERROR
, "postrm script for package \"%s\" failed\n",
960 static int postrm_upgrade_old_pkg_unwind(pkg_t
* pkg
, pkg_t
* old_pkg
)
962 /* DPKG_INCOMPATIBILITY:
963 dpkg does some things here that we don't do yet. Do we care?
964 (See postrm_upgrade_old_pkg for details)
969 static int remove_obsolesced_files(pkg_t
* pkg
, pkg_t
* old_pkg
)
972 str_list_t
*old_files
;
974 str_list_t
*new_files
;
976 hash_table_t new_files_table
;
978 old_files
= pkg_get_installed_files(old_pkg
);
979 if (old_files
== NULL
)
982 new_files
= pkg_get_installed_files(pkg
);
983 if (new_files
== NULL
) {
984 pkg_free_installed_files(old_pkg
);
988 new_files_table
.entries
= NULL
;
989 hash_table_init("new_files", &new_files_table
, 20);
990 for (nf
= str_list_first(new_files
); nf
;
991 nf
= str_list_next(new_files
, nf
)) {
993 hash_table_insert(&new_files_table
, nf
->data
, nf
->data
);
996 for (of
= str_list_first(old_files
); of
;
997 of
= str_list_next(old_files
, of
)) {
1000 old
= (char *)of
->data
;
1001 new = (char *)hash_table_get(&new_files_table
, old
);
1005 if (file_is_dir(old
)) {
1008 owner
= file_hash_get_file_owner(old
);
1009 if (owner
!= old_pkg
) {
1010 /* in case obsolete file no longer belongs to old_pkg */
1014 /* old file is obsolete */
1015 opkg_msg(NOTICE
, "Removing obsolete file %s.\n", old
);
1016 if (!conf
->noaction
) {
1019 opkg_perror(ERROR
, "unlinking %s failed", old
);
1024 hash_table_deinit(&new_files_table
);
1025 pkg_free_installed_files(old_pkg
);
1026 pkg_free_installed_files(pkg
);
1031 static int install_maintainer_scripts(pkg_t
* pkg
, pkg_t
* old_pkg
)
1036 sprintf_alloc(&prefix
, "%s.", pkg
->name
);
1037 ret
= pkg_extract_control_files_to_dir_with_prefix(pkg
,
1038 pkg
->dest
->info_dir
,
1044 static int remove_disappeared(pkg_t
* pkg
)
1046 /* DPKG_INCOMPATIBILITY:
1047 This is a fairly sophisticated dpkg operation. Shall we
1050 /* Any packages all of whose files have been overwritten during the
1051 installation, and which aren't required for dependencies, are
1052 considered to have been removed. For each such package
1053 1. disappearer's-postrm disappear overwriter overwriter-version
1054 2. The package's maintainer scripts are removed
1055 3. It is noted in the status database as being in a sane state,
1056 namely not installed (any conffiles it may have are ignored,
1057 rather than being removed by dpkg). Note that disappearing
1058 packages do not have their prerm called, because dpkg doesn't
1059 know in advance that the package is going to vanish.
1064 static int install_data_files(pkg_t
* pkg
)
1068 /* opkg takes a slightly different approach to data file backups
1069 than dpkg. Rather than removing backups at this point, we
1070 actually do the data file installation now. See comments in
1071 check_data_file_clashes() for more details. */
1073 opkg_msg(INFO
, "Extracting data files to %s.\n", pkg
->dest
->root_dir
);
1074 err
= pkg_extract_data_files_to_dir(pkg
, pkg
->dest
->root_dir
);
1079 /* The "Essential" control field may only be present in the control
1080 * file and not in the Packages list. Ensure we capture it regardless.
1082 * XXX: This should be fixed outside of opkg, in the Package list.
1084 set_flags_from_control(pkg
);
1086 opkg_msg(DEBUG
, "Calling pkg_write_filelist.\n");
1087 err
= pkg_write_filelist(pkg
);
1091 /* XXX: FEATURE: opkg should identify any files which existed
1092 before installation and which were overwritten, (see
1093 check_data_file_clashes()). What it must do is remove any such
1094 files from the filelist of the old package which provided the
1095 file. Otherwise, if the old package were removed at some point
1096 it would break the new package. Removing the new package will
1097 also break the old one, but this cannot be helped since the old
1098 package's file has already been deleted. This is the importance
1099 of check_data_file_clashes(), and only allowing opkg to install
1100 a clashing package with a user force. */
1105 static int resolve_conffiles(pkg_t
* pkg
)
1107 conffile_list_elt_t
*iter
;
1115 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
;
1116 iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
1117 char *root_filename
;
1118 cf
= (conffile_t
*) iter
->data
;
1119 root_filename
= root_filename_alloc(cf
->name
);
1121 /* Might need to initialize the md5sum for each conffile */
1122 if (cf
->value
== NULL
) {
1123 cf
->value
= file_sha256sum_alloc(root_filename
);
1126 if (!file_exists(root_filename
)) {
1127 free(root_filename
);
1131 cf_backup
= backup_filename_alloc(root_filename
);
1133 if (file_exists(cf_backup
)) {
1134 /* Let's compute md5 to test if files are changed */
1136 if (cf
->value
&& strlen(cf
->value
) > 33) {
1137 chksum
= file_sha256sum_alloc(cf_backup
);
1139 chksum
= file_md5sum_alloc(cf_backup
);
1142 chksum
= file_sha256sum_alloc(cf_backup
);
1144 if (chksum
&& cf
->value
1145 && strcmp(cf
->value
, chksum
) != 0) {
1146 if (conf
->force_maintainer
) {
1148 "Conffile %s using maintainer's setting.\n",
1152 sprintf_alloc(&new_conffile
, "%s-opkg",
1155 "Existing conffile %s "
1156 "is different from the conffile in the new package."
1157 " The new conffile will be placed at %s.\n",
1158 root_filename
, new_conffile
);
1159 rename(root_filename
, new_conffile
);
1160 rename(cf_backup
, root_filename
);
1170 free(root_filename
);
1176 int opkg_install_by_name(const char *pkg_name
)
1180 char *old_version
, *new_version
;
1182 old
= pkg_hash_fetch_installed_by_name(pkg_name
);
1184 opkg_msg(DEBUG2
, "Old versions from pkg_hash_fetch %s.\n",
1187 new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name
);
1189 opkg_msg(NOTICE
, "Unknown package '%s'.\n", pkg_name
);
1193 opkg_msg(DEBUG2
, "Versions from pkg_hash_fetch:");
1195 opkg_message(DEBUG2
, " old %s ", old
->version
);
1196 opkg_message(DEBUG2
, " new %s\n", new->version
);
1198 new->state_flag
|= SF_USER
;
1200 old_version
= pkg_version_str_alloc(old
);
1201 new_version
= pkg_version_str_alloc(new);
1203 cmp
= pkg_compare_versions(old
, new);
1204 if ((conf
->force_downgrade
== 1) && (cmp
> 0)) { /* We've been asked to allow downgrade and version is precedent */
1205 opkg_msg(DEBUG
, "Forcing downgrade\n");
1206 cmp
= -1; /* then we force opkg to downgrade */
1207 /* We need to use a value < 0 because in the 0 case we are asking to */
1208 /* reinstall, and some check could fail asking the "force-reinstall" option */
1210 opkg_msg(DEBUG
, "Comparing visible versions of pkg %s:"
1211 "\n\t%s is installed "
1212 "\n\t%s is available "
1213 "\n\t%d was comparison result\n",
1214 pkg_name
, old_version
, new_version
, cmp
);
1217 "Package %s (%s) installed in %s is up to date.\n",
1218 old
->name
, old_version
, old
->dest
->name
);
1222 } else if (cmp
> 0) {
1224 "Not downgrading package %s on %s from %s to %s.\n",
1225 old
->name
, old
->dest
->name
, old_version
,
1230 } else if (cmp
< 0) {
1231 new->dest
= old
->dest
;
1232 old
->state_want
= SW_DEINSTALL
;
1238 opkg_msg(DEBUG2
, "Calling opkg_install_pkg.\n");
1239 return opkg_install_pkg(new, 0);
1243 * @brief Really install a pkg_t
1245 int opkg_install_pkg(pkg_t
* pkg
, int from_upgrade
)
1249 pkg_t
*old_pkg
= NULL
;
1250 pkg_vec_t
*replacees
;
1251 abstract_pkg_t
*ab_pkg
= NULL
;
1257 sigset_t newset
, oldset
;
1260 message
= 1; /* Coming from an upgrade, and should change the output message */
1262 opkg_msg(DEBUG2
, "Calling pkg_arch_supported.\n");
1264 if (!pkg_arch_supported(pkg
)) {
1266 "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1267 pkg
->architecture
, pkg
->name
);
1270 if (pkg
->state_status
== SS_INSTALLED
&& conf
->nodeps
== 0) {
1271 err
= satisfy_dependencies_for(pkg
);
1275 opkg_msg(NOTICE
, "Package %s is already installed on %s.\n",
1276 pkg
->name
, pkg
->dest
->name
);
1280 if (pkg
->dest
== NULL
) {
1281 pkg
->dest
= conf
->default_dest
;
1284 old_pkg
= pkg_hash_fetch_installed_by_name(pkg
->name
);
1286 err
= opkg_install_check_downgrade(pkg
, old_pkg
, message
);
1290 pkg
->state_want
= SW_INSTALL
;
1292 old_pkg
->state_want
= SW_DEINSTALL
; /* needed for check_data_file_clashes of dependencies */
1295 err
= check_conflicts_for(pkg
);
1299 /* this setup is to remove the upgrade scenario in the end when
1300 installing pkg A, A deps B & B deps on A. So both B and A are
1301 installed. Then A's installation is started resulting in an
1302 uncecessary upgrade */
1303 if (pkg
->state_status
== SS_INSTALLED
)
1306 err
= verify_pkg_installable(pkg
);
1310 if (pkg
->local_filename
== NULL
) {
1311 if (!conf
->cache
&& conf
->download_only
) {
1313 if (getcwd(cwd
, sizeof(cwd
)) != NULL
)
1314 err
= opkg_download_pkg(pkg
, cwd
);
1318 err
= opkg_download_pkg(pkg
, conf
->tmp_dir
);
1321 opkg_msg(ERROR
, "Failed to download %s. "
1322 "Perhaps you need to run 'opkg update'?\n",
1328 /* check that the repository is valid */
1329 #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) || defined(HAVE_USIGN)
1330 char *list_file_name
, *sig_file_name
, *lists_dir
;
1332 /* check to ensure the package has come from a repository */
1333 if (conf
->check_signature
&& pkg
->src
) {
1334 sprintf_alloc(&lists_dir
, "%s", (conf
->restrict_to_default_dest
)
1335 ? conf
->default_dest
->lists_dir
1337 sprintf_alloc(&list_file_name
, "%s/%s", lists_dir
,
1339 sprintf_alloc(&sig_file_name
, "%s/%s.sig", lists_dir
,
1342 if (file_exists(sig_file_name
)) {
1343 if (opkg_verify_file(list_file_name
, sig_file_name
)) {
1345 "Failed to verify the signature of %s.\n",
1347 if (!conf
->force_signature
)
1351 opkg_msg(ERROR
, "Signature file is missing for %s. "
1352 "Perhaps you need to run 'opkg update'?\n",
1354 if (!conf
->force_signature
)
1359 free(list_file_name
);
1360 free(sig_file_name
);
1365 /* Check for md5 values */
1367 file_md5
= file_md5sum_alloc(pkg
->local_filename
);
1368 if (file_md5
&& strcmp(file_md5
, pkg
->md5sum
)) {
1369 if (!conf
->force_checksum
) {
1370 opkg_msg(ERROR
, "Package %s md5sum mismatch. "
1371 "Either the opkg or the package index are corrupt. "
1372 "Try 'opkg update'.\n", pkg
->name
);
1377 "Ignored %s md5sum mismatch.\n",
1387 /* Check for sha256 value */
1388 if (pkg
->sha256sum
) {
1389 file_sha256
= file_sha256sum_alloc(pkg
->local_filename
);
1390 if (file_sha256
&& strcmp(file_sha256
, pkg
->sha256sum
)) {
1391 if (!conf
->force_checksum
) {
1393 "Package %s sha256sum mismatch. "
1394 "Either the opkg or the package index are corrupt. "
1395 "Try 'opkg update'.\n", pkg
->name
);
1400 "Ignored %s sha256sum mismatch.\n",
1408 if (conf
->download_only
) {
1409 if (conf
->nodeps
== 0) {
1410 err
= satisfy_dependencies_for(pkg
);
1417 if (pkg
->tmp_unpack_dir
== NULL
) {
1418 if (unpack_pkg_control_files(pkg
) == -1) {
1420 "Failed to unpack control files from %s.\n",
1421 pkg
->local_filename
);
1426 err
= update_file_ownership(pkg
, old_pkg
);
1430 if (conf
->nodeps
== 0) {
1431 err
= satisfy_dependencies_for(pkg
);
1434 if (pkg
->state_status
== SS_UNPACKED
)
1435 /* Circular dependency has installed it for us. */
1439 replacees
= pkg_vec_alloc();
1440 pkg_get_installed_replacees(pkg
, replacees
);
1442 /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1444 sigemptyset(&newset
);
1445 sigaddset(&newset
, SIGINT
);
1446 sigprocmask(SIG_BLOCK
, &newset
, &oldset
);
1448 opkg_state_changed
++;
1449 pkg
->state_flag
|= SF_FILELIST_CHANGED
;
1452 pkg_remove_orphan_dependent(pkg
, old_pkg
);
1453 old_pkg
->is_upgrade
= 1;
1454 pkg
->is_upgrade
= 1;
1456 /* XXX: BUG: we really should treat replacement more like an upgrade
1457 * Instead, we're going to remove the replacees
1459 err
= pkg_remove_installed_replacees(replacees
);
1461 goto UNWIND_REMOVE_INSTALLED_REPLACEES
;
1463 err
= prerm_upgrade_old_pkg(pkg
, old_pkg
);
1465 goto UNWIND_PRERM_UPGRADE_OLD_PKG
;
1467 err
= prerm_deconfigure_conflictors(pkg
, replacees
);
1469 goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS
;
1471 err
= preinst_configure(pkg
, old_pkg
);
1473 goto UNWIND_PREINST_CONFIGURE
;
1475 err
= backup_modified_conffiles(pkg
, old_pkg
);
1477 goto UNWIND_BACKUP_MODIFIED_CONFFILES
;
1479 err
= check_data_file_clashes(pkg
, old_pkg
);
1481 goto UNWIND_CHECK_DATA_FILE_CLASHES
;
1483 err
= postrm_upgrade_old_pkg(pkg
, old_pkg
);
1485 goto UNWIND_POSTRM_UPGRADE_OLD_PKG
;
1490 /* point of no return: no unwinding after this */
1492 old_pkg
->state_want
= SW_DEINSTALL
;
1494 if (old_pkg
->state_flag
& SF_NOPRUNE
) {
1495 opkg_msg(INFO
, "Not removing obsolesced files because "
1496 "package %s marked noprune.\n", old_pkg
->name
);
1498 opkg_msg(INFO
, "Removing obsolesced files for %s\n",
1500 if (remove_obsolesced_files(pkg
, old_pkg
)) {
1501 opkg_msg(ERROR
, "Failed to determine "
1502 "obsolete files from previously "
1503 "installed %s\n", old_pkg
->name
);
1507 /* removing files from old package, to avoid ghost files */
1508 remove_data_files_and_list(old_pkg
);
1509 remove_maintainer_scripts(old_pkg
);
1512 opkg_msg(INFO
, "%s maintainer scripts.\n",
1513 (pkg
->is_upgrade
) ? ("Upgrading") : ("Installing"));
1514 if (install_maintainer_scripts(pkg
, old_pkg
)) {
1515 opkg_msg(ERROR
, "Failed to extract maintainer scripts for %s."
1516 " Package debris may remain!\n", pkg
->name
);
1520 /* the following just returns 0 */
1521 remove_disappeared(pkg
);
1523 opkg_msg(INFO
, "Installing data files for %s.\n", pkg
->name
);
1525 if (install_data_files(pkg
)) {
1526 opkg_msg(ERROR
, "Failed to extract data files for %s. "
1527 "Package debris may remain!\n", pkg
->name
);
1531 err
= check_data_file_clashes_change(pkg
, old_pkg
);
1533 opkg_msg(ERROR
, "check_data_file_clashes_change() failed for "
1534 "for files belonging to %s.\n", pkg
->name
);
1537 opkg_msg(INFO
, "Resolving conf files for %s\n", pkg
->name
);
1538 resolve_conffiles(pkg
);
1540 pkg
->state_status
= SS_UNPACKED
;
1541 old_state_flag
= pkg
->state_flag
;
1542 pkg
->state_flag
&= ~SF_PREFER
;
1543 opkg_msg(DEBUG
, "pkg=%s old_state_flag=%x state_flag=%x\n",
1544 pkg
->name
, old_state_flag
, pkg
->state_flag
);
1547 old_pkg
->state_status
= SS_NOT_INSTALLED
;
1549 time(&pkg
->installed_time
);
1551 ab_pkg
= pkg
->parent
;
1553 ab_pkg
->state_status
= pkg
->state_status
;
1555 sigprocmask(SIG_UNBLOCK
, &newset
, &oldset
);
1556 pkg_vec_free(replacees
);
1559 UNWIND_POSTRM_UPGRADE_OLD_PKG
:
1560 postrm_upgrade_old_pkg_unwind(pkg
, old_pkg
);
1561 UNWIND_CHECK_DATA_FILE_CLASHES
:
1562 check_data_file_clashes_unwind(pkg
, old_pkg
);
1563 UNWIND_BACKUP_MODIFIED_CONFFILES
:
1564 backup_modified_conffiles_unwind(pkg
, old_pkg
);
1565 UNWIND_PREINST_CONFIGURE
:
1566 preinst_configure_unwind(pkg
, old_pkg
);
1567 UNWIND_PRERM_DECONFIGURE_CONFLICTORS
:
1568 prerm_deconfigure_conflictors_unwind(pkg
, replacees
);
1569 UNWIND_PRERM_UPGRADE_OLD_PKG
:
1570 prerm_upgrade_old_pkg_unwind(pkg
, old_pkg
);
1571 UNWIND_REMOVE_INSTALLED_REPLACEES
:
1572 pkg_remove_installed_replacees_unwind(replacees
);
1575 sigprocmask(SIG_UNBLOCK
, &newset
, &oldset
);
1577 pkg_vec_free(replacees
);