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"
46 satisfy_dependencies_for(pkg_t
*pkg
)
49 pkg_vec_t
*depends
= pkg_vec_alloc();
51 char **tmp
, **unresolved
= NULL
;
54 ndepends
= pkg_hash_fetch_unsatisfied_dependencies(pkg
, depends
,
58 opkg_msg(ERROR
, "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
);
117 check_conflicts_for(pkg_t
*pkg
)
120 pkg_vec_t
*conflicts
= NULL
;
121 message_level_t level
;
123 if (conf
->force_depends
) {
129 if (!conf
->force_depends
)
130 conflicts
= pkg_hash_fetch_conflicts(pkg
);
133 opkg_msg(level
, "The following packages conflict with %s:\n",
136 while (i
< conflicts
->len
)
137 opkg_msg(level
, "\t%s", conflicts
->pkgs
[i
++]->name
);
138 opkg_message(level
, "\n");
139 pkg_vec_free(conflicts
);
146 update_file_ownership(pkg_t
*new_pkg
, pkg_t
*old_pkg
)
148 str_list_t
*new_list
, *old_list
;
149 str_list_elt_t
*iter
, *niter
;
151 new_list
= pkg_get_installed_files(new_pkg
);
152 if (new_list
== NULL
)
155 for (iter
= str_list_first(new_list
), niter
= str_list_next(new_list
, iter
);
157 iter
= niter
, niter
= str_list_next(new_list
, niter
)) {
158 char *new_file
= (char *)iter
->data
;
159 pkg_t
*owner
= file_hash_get_file_owner(new_file
);
160 pkg_t
*obs
= hash_table_get(&conf
->obs_file_hash
, new_file
);
162 opkg_msg(DEBUG2
, "%s: new_pkg=%s wants file %s, from owner=%s\n",
163 __func__
, new_pkg
->name
, new_file
, 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
= str_list_next(old_list
, 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
, old_file
, old_pkg
);
186 pkg_free_installed_files(old_pkg
);
188 pkg_free_installed_files(new_pkg
);
193 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)
204 if (!strcmp(pkg
->dest
->name
, "root") && conf
->overlay_root
205 && !stat(conf
->overlay_root
, &s
) && (s
.st_mode
& S_IFDIR
))
206 root_dir
= conf
->overlay_root
;
208 root_dir
= pkg
->dest
->root_dir
;
212 root_dir
= conf
->default_dest
->root_dir
;
214 kbs_available
= get_available_kbytes(root_dir
);
216 pkg_size_kbs
= (pkg
->installed_size
+ 1023)/1024;
218 if (pkg_size_kbs
>= kbs_available
) {
219 opkg_msg(ERROR
, "Only have %ldkb available on filesystem %s, "
220 "pkg %s needs %ld\n",
221 kbs_available
, root_dir
, pkg
->name
, pkg_size_kbs
);
229 unpack_pkg_control_files(pkg_t
*pkg
)
232 char *conffiles_file_name
;
234 FILE *conffiles_file
;
236 sprintf_alloc(&pkg
->tmp_unpack_dir
, "%s/%s-XXXXXX", conf
->tmp_dir
, pkg
->name
);
238 pkg
->tmp_unpack_dir
= mkdtemp(pkg
->tmp_unpack_dir
);
239 if (pkg
->tmp_unpack_dir
== NULL
) {
240 opkg_perror(ERROR
, "Failed to create temporary directory '%s'",
241 pkg
->tmp_unpack_dir
);
245 err
= pkg_extract_control_files_to_dir(pkg
, pkg
->tmp_unpack_dir
);
250 /* XXX: CLEANUP: There might be a cleaner place to read in the
251 conffiles. Seems like I should be able to get everything to go
252 through pkg_init_from_file. If so, maybe it would make sense to
253 move all of unpack_pkg_control_files to that function. */
255 /* Don't need to re-read conffiles if we already have it */
256 if (!nv_pair_list_empty(&pkg
->conffiles
)) {
260 sprintf_alloc(&conffiles_file_name
, "%s/conffiles", 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');
293 /* Prepend dest->root_dir to conffile name.
294 Take pains to avoid multiple slashes. */
295 root_dir
= pkg
->dest
->root_dir
;
296 if (conf
->offline_root
)
297 /* skip the offline_root prefix */
298 root_dir
= 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.
320 pkg_remove_orphan_dependent(pkg_t
*pkg
, pkg_t
*old_pkg
)
322 int i
, j
, k
, l
, found
,r
, err
= 0;
325 struct compound_depend
*cd0
, *cd1
;
326 abstract_pkg_t
**dependents
;
328 int count0
= old_pkg
->pre_depends_count
+
329 old_pkg
->depends_count
+
330 old_pkg
->recommends_count
+
331 old_pkg
->suggests_count
;
332 int count1
= pkg
->pre_depends_count
+
334 pkg
->recommends_count
+
337 for (i
=0; i
<count0
; i
++) {
338 cd0
= &old_pkg
->depends
[i
];
339 if (cd0
->type
!= DEPEND
)
341 for (j
=0; j
<cd0
->possibility_count
; j
++) {
345 for (k
=0; k
<count1
; k
++) {
346 cd1
= &pkg
->depends
[k
];
347 if (cd1
->type
!= DEPEND
)
349 for (l
=0; l
<cd1
->possibility_count
; l
++) {
350 if (cd0
->possibilities
[j
]
351 == cd1
->possibilities
[l
]) {
364 * old_pkg has a dependency that pkg does not.
366 p
= pkg_hash_fetch_installed_by_name(
367 cd0
->possibilities
[j
]->pkg
->name
);
372 if (!p
->auto_installed
)
375 n_deps
= pkg_has_installed_dependents(p
, &dependents
);
376 n_deps
--; /* don't count old_pkg */
379 opkg_msg(NOTICE
, "%s was autoinstalled and is "
380 "now orphaned, removing.\n",
383 /* p has one installed dependency (old_pkg),
384 * which we need to ignore during removal. */
385 p
->state_flag
|= SF_REPLACE
;
387 r
= opkg_remove_pkg(p
, 0);
391 opkg_msg(INFO
, "%s was autoinstalled and is "
392 "still required by %d "
393 "installed packages.\n",
402 /* returns number of installed replacees */
404 pkg_get_installed_replacees(pkg_t
*pkg
, pkg_vec_t
*installed_replacees
)
406 abstract_pkg_t
**replaces
= pkg
->replaces
;
407 int replaces_count
= pkg
->replaces_count
;
409 for (i
= 0; i
< replaces_count
; i
++) {
410 abstract_pkg_t
*ab_pkg
= replaces
[i
];
411 pkg_vec_t
*pkg_vec
= ab_pkg
->pkgs
;
413 for (j
= 0; j
< pkg_vec
->len
; j
++) {
414 pkg_t
*replacee
= pkg_vec
->pkgs
[j
];
415 if (!pkg_conflicts(pkg
, replacee
))
417 if (replacee
->state_status
== SS_INSTALLED
) {
418 pkg_vec_insert(installed_replacees
, replacee
);
423 return installed_replacees
->len
;
427 pkg_remove_installed_replacees(pkg_vec_t
*replacees
)
430 int replaces_count
= replacees
->len
;
431 for (i
= 0; i
< replaces_count
; i
++) {
432 pkg_t
*replacee
= replacees
->pkgs
[i
];
434 replacee
->state_flag
|= SF_REPLACE
; /* flag it so remove won't complain */
435 err
= opkg_remove_pkg(replacee
, 0);
442 /* to unwind the removal: make sure they are installed */
444 pkg_remove_installed_replacees_unwind(pkg_vec_t
*replacees
)
447 int replaces_count
= replacees
->len
;
448 for (i
= 0; i
< replaces_count
; i
++) {
449 pkg_t
*replacee
= replacees
->pkgs
[i
];
450 if (replacee
->state_status
!= SS_INSTALLED
) {
451 opkg_msg(DEBUG2
, "Calling opkg_install_pkg.\n");
452 err
= opkg_install_pkg(replacee
, 0);
460 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
462 opkg_install_check_downgrade(pkg_t
*pkg
, pkg_t
*old_pkg
, int message
)
465 char message_out
[15];
466 char *old_version
= pkg_version_str_alloc(old_pkg
);
467 char *new_version
= pkg_version_str_alloc(pkg
);
468 int cmp
= pkg_compare_versions(old_pkg
, pkg
);
471 memset(message_out
,'\x0',15);
472 strncpy (message_out
,"Upgrading ",strlen("Upgrading "));
473 if ( (conf
->force_downgrade
==1) && (cmp
> 0) ){ /* We've been asked to allow downgrade and version is precedent */
474 cmp
= -1 ; /* then we force opkg to downgrade */
475 strncpy (message_out
,"Downgrading ",strlen("Downgrading ")); /* We need to use a value < 0 because in the 0 case we are asking to */
476 /* reinstall, and some check could fail asking the "force-reinstall" option */
480 if(!conf
->download_only
)
482 "Not downgrading package %s on %s from %s to %s.\n",
483 old_pkg
->name
, old_pkg
->dest
->name
, old_version
, new_version
);
485 } else if (cmp
< 0) {
486 if(!conf
->download_only
)
487 opkg_msg(NOTICE
, "%s%s on %s from %s to %s...\n",
488 message_out
, pkg
->name
, old_pkg
->dest
->name
, old_version
, new_version
);
489 pkg
->dest
= old_pkg
->dest
;
491 } else /* cmp == 0 */ {
492 if(!conf
->download_only
)
493 opkg_msg(NOTICE
, "%s (%s) already install on %s.\n",
494 pkg
->name
, new_version
, old_pkg
->dest
->name
);
501 char message_out
[15] ;
502 memset(message_out
,'\x0',15);
504 strncpy( message_out
,"Upgrading ",strlen("Upgrading ") );
506 strncpy( message_out
,"Installing ",strlen("Installing ") );
507 char *version
= pkg_version_str_alloc(pkg
);
509 if(!conf
->download_only
)
510 opkg_msg(NOTICE
, "%s%s (%s) to %s...\n", message_out
,
511 pkg
->name
, version
, pkg
->dest
->name
);
519 prerm_upgrade_old_pkg(pkg_t
*pkg
, pkg_t
*old_pkg
)
521 /* DPKG_INCOMPATIBILITY:
522 dpkg does some things here that we don't do yet. Do we care?
524 1. If a version of the package is already installed, call
525 old-prerm upgrade new-version
526 2. If the script runs but exits with a non-zero exit status
527 new-prerm failed-upgrade old-version
528 Error unwind, for both the above cases:
529 old-postinst abort-upgrade new-version
535 if (!old_pkg
|| !pkg
)
538 new_version
= pkg_version_str_alloc(pkg
);
540 sprintf_alloc(&script_args
, "upgrade %s", new_version
);
542 err
= pkg_run_script(old_pkg
, "prerm", script_args
);
545 opkg_msg(ERROR
, "prerm script for package \"%s\" failed\n",
553 prerm_upgrade_old_pkg_unwind(pkg_t
*pkg
, pkg_t
*old_pkg
)
555 /* DPKG_INCOMPATIBILITY:
556 dpkg does some things here that we don't do yet. Do we care?
557 (See prerm_upgrade_old_package for details)
563 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
599 preinst_configure(pkg_t
*pkg
, pkg_t
*old_pkg
)
605 char *old_version
= pkg_version_str_alloc(old_pkg
);
606 sprintf_alloc(&preinst_args
, "upgrade %s", old_version
);
608 } else if (pkg
->state_status
== SS_CONFIG_FILES
) {
609 char *pkg_version
= pkg_version_str_alloc(pkg
);
610 sprintf_alloc(&preinst_args
, "install %s", pkg_version
);
613 preinst_args
= xstrdup("install");
616 err
= pkg_run_script(pkg
, "preinst", preinst_args
);
618 opkg_msg(ERROR
, "Aborting installation of %s.\n", pkg
->name
);
628 preinst_configure_unwind(pkg_t
*pkg
, pkg_t
*old_pkg
)
630 /* DPKG_INCOMPATIBILITY:
631 dpkg does the following error unwind, should we?
632 pkg->postrm abort-upgrade old-version
633 OR pkg->postrm abort-install old-version
634 OR pkg->postrm abort-install
640 backup_filename_alloc(const char *file_name
)
644 sprintf_alloc(&backup
, "%s%s", file_name
, OPKG_BACKUP_SUFFIX
);
651 backup_make_backup(const char *file_name
)
656 backup
= backup_filename_alloc(file_name
);
657 err
= file_copy(file_name
, backup
);
659 opkg_msg(ERROR
, "Failed to copy %s to %s\n",
669 backup_exists_for(const char *file_name
)
674 backup
= backup_filename_alloc(file_name
);
676 ret
= file_exists(backup
);
684 backup_remove(const char *file_name
)
688 backup
= backup_filename_alloc(file_name
);
696 backup_modified_conffiles(pkg_t
*pkg
, pkg_t
*old_pkg
)
699 conffile_list_elt_t
*iter
;
702 if (conf
->noaction
) return 0;
704 /* Backup all modified conffiles */
706 for (iter
= nv_pair_list_first(&old_pkg
->conffiles
); iter
; iter
= nv_pair_list_next(&old_pkg
->conffiles
, iter
)) {
710 cf_name
= root_filename_alloc(cf
->name
);
712 /* Don't worry if the conffile is just plain gone */
713 if (file_exists(cf_name
) && conffile_has_been_modified(cf
)) {
714 err
= backup_make_backup(cf_name
);
723 /* Backup all conffiles that were not conffiles in old_pkg */
724 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
; iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
726 cf
= (conffile_t
*)iter
->data
;
727 cf_name
= root_filename_alloc(cf
->name
);
728 /* Ignore if this was a conffile in old_pkg as well */
729 if (pkg_get_conffile(old_pkg
, cf
->name
)) {
733 if (file_exists(cf_name
) && (! backup_exists_for(cf_name
))) {
734 err
= backup_make_backup(cf_name
);
746 backup_modified_conffiles_unwind(pkg_t
*pkg
, pkg_t
*old_pkg
)
748 conffile_list_elt_t
*iter
;
751 for (iter
= nv_pair_list_first(&old_pkg
->conffiles
); iter
; iter
= nv_pair_list_next(&old_pkg
->conffiles
, iter
)) {
752 backup_remove(((nv_pair_t
*)iter
->data
)->name
);
756 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
; iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
757 backup_remove(((nv_pair_t
*)iter
->data
)->name
);
765 check_data_file_clashes(pkg_t
*pkg
, pkg_t
*old_pkg
)
767 /* DPKG_INCOMPATIBILITY:
768 opkg takes a slightly different approach than dpkg at this
769 point. dpkg installs each file in the new package while
770 creating a backup for any file that is replaced, (so that it
771 can unwind if necessary). To avoid complexity and redundant
772 storage, opkg doesn't do any installation until later, (at the
773 point at which dpkg removes the backups.
775 But, we do have to check for data file clashes, since after
776 installing a package with a file clash, removing either of the
777 packages involved in the clash has the potential to break the
780 str_list_t
*files_list
;
781 str_list_elt_t
*iter
, *niter
;
785 files_list
= pkg_get_installed_files(pkg
);
786 if (files_list
== NULL
)
789 for (iter
= str_list_first(files_list
), niter
= str_list_next(files_list
, iter
);
791 iter
= niter
, niter
= str_list_next(files_list
, iter
)) {
792 filename
= (char *) iter
->data
;
793 if (file_exists(filename
) && (! file_is_dir(filename
))) {
797 if (backup_exists_for(filename
)) {
801 /* Pre-existing files are OK if force-overwrite was asserted. */
802 if (conf
->force_overwrite
) {
803 /* but we need to change who owns this file */
804 file_hash_set_file_owner(filename
, pkg
);
808 owner
= file_hash_get_file_owner(filename
);
810 /* Pre-existing files are OK if owned by the pkg being upgraded. */
811 if (owner
&& old_pkg
) {
812 if (strcmp(owner
->name
, old_pkg
->name
) == 0) {
817 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
819 opkg_msg(DEBUG2
, "Checking replaces for %s in package %s\n",
820 filename
, owner
->name
);
821 if (pkg_replaces(pkg
, owner
)) {
824 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
825 then it's ok to overwrite. */
826 if (strcmp(owner
->name
,pkg
->name
)==0){
827 opkg_msg(INFO
, "Replacing pre-existing file %s"
828 " owned by package %s\n",
829 filename
, owner
->name
);
834 /* Pre-existing files are OK if they are obsolete */
835 obs
= hash_table_get(&conf
->obs_file_hash
, filename
);
837 opkg_msg(INFO
, "Pre-exiting file %s is obsolete."
839 filename
, obs
->name
);
843 /* We have found a clash. */
844 opkg_msg(ERROR
, "Package %s wants to install file %s\n"
845 "\tBut that file is already provided by package ",
846 pkg
->name
, filename
);
848 opkg_message(ERROR
, "%s\n", owner
->name
);
850 opkg_message(ERROR
, "<no package>\n"
851 "Please move this file out of the way and try again.\n");
856 pkg_free_installed_files(pkg
);
862 * XXX: This function sucks, as does the below comment.
865 check_data_file_clashes_change(pkg_t
*pkg
, pkg_t
*old_pkg
)
867 /* Basically that's the worst hack I could do to be able to change ownership of
868 file list, but, being that we have no way to unwind the mods, due to structure
869 of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
870 What we do here is change the ownership of file in hash if a replace ( or similar events
872 Only the action that are needed to change name should be considered.
873 @@@ To change after 1.0 release.
875 str_list_t
*files_list
;
876 str_list_elt_t
*iter
, *niter
;
878 char *root_filename
= NULL
;
880 files_list
= pkg_get_installed_files(pkg
);
881 if (files_list
== NULL
)
884 for (iter
= str_list_first(files_list
), niter
= str_list_next(files_list
, iter
);
886 iter
= niter
, niter
= str_list_next(files_list
, niter
)) {
887 char *filename
= (char *) iter
->data
;
890 root_filename
= NULL
;
892 root_filename
= root_filename_alloc(filename
);
893 if (file_exists(root_filename
) && (! file_is_dir(root_filename
))) {
896 owner
= file_hash_get_file_owner(filename
);
898 if (conf
->force_overwrite
) {
899 /* but we need to change who owns this file */
900 file_hash_set_file_owner(filename
, pkg
);
905 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
907 if (pkg_replaces(pkg
, owner
)) {
908 /* It's now time to change the owner of that file.
909 It has been "replaced" from the new "Replaces", then I need to inform lists file about that. */
910 opkg_msg(INFO
, "Replacing pre-existing file %s "
911 "owned by package %s\n",
912 filename
, owner
->name
);
913 file_hash_set_file_owner(filename
, pkg
);
922 root_filename
= NULL
;
924 pkg_free_installed_files(pkg
);
930 check_data_file_clashes_unwind(pkg_t
*pkg
, pkg_t
*old_pkg
)
932 /* Nothing to do since check_data_file_clashes doesn't change state */
937 postrm_upgrade_old_pkg(pkg_t
*pkg
, pkg_t
*old_pkg
)
939 /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
940 1. If the package is being upgraded, call
941 old-postrm upgrade new-version
942 2. If this fails, attempt:
943 new-postrm failed-upgrade old-version
944 Error unwind, for both cases:
945 old-preinst abort-upgrade new-version */
950 if (!old_pkg
|| !pkg
)
953 new_version
= pkg_version_str_alloc(pkg
);
955 sprintf_alloc(&script_args
, "upgrade %s", new_version
);
957 err
= pkg_run_script(old_pkg
, "postrm", script_args
);
960 opkg_msg(ERROR
, "postrm script for package \"%s\" failed\n",
968 postrm_upgrade_old_pkg_unwind(pkg_t
*pkg
, pkg_t
*old_pkg
)
970 /* DPKG_INCOMPATIBILITY:
971 dpkg does some things here that we don't do yet. Do we care?
972 (See postrm_upgrade_old_pkg for details)
978 remove_obsolesced_files(pkg_t
*pkg
, pkg_t
*old_pkg
)
981 str_list_t
*old_files
;
983 str_list_t
*new_files
;
985 hash_table_t new_files_table
;
987 old_files
= pkg_get_installed_files(old_pkg
);
988 if (old_files
== NULL
)
991 new_files
= pkg_get_installed_files(pkg
);
992 if (new_files
== NULL
) {
993 pkg_free_installed_files(old_pkg
);
997 new_files_table
.entries
= NULL
;
998 hash_table_init("new_files" , &new_files_table
, 20);
999 for (nf
= str_list_first(new_files
); nf
; nf
= str_list_next(new_files
, nf
)) {
1001 hash_table_insert(&new_files_table
, nf
->data
, nf
->data
);
1004 for (of
= str_list_first(old_files
); of
; of
= str_list_next(old_files
, of
)) {
1007 old
= (char *)of
->data
;
1008 new = (char *) hash_table_get (&new_files_table
, old
);
1012 if (file_is_dir(old
)) {
1015 owner
= file_hash_get_file_owner(old
);
1016 if (owner
!= old_pkg
) {
1017 /* in case obsolete file no longer belongs to old_pkg */
1021 /* old file is obsolete */
1022 opkg_msg(NOTICE
, "Removing obsolete file %s.\n", old
);
1023 if (!conf
->noaction
) {
1026 opkg_perror(ERROR
, "unlinking %s failed", old
);
1031 hash_table_deinit(&new_files_table
);
1032 pkg_free_installed_files(old_pkg
);
1033 pkg_free_installed_files(pkg
);
1039 install_maintainer_scripts(pkg_t
*pkg
, pkg_t
*old_pkg
)
1044 sprintf_alloc(&prefix
, "%s.", pkg
->name
);
1045 ret
= pkg_extract_control_files_to_dir_with_prefix(pkg
,
1046 pkg
->dest
->info_dir
,
1053 remove_disappeared(pkg_t
*pkg
)
1055 /* DPKG_INCOMPATIBILITY:
1056 This is a fairly sophisticated dpkg operation. Shall we
1059 /* Any packages all of whose files have been overwritten during the
1060 installation, and which aren't required for dependencies, are
1061 considered to have been removed. For each such package
1062 1. disappearer's-postrm disappear overwriter overwriter-version
1063 2. The package's maintainer scripts are removed
1064 3. It is noted in the status database as being in a sane state,
1065 namely not installed (any conffiles it may have are ignored,
1066 rather than being removed by dpkg). Note that disappearing
1067 packages do not have their prerm called, because dpkg doesn't
1068 know in advance that the package is going to vanish.
1074 install_data_files(pkg_t
*pkg
)
1078 /* opkg takes a slightly different approach to data file backups
1079 than dpkg. Rather than removing backups at this point, we
1080 actually do the data file installation now. See comments in
1081 check_data_file_clashes() for more details. */
1083 opkg_msg(INFO
, "Extracting data files to %s.\n", pkg
->dest
->root_dir
);
1084 err
= pkg_extract_data_files_to_dir(pkg
, pkg
->dest
->root_dir
);
1089 /* The "Essential" control field may only be present in the control
1090 * file and not in the Packages list. Ensure we capture it regardless.
1092 * XXX: This should be fixed outside of opkg, in the Package list.
1094 set_flags_from_control(pkg
) ;
1096 opkg_msg(DEBUG
, "Calling pkg_write_filelist.\n");
1097 err
= pkg_write_filelist(pkg
);
1101 /* XXX: FEATURE: opkg should identify any files which existed
1102 before installation and which were overwritten, (see
1103 check_data_file_clashes()). What it must do is remove any such
1104 files from the filelist of the old package which provided the
1105 file. Otherwise, if the old package were removed at some point
1106 it would break the new package. Removing the new package will
1107 also break the old one, but this cannot be helped since the old
1108 package's file has already been deleted. This is the importance
1109 of check_data_file_clashes(), and only allowing opkg to install
1110 a clashing package with a user force. */
1116 resolve_conffiles(pkg_t
*pkg
)
1118 conffile_list_elt_t
*iter
;
1123 if (conf
->noaction
) return 0;
1125 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
; iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
1126 char *root_filename
;
1127 cf
= (conffile_t
*)iter
->data
;
1128 root_filename
= root_filename_alloc(cf
->name
);
1130 /* Might need to initialize the md5sum for each conffile */
1131 if (cf
->value
== NULL
) {
1132 cf
->value
= file_sha256sum_alloc(root_filename
);
1135 if (!file_exists(root_filename
)) {
1136 free(root_filename
);
1140 cf_backup
= backup_filename_alloc(root_filename
);
1142 if (file_exists(cf_backup
)) {
1143 /* Let's compute md5 to test if files are changed */
1145 if(cf
->value
&& strlen(cf
->value
) > 33) {
1146 chksum
= file_sha256sum_alloc(cf_backup
);
1148 chksum
= file_md5sum_alloc(cf_backup
);
1151 chksum
= file_sha256sum_alloc(cf_backup
);
1153 if (chksum
&& cf
->value
&& strcmp(cf
->value
,chksum
) != 0 ) {
1154 if (conf
->force_maintainer
) {
1155 opkg_msg(NOTICE
, "Conffile %s using maintainer's setting.\n",
1159 sprintf_alloc(&new_conffile
, "%s-opkg", root_filename
);
1160 opkg_msg(ERROR
, "Existing conffile %s "
1161 "is different from the conffile in the new package."
1162 " The new conffile will be placed at %s.\n",
1163 root_filename
, new_conffile
);
1164 rename(root_filename
, new_conffile
);
1165 rename(cf_backup
, root_filename
);
1175 free(root_filename
);
1183 opkg_install_by_name(const char *pkg_name
)
1187 char *old_version
, *new_version
;
1189 old
= pkg_hash_fetch_installed_by_name(pkg_name
);
1191 opkg_msg(DEBUG2
, "Old versions from pkg_hash_fetch %s.\n",
1194 new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name
);
1196 opkg_msg(NOTICE
, "Unknown package '%s'.\n", pkg_name
);
1200 opkg_msg(DEBUG2
, "Versions from pkg_hash_fetch:");
1202 opkg_message(DEBUG2
, " old %s ", old
->version
);
1203 opkg_message(DEBUG2
, " new %s\n", new->version
);
1205 new->state_flag
|= SF_USER
;
1207 old_version
= pkg_version_str_alloc(old
);
1208 new_version
= pkg_version_str_alloc(new);
1210 cmp
= pkg_compare_versions(old
, new);
1211 if ( (conf
->force_downgrade
==1) && (cmp
> 0) ){ /* We've been asked to allow downgrade and version is precedent */
1212 opkg_msg(DEBUG
, "Forcing downgrade\n");
1213 cmp
= -1 ; /* then we force opkg to downgrade */
1214 /* We need to use a value < 0 because in the 0 case we are asking to */
1215 /* reinstall, and some check could fail asking the "force-reinstall" option */
1217 opkg_msg(DEBUG
, "Comparing visible versions of pkg %s:"
1218 "\n\t%s is installed "
1219 "\n\t%s is available "
1220 "\n\t%d was comparison result\n",
1221 pkg_name
, old_version
, new_version
, cmp
);
1224 "Package %s (%s) installed in %s is up to date.\n",
1225 old
->name
, old_version
, old
->dest
->name
);
1229 } else if (cmp
> 0) {
1231 "Not downgrading package %s on %s from %s to %s.\n",
1232 old
->name
, old
->dest
->name
, old_version
, new_version
);
1236 } else if (cmp
< 0) {
1237 new->dest
= old
->dest
;
1238 old
->state_want
= SW_DEINSTALL
;
1244 opkg_msg(DEBUG2
,"Calling opkg_install_pkg.\n");
1245 return opkg_install_pkg(new, 0);
1249 * @brief Really install a pkg_t
1252 opkg_install_pkg(pkg_t
*pkg
, int from_upgrade
)
1256 pkg_t
*old_pkg
= NULL
;
1257 pkg_vec_t
*replacees
;
1258 abstract_pkg_t
*ab_pkg
= NULL
;
1264 sigset_t newset
, oldset
;
1267 message
= 1; /* Coming from an upgrade, and should change the output message */
1269 opkg_msg(DEBUG2
, "Calling pkg_arch_supported.\n");
1271 if (!pkg_arch_supported(pkg
)) {
1272 opkg_msg(ERROR
, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1273 pkg
->architecture
, pkg
->name
);
1276 if (pkg
->state_status
== SS_INSTALLED
&& conf
->nodeps
== 0) {
1277 err
= satisfy_dependencies_for(pkg
);
1281 opkg_msg(NOTICE
, "Package %s is already installed on %s.\n",
1282 pkg
->name
, pkg
->dest
->name
);
1286 if (pkg
->dest
== NULL
) {
1287 pkg
->dest
= conf
->default_dest
;
1290 old_pkg
= pkg_hash_fetch_installed_by_name(pkg
->name
);
1292 err
= opkg_install_check_downgrade(pkg
, old_pkg
, message
);
1296 pkg
->state_want
= SW_INSTALL
;
1298 old_pkg
->state_want
= SW_DEINSTALL
; /* needed for check_data_file_clashes of dependencies */
1301 err
= check_conflicts_for(pkg
);
1305 /* this setup is to remove the upgrade scenario in the end when
1306 installing pkg A, A deps B & B deps on A. So both B and A are
1307 installed. Then A's installation is started resulting in an
1308 uncecessary upgrade */
1309 if (pkg
->state_status
== SS_INSTALLED
)
1312 err
= verify_pkg_installable(pkg
);
1316 if (pkg
->local_filename
== NULL
) {
1317 if(!conf
->cache
&& conf
->download_only
){
1319 if(getcwd(cwd
, sizeof(cwd
)) != NULL
)
1320 err
= opkg_download_pkg(pkg
, cwd
);
1324 err
= opkg_download_pkg(pkg
, conf
->tmp_dir
);
1327 opkg_msg(ERROR
, "Failed to download %s. "
1328 "Perhaps you need to run 'opkg update'?\n",
1334 /* check that the repository is valid */
1335 #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL) || defined(HAVE_USIGN)
1336 char *list_file_name
, *sig_file_name
, *lists_dir
;
1338 /* check to ensure the package has come from a repository */
1339 if (conf
->check_signature
&& pkg
->src
)
1341 sprintf_alloc (&lists_dir
, "%s",
1342 (conf
->restrict_to_default_dest
)
1343 ? conf
->default_dest
->lists_dir
1345 sprintf_alloc (&list_file_name
, "%s/%s", lists_dir
, pkg
->src
->name
);
1346 sprintf_alloc (&sig_file_name
, "%s/%s.sig", lists_dir
, pkg
->src
->name
);
1348 if (file_exists (sig_file_name
))
1350 if (opkg_verify_file (list_file_name
, sig_file_name
)){
1351 opkg_msg(ERROR
, "Failed to verify the signature of %s.\n",
1353 if (!conf
->force_signature
)
1357 opkg_msg(ERROR
, "Signature file is missing for %s. "
1358 "Perhaps you need to run 'opkg update'?\n",
1360 if (!conf
->force_signature
)
1365 free (list_file_name
);
1366 free (sig_file_name
);
1371 /* Check for md5 values */
1374 file_md5
= file_md5sum_alloc(pkg
->local_filename
);
1375 if (file_md5
&& strcmp(file_md5
, pkg
->md5sum
))
1377 if (!conf
->force_checksum
)
1379 opkg_msg(ERROR
, "Package %s md5sum mismatch. "
1380 "Either the opkg or the package index are corrupt. "
1381 "Try 'opkg update'.\n",
1388 opkg_msg(NOTICE
, "Ignored %s md5sum mismatch.\n", pkg
->name
);
1397 /* Check for sha256 value */
1400 file_sha256
= file_sha256sum_alloc(pkg
->local_filename
);
1401 if (file_sha256
&& strcmp(file_sha256
, pkg
->sha256sum
))
1403 if (!conf
->force_checksum
)
1406 "Package %s sha256sum mismatch. "
1407 "Either the opkg or the package index are corrupt. "
1408 "Try 'opkg update'.\n",
1416 "Ignored %s sha256sum mismatch.\n",
1424 if(conf
->download_only
) {
1425 if (conf
->nodeps
== 0) {
1426 err
= satisfy_dependencies_for(pkg
);
1433 if (pkg
->tmp_unpack_dir
== NULL
) {
1434 if (unpack_pkg_control_files(pkg
) == -1) {
1435 opkg_msg(ERROR
, "Failed to unpack control files from %s.\n",
1436 pkg
->local_filename
);
1441 err
= update_file_ownership(pkg
, old_pkg
);
1445 if (conf
->nodeps
== 0) {
1446 err
= satisfy_dependencies_for(pkg
);
1449 if (pkg
->state_status
== SS_UNPACKED
)
1450 /* Circular dependency has installed it for us. */
1454 replacees
= pkg_vec_alloc();
1455 pkg_get_installed_replacees(pkg
, replacees
);
1457 /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1459 sigemptyset(&newset
);
1460 sigaddset(&newset
, SIGINT
);
1461 sigprocmask(SIG_BLOCK
, &newset
, &oldset
);
1463 opkg_state_changed
++;
1464 pkg
->state_flag
|= SF_FILELIST_CHANGED
;
1467 pkg_remove_orphan_dependent(pkg
, old_pkg
);
1468 old_pkg
->is_upgrade
= 1;
1469 pkg
->is_upgrade
= 1;
1471 /* XXX: BUG: we really should treat replacement more like an upgrade
1472 * Instead, we're going to remove the replacees
1474 err
= pkg_remove_installed_replacees(replacees
);
1476 goto UNWIND_REMOVE_INSTALLED_REPLACEES
;
1478 err
= prerm_upgrade_old_pkg(pkg
, old_pkg
);
1480 goto UNWIND_PRERM_UPGRADE_OLD_PKG
;
1482 err
= prerm_deconfigure_conflictors(pkg
, replacees
);
1484 goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS
;
1486 err
= preinst_configure(pkg
, old_pkg
);
1488 goto UNWIND_PREINST_CONFIGURE
;
1490 err
= backup_modified_conffiles(pkg
, old_pkg
);
1492 goto UNWIND_BACKUP_MODIFIED_CONFFILES
;
1494 err
= check_data_file_clashes(pkg
, old_pkg
);
1496 goto UNWIND_CHECK_DATA_FILE_CLASHES
;
1498 err
= postrm_upgrade_old_pkg(pkg
, old_pkg
);
1500 goto UNWIND_POSTRM_UPGRADE_OLD_PKG
;
1505 /* point of no return: no unwinding after this */
1507 old_pkg
->state_want
= SW_DEINSTALL
;
1509 if (old_pkg
->state_flag
& SF_NOPRUNE
) {
1510 opkg_msg(INFO
, "Not removing obsolesced files because "
1511 "package %s marked noprune.\n",
1514 opkg_msg(INFO
, "Removing obsolesced files for %s\n",
1516 if (remove_obsolesced_files(pkg
, old_pkg
)) {
1517 opkg_msg(ERROR
, "Failed to determine "
1518 "obsolete files from previously "
1519 "installed %s\n", old_pkg
->name
);
1523 /* removing files from old package, to avoid ghost files */
1524 remove_data_files_and_list(old_pkg
);
1525 remove_maintainer_scripts(old_pkg
);
1529 opkg_msg(INFO
, "%s maintainer scripts.\n", (pkg
->is_upgrade
) ? ("Upgrading") : ("Installing"));
1530 if (install_maintainer_scripts(pkg
, old_pkg
)) {
1531 opkg_msg(ERROR
, "Failed to extract maintainer scripts for %s."
1532 " Package debris may remain!\n",
1537 /* the following just returns 0 */
1538 remove_disappeared(pkg
);
1540 opkg_msg(INFO
, "Installing data files for %s.\n", pkg
->name
);
1542 if (install_data_files(pkg
)) {
1543 opkg_msg(ERROR
, "Failed to extract data files for %s. "
1544 "Package debris may remain!\n",
1549 err
= check_data_file_clashes_change(pkg
, old_pkg
);
1551 opkg_msg(ERROR
, "check_data_file_clashes_change() failed for "
1552 "for files belonging to %s.\n",
1556 opkg_msg(INFO
, "Resolving conf files for %s\n", pkg
->name
);
1557 resolve_conffiles(pkg
);
1559 pkg
->state_status
= SS_UNPACKED
;
1560 old_state_flag
= pkg
->state_flag
;
1561 pkg
->state_flag
&= ~SF_PREFER
;
1562 opkg_msg(DEBUG
, "pkg=%s old_state_flag=%x state_flag=%x\n",
1563 pkg
->name
, old_state_flag
, pkg
->state_flag
);
1566 old_pkg
->state_status
= SS_NOT_INSTALLED
;
1568 time(&pkg
->installed_time
);
1570 ab_pkg
= pkg
->parent
;
1572 ab_pkg
->state_status
= pkg
->state_status
;
1574 sigprocmask(SIG_UNBLOCK
, &newset
, &oldset
);
1575 pkg_vec_free (replacees
);
1579 UNWIND_POSTRM_UPGRADE_OLD_PKG
:
1580 postrm_upgrade_old_pkg_unwind(pkg
, old_pkg
);
1581 UNWIND_CHECK_DATA_FILE_CLASHES
:
1582 check_data_file_clashes_unwind(pkg
, old_pkg
);
1583 UNWIND_BACKUP_MODIFIED_CONFFILES
:
1584 backup_modified_conffiles_unwind(pkg
, old_pkg
);
1585 UNWIND_PREINST_CONFIGURE
:
1586 preinst_configure_unwind(pkg
, old_pkg
);
1587 UNWIND_PRERM_DECONFIGURE_CONFLICTORS
:
1588 prerm_deconfigure_conflictors_unwind(pkg
, replacees
);
1589 UNWIND_PRERM_UPGRADE_OLD_PKG
:
1590 prerm_upgrade_old_pkg_unwind(pkg
, old_pkg
);
1591 UNWIND_REMOVE_INSTALLED_REPLACEES
:
1592 pkg_remove_installed_replacees_unwind(replacees
);
1595 sigprocmask(SIG_UNBLOCK
, &newset
, &oldset
);
1597 pkg_vec_free (replacees
);