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_message(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,r, err = 0;
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 r = opkg_remove_pkg(p, 0);
369 opkg_msg(INFO, "%s was autoinstalled and is "
370 "still required by %d "
371 "installed packages.\n",
380 /* returns number of installed replacees */
382 pkg_get_installed_replacees(pkg_t *pkg, pkg_vec_t *installed_replacees)
384 abstract_pkg_t **replaces = pkg->replaces;
385 int replaces_count = pkg->replaces_count;
387 for (i = 0; i < replaces_count; i++) {
388 abstract_pkg_t *ab_pkg = replaces[i];
389 pkg_vec_t *pkg_vec = ab_pkg->pkgs;
391 for (j = 0; j < pkg_vec->len; j++) {
392 pkg_t *replacee = pkg_vec->pkgs[j];
393 if (!pkg_conflicts(pkg, replacee))
395 if (replacee->state_status == SS_INSTALLED) {
396 pkg_vec_insert(installed_replacees, replacee);
401 return installed_replacees->len;
405 pkg_remove_installed_replacees(pkg_vec_t *replacees)
408 int replaces_count = replacees->len;
409 for (i = 0; i < replaces_count; i++) {
410 pkg_t *replacee = replacees->pkgs[i];
412 replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
413 err = opkg_remove_pkg(replacee, 0);
420 /* to unwind the removal: make sure they are installed */
422 pkg_remove_installed_replacees_unwind(pkg_vec_t *replacees)
425 int replaces_count = replacees->len;
426 for (i = 0; i < replaces_count; i++) {
427 pkg_t *replacee = replacees->pkgs[i];
428 if (replacee->state_status != SS_INSTALLED) {
429 opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
430 err = opkg_install_pkg(replacee, 0);
438 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
440 opkg_install_check_downgrade(pkg_t *pkg, pkg_t *old_pkg, int message)
443 char message_out[15];
444 char *old_version = pkg_version_str_alloc(old_pkg);
445 char *new_version = pkg_version_str_alloc(pkg);
446 int cmp = pkg_compare_versions(old_pkg, pkg);
449 memset(message_out,'\x0',15);
450 strncpy (message_out,"Upgrading ",strlen("Upgrading "));
451 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
452 cmp = -1 ; /* then we force opkg to downgrade */
453 strncpy (message_out,"Downgrading ",strlen("Downgrading ")); /* We need to use a value < 0 because in the 0 case we are asking to */
454 /* reinstall, and some check could fail asking the "force-reinstall" option */
458 if(!conf->download_only)
460 "Not downgrading package %s on %s from %s to %s.\n",
461 old_pkg->name, old_pkg->dest->name, old_version, new_version);
463 } else if (cmp < 0) {
464 if(!conf->download_only)
465 opkg_msg(NOTICE, "%s%s on %s from %s to %s...\n",
466 message_out, pkg->name, old_pkg->dest->name, old_version, new_version);
467 pkg->dest = old_pkg->dest;
469 } else /* cmp == 0 */ {
470 if (conf->force_reinstall) {
471 if(!conf->download_only)
472 opkg_msg(NOTICE, "Reinstalling %s (%s) on %s...\n",
473 pkg->name, new_version, old_pkg->dest->name);
474 pkg->dest = old_pkg->dest;
477 if(!conf->download_only)
478 opkg_msg(NOTICE, "%s (%s) already install on %s."
479 " Not reinstalling.\n",
480 pkg->name, new_version, old_pkg->dest->name);
488 char message_out[15] ;
489 memset(message_out,'\x0',15);
491 strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
493 strncpy( message_out,"Installing ",strlen("Installing ") );
494 char *version = pkg_version_str_alloc(pkg);
496 if(!conf->download_only)
497 opkg_msg(NOTICE, "%s%s (%s) to %s...\n", message_out,
498 pkg->name, version, pkg->dest->name);
506 prerm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
508 /* DPKG_INCOMPATIBILITY:
509 dpkg does some things here that we don't do yet. Do we care?
511 1. If a version of the package is already installed, call
512 old-prerm upgrade new-version
513 2. If the script runs but exits with a non-zero exit status
514 new-prerm failed-upgrade old-version
515 Error unwind, for both the above cases:
516 old-postinst abort-upgrade new-version
522 prerm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
524 /* DPKG_INCOMPATIBILITY:
525 dpkg does some things here that we don't do yet. Do we care?
526 (See prerm_upgrade_old_package for details)
532 prerm_deconfigure_conflictors(pkg_t *pkg, pkg_vec_t *conflictors)
534 /* DPKG_INCOMPATIBILITY:
535 dpkg does some things here that we don't do yet. Do we care?
536 2. If a 'conflicting' package is being removed at the same time:
537 1. If any packages depended on that conflicting package and
538 --auto-deconfigure is specified, call, for each such package:
539 deconfigured's-prerm deconfigure \
540 in-favour package-being-installed version \
541 removing conflicting-package version
543 deconfigured's-postinst abort-deconfigure \
544 in-favour package-being-installed-but-failed version \
545 removing conflicting-package version
547 The deconfigured packages are marked as requiring
548 configuration, so that if --install is used they will be
549 configured again if possible.
550 2. To prepare for removal of the conflicting package, call:
551 conflictor's-prerm remove in-favour package new-version
553 conflictor's-postinst abort-remove in-favour package new-version
559 prerm_deconfigure_conflictors_unwind(pkg_t *pkg, pkg_vec_t *conflictors)
561 /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
562 do yet. Do we care? (See prerm_deconfigure_conflictors for
568 preinst_configure(pkg_t *pkg, pkg_t *old_pkg)
574 char *old_version = pkg_version_str_alloc(old_pkg);
575 sprintf_alloc(&preinst_args, "upgrade %s", old_version);
577 } else if (pkg->state_status == SS_CONFIG_FILES) {
578 char *pkg_version = pkg_version_str_alloc(pkg);
579 sprintf_alloc(&preinst_args, "install %s", pkg_version);
582 preinst_args = xstrdup("install");
585 err = pkg_run_script(pkg, "preinst", preinst_args);
587 opkg_msg(ERROR, "Aborting installation of %s.\n", pkg->name);
597 preinst_configure_unwind(pkg_t *pkg, pkg_t *old_pkg)
599 /* DPKG_INCOMPATIBILITY:
600 dpkg does the following error unwind, should we?
601 pkg->postrm abort-upgrade old-version
602 OR pkg->postrm abort-install old-version
603 OR pkg->postrm abort-install
609 backup_filename_alloc(const char *file_name)
613 sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
620 backup_make_backup(const char *file_name)
625 backup = backup_filename_alloc(file_name);
626 err = file_copy(file_name, backup);
628 opkg_msg(ERROR, "Failed to copy %s to %s\n",
638 backup_exists_for(const char *file_name)
643 backup = backup_filename_alloc(file_name);
645 ret = file_exists(backup);
653 backup_remove(const char *file_name)
657 backup = backup_filename_alloc(file_name);
665 backup_modified_conffiles(pkg_t *pkg, pkg_t *old_pkg)
668 conffile_list_elt_t *iter;
671 if (conf->noaction) return 0;
673 /* Backup all modified conffiles */
675 for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
679 cf_name = root_filename_alloc(cf->name);
681 /* Don't worry if the conffile is just plain gone */
682 if (file_exists(cf_name) && conffile_has_been_modified(cf)) {
683 err = backup_make_backup(cf_name);
692 /* Backup all conffiles that were not conffiles in old_pkg */
693 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
695 cf = (conffile_t *)iter->data;
696 cf_name = root_filename_alloc(cf->name);
697 /* Ignore if this was a conffile in old_pkg as well */
698 if (pkg_get_conffile(old_pkg, cf->name)) {
702 if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
703 err = backup_make_backup(cf_name);
715 backup_modified_conffiles_unwind(pkg_t *pkg, pkg_t *old_pkg)
717 conffile_list_elt_t *iter;
720 for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
721 backup_remove(((nv_pair_t *)iter->data)->name);
725 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
726 backup_remove(((nv_pair_t *)iter->data)->name);
734 check_data_file_clashes(pkg_t *pkg, pkg_t *old_pkg)
736 /* DPKG_INCOMPATIBILITY:
737 opkg takes a slightly different approach than dpkg at this
738 point. dpkg installs each file in the new package while
739 creating a backup for any file that is replaced, (so that it
740 can unwind if necessary). To avoid complexity and redundant
741 storage, opkg doesn't do any installation until later, (at the
742 point at which dpkg removes the backups.
744 But, we do have to check for data file clashes, since after
745 installing a package with a file clash, removing either of the
746 packages involved in the clash has the potential to break the
749 str_list_t *files_list;
750 str_list_elt_t *iter, *niter;
754 files_list = pkg_get_installed_files(pkg);
755 if (files_list == NULL)
758 for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
760 iter = niter, niter = str_list_next(files_list, iter)) {
762 char *filename = (char *) iter->data;
763 root_filename = root_filename_alloc(filename);
764 if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
768 if (backup_exists_for(root_filename)) {
772 /* Pre-existing files are OK if force-overwrite was asserted. */
773 if (conf->force_overwrite) {
774 /* but we need to change who owns this file */
775 file_hash_set_file_owner(filename, pkg);
779 owner = file_hash_get_file_owner(filename);
781 /* Pre-existing files are OK if owned by the pkg being upgraded. */
782 if (owner && old_pkg) {
783 if (strcmp(owner->name, old_pkg->name) == 0) {
788 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
790 opkg_msg(DEBUG2, "Checking replaces for %s in package %s\n",
791 filename, owner->name);
792 if (pkg_replaces(pkg, owner)) {
795 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
796 then it's ok to overwrite. */
797 if (strcmp(owner->name,pkg->name)==0){
798 opkg_msg(INFO, "Replacing pre-existing file %s"
799 " owned by package %s\n",
800 filename, owner->name);
805 /* Pre-existing files are OK if they are obsolete */
806 obs = hash_table_get(&conf->obs_file_hash, filename);
808 opkg_msg(INFO, "Pre-exiting file %s is obsolete."
810 filename, obs->name);
814 /* We have found a clash. */
815 opkg_msg(ERROR, "Package %s wants to install file %s\n"
816 "\tBut that file is already provided by package ",
817 pkg->name, filename);
819 opkg_msg(ERROR, "%s\n", owner->name);
821 opkg_msg(ERROR, "<no package>\n"
822 "Please move this file out of the way and try again.\n");
828 pkg_free_installed_files(pkg);
834 * XXX: This function sucks, as does the below comment.
837 check_data_file_clashes_change(pkg_t *pkg, pkg_t *old_pkg)
839 /* Basically that's the worst hack I could do to be able to change ownership of
840 file list, but, being that we have no way to unwind the mods, due to structure
841 of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
842 What we do here is change the ownership of file in hash if a replace ( or similar events
844 Only the action that are needed to change name should be considered.
845 @@@ To change after 1.0 release.
847 str_list_t *files_list;
848 str_list_elt_t *iter, *niter;
850 char *root_filename = NULL;
852 files_list = pkg_get_installed_files(pkg);
853 if (files_list == NULL)
856 for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
858 iter = niter, niter = str_list_next(files_list, niter)) {
859 char *filename = (char *) iter->data;
862 root_filename = NULL;
864 root_filename = root_filename_alloc(filename);
865 if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
868 owner = file_hash_get_file_owner(filename);
870 if (conf->force_overwrite) {
871 /* but we need to change who owns this file */
872 file_hash_set_file_owner(filename, pkg);
877 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
879 if (pkg_replaces(pkg, owner)) {
880 /* It's now time to change the owner of that file.
881 It has been "replaced" from the new "Replaces", then I need to inform lists file about that. */
882 opkg_msg(INFO, "Replacing pre-existing file %s "
883 "owned by package %s\n",
884 filename, owner->name);
885 file_hash_set_file_owner(filename, pkg);
894 root_filename = NULL;
896 pkg_free_installed_files(pkg);
902 check_data_file_clashes_unwind(pkg_t *pkg, pkg_t *old_pkg)
904 /* Nothing to do since check_data_file_clashes doesn't change state */
909 postrm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
911 /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
912 1. If the package is being upgraded, call
913 old-postrm upgrade new-version
914 2. If this fails, attempt:
915 new-postrm failed-upgrade old-version
916 Error unwind, for both cases:
917 old-preinst abort-upgrade new-version */
922 postrm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
924 /* DPKG_INCOMPATIBILITY:
925 dpkg does some things here that we don't do yet. Do we care?
926 (See postrm_upgrade_old_pkg for details)
932 remove_obsolesced_files(pkg_t *pkg, pkg_t *old_pkg)
935 str_list_t *old_files;
937 str_list_t *new_files;
939 hash_table_t new_files_table;
941 old_files = pkg_get_installed_files(old_pkg);
942 if (old_files == NULL)
945 new_files = pkg_get_installed_files(pkg);
946 if (new_files == NULL) {
947 pkg_free_installed_files(old_pkg);
951 new_files_table.entries = NULL;
952 hash_table_init("new_files" , &new_files_table, 20);
953 for (nf = str_list_first(new_files); nf; nf = str_list_next(new_files, nf)) {
955 hash_table_insert(&new_files_table, nf->data, nf->data);
958 for (of = str_list_first(old_files); of; of = str_list_next(old_files, of)) {
961 old = (char *)of->data;
962 new = (char *) hash_table_get (&new_files_table, old);
966 if (file_is_dir(old)) {
969 owner = file_hash_get_file_owner(old);
970 if (owner != old_pkg) {
971 /* in case obsolete file no longer belongs to old_pkg */
975 /* old file is obsolete */
976 opkg_msg(INFO, "Removing obsolete file %s.\n", old);
977 if (!conf->noaction) {
980 opkg_perror(ERROR, "unlinking %s failed", old);
985 hash_table_deinit(&new_files_table);
986 pkg_free_installed_files(old_pkg);
987 pkg_free_installed_files(pkg);
993 install_maintainer_scripts(pkg_t *pkg, pkg_t *old_pkg)
998 sprintf_alloc(&prefix, "%s.", pkg->name);
999 ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
1000 pkg->dest->info_dir,
1007 remove_disappeared(pkg_t *pkg)
1009 /* DPKG_INCOMPATIBILITY:
1010 This is a fairly sophisticated dpkg operation. Shall we
1013 /* Any packages all of whose files have been overwritten during the
1014 installation, and which aren't required for dependencies, are
1015 considered to have been removed. For each such package
1016 1. disappearer's-postrm disappear overwriter overwriter-version
1017 2. The package's maintainer scripts are removed
1018 3. It is noted in the status database as being in a sane state,
1019 namely not installed (any conffiles it may have are ignored,
1020 rather than being removed by dpkg). Note that disappearing
1021 packages do not have their prerm called, because dpkg doesn't
1022 know in advance that the package is going to vanish.
1028 install_data_files(pkg_t *pkg)
1032 /* opkg takes a slightly different approach to data file backups
1033 than dpkg. Rather than removing backups at this point, we
1034 actually do the data file installation now. See comments in
1035 check_data_file_clashes() for more details. */
1037 opkg_msg(INFO, "Extracting data files to %s.\n", pkg->dest->root_dir);
1038 err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
1043 /* The "Essential" control field may only be present in the control
1044 * file and not in the Packages list. Ensure we capture it regardless.
1046 * XXX: This should be fixed outside of opkg, in the Package list.
1048 set_flags_from_control(pkg) ;
1050 opkg_msg(DEBUG, "Calling pkg_write_filelist.\n");
1051 err = pkg_write_filelist(pkg);
1055 /* XXX: FEATURE: opkg should identify any files which existed
1056 before installation and which were overwritten, (see
1057 check_data_file_clashes()). What it must do is remove any such
1058 files from the filelist of the old package which provided the
1059 file. Otherwise, if the old package were removed at some point
1060 it would break the new package. Removing the new package will
1061 also break the old one, but this cannot be helped since the old
1062 package's file has already been deleted. This is the importance
1063 of check_data_file_clashes(), and only allowing opkg to install
1064 a clashing package with a user force. */
1070 resolve_conffiles(pkg_t *pkg)
1072 conffile_list_elt_t *iter;
1077 if (conf->noaction) return 0;
1079 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
1080 char *root_filename;
1081 cf = (conffile_t *)iter->data;
1082 root_filename = root_filename_alloc(cf->name);
1084 /* Might need to initialize the md5sum for each conffile */
1085 if (cf->value == NULL) {
1086 cf->value = file_md5sum_alloc(root_filename);
1089 if (!file_exists(root_filename)) {
1090 free(root_filename);
1094 cf_backup = backup_filename_alloc(root_filename);
1096 if (file_exists(cf_backup)) {
1097 /* Let's compute md5 to test if files are changed */
1098 md5sum = file_md5sum_alloc(cf_backup);
1099 if (md5sum && cf->value && strcmp(cf->value,md5sum) != 0 ) {
1100 if (conf->force_maintainer) {
1101 opkg_msg(NOTICE, "Conffile %s using maintainer's setting.\n",
1105 sprintf_alloc(&new_conffile, "%s-opkg", root_filename);
1106 opkg_msg(NOTICE, "Existing conffile %s "
1107 "is different from the conffile in the new package."
1108 " The new conffile will be placed at %s.\n",
1109 root_filename, new_conffile);
1110 rename(root_filename, new_conffile);
1111 rename(cf_backup, root_filename);
1121 free(root_filename);
1129 opkg_install_by_name(const char *pkg_name)
1133 char *old_version, *new_version;
1135 old = pkg_hash_fetch_installed_by_name(pkg_name);
1137 opkg_msg(DEBUG2, "Old versions from pkg_hash_fetch %s.\n",
1140 new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name);
1144 opkg_msg(DEBUG2, "Versions from pkg_hash_fetch:");
1146 opkg_msg(DEBUG2, " old %s ", old->version);
1147 opkg_msg(DEBUG2, " new %s\n", new->version);
1149 new->state_flag |= SF_USER;
1151 old_version = pkg_version_str_alloc(old);
1152 new_version = pkg_version_str_alloc(new);
1154 cmp = pkg_compare_versions(old, new);
1155 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
1156 opkg_msg(DEBUG, "Forcing downgrade\n");
1157 cmp = -1 ; /* then we force opkg to downgrade */
1158 /* We need to use a value < 0 because in the 0 case we are asking to */
1159 /* reinstall, and some check could fail asking the "force-reinstall" option */
1161 opkg_msg(DEBUG, "Comparing visible versions of pkg %s:"
1162 "\n\t%s is installed "
1163 "\n\t%s is available "
1164 "\n\t%d was comparison result\n",
1165 pkg_name, old_version, new_version, cmp);
1166 if (cmp == 0 && !conf->force_reinstall) {
1168 "Package %s (%s) installed in %s is up to date.\n",
1169 old->name, old_version, old->dest->name);
1173 } else if (cmp > 0) {
1175 "Not downgrading package %s on %s from %s to %s.\n",
1176 old->name, old->dest->name, old_version, new_version);
1180 } else if (cmp < 0) {
1181 new->dest = old->dest;
1182 old->state_want = SW_DEINSTALL; /* Here probably the problem for bug 1277 */
1188 opkg_msg(DEBUG2,"Calling opkg_install_pkg.\n");
1189 return opkg_install_pkg(new, 0);
1193 * @brief Really install a pkg_t
1196 opkg_install_pkg(pkg_t *pkg, int from_upgrade)
1200 pkg_t *old_pkg = NULL;
1201 pkg_vec_t *replacees;
1202 abstract_pkg_t *ab_pkg = NULL;
1208 sigset_t newset, oldset;
1211 message = 1; /* Coming from an upgrade, and should change the output message */
1213 opkg_msg(DEBUG2, "Calling pkg_arch_supported.\n");
1215 if (!pkg_arch_supported(pkg)) {
1216 opkg_msg(ERROR, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1217 pkg->architecture, pkg->name);
1220 if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
1221 err = satisfy_dependencies_for(pkg);
1225 opkg_msg(NOTICE, "Package %s is already installed on %s.\n",
1226 pkg->name, pkg->dest->name);
1230 if (pkg->dest == NULL) {
1231 pkg->dest = conf->default_dest;
1234 old_pkg = pkg_hash_fetch_installed_by_name(pkg->name);
1236 err = opkg_install_check_downgrade(pkg, old_pkg, message);
1240 pkg->state_want = SW_INSTALL;
1242 old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependencies */
1245 err = check_conflicts_for(pkg);
1249 /* this setup is to remove the upgrade scenario in the end when
1250 installing pkg A, A deps B & B deps on A. So both B and A are
1251 installed. Then A's installation is started resulting in an
1252 uncecessary upgrade */
1253 if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0)
1256 err = verify_pkg_installable(pkg);
1260 if (pkg->local_filename == NULL) {
1261 if(!conf->cache && conf->download_only){
1263 if(getcwd(cwd, sizeof(cwd)) != NULL)
1264 err = opkg_download_pkg(pkg, cwd);
1268 err = opkg_download_pkg(pkg, conf->tmp_dir);
1271 opkg_msg(ERROR, "Failed to download %s. "
1272 "Perhaps you need to run 'opkg update'?\n",
1278 /* check that the repository is valid */
1279 #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
1280 char *list_file_name, *sig_file_name, *lists_dir;
1282 /* check to ensure the package has come from a repository */
1283 if (conf->check_signature && pkg->src)
1285 sprintf_alloc (&lists_dir, "%s",
1286 (conf->restrict_to_default_dest)
1287 ? conf->default_dest->lists_dir
1289 sprintf_alloc (&list_file_name, "%s/%s", lists_dir, pkg->src->name);
1290 sprintf_alloc (&sig_file_name, "%s/%s.sig", lists_dir, pkg->src->name);
1292 if (file_exists (sig_file_name))
1294 if (opkg_verify_file (list_file_name, sig_file_name)){
1295 opkg_msg(ERROR, "Failed to verify the signature of %s.\n",
1300 opkg_msg(ERROR, "Signature file is missing for %s. "
1301 "Perhaps you need to run 'opkg update'?\n",
1307 free (list_file_name);
1308 free (sig_file_name);
1312 /* Check for md5 values */
1315 file_md5 = file_md5sum_alloc(pkg->local_filename);
1316 if (file_md5 && strcmp(file_md5, pkg->md5sum))
1318 opkg_msg(ERROR, "Package %s md5sum mismatch. "
1319 "Either the opkg or the package index are corrupt. "
1320 "Try 'opkg update'.\n",
1330 /* Check for sha256 value */
1333 file_sha256 = file_sha256sum_alloc(pkg->local_filename);
1334 if (file_sha256 && strcmp(file_sha256, pkg->sha256sum))
1336 opkg_msg(ERROR, "Package %s sha256sum mismatch. "
1337 "Either the opkg or the package index are corrupt. "
1338 "Try 'opkg update'.\n",
1347 if(conf->download_only) {
1348 if (conf->nodeps == 0) {
1349 err = satisfy_dependencies_for(pkg);
1356 if (pkg->tmp_unpack_dir == NULL) {
1357 if (unpack_pkg_control_files(pkg) == -1) {
1358 opkg_msg(ERROR, "Failed to unpack control files from %s.\n",
1359 pkg->local_filename);
1364 err = update_file_ownership(pkg, old_pkg);
1368 if (conf->nodeps == 0) {
1369 err = satisfy_dependencies_for(pkg);
1372 if (pkg->state_status == SS_UNPACKED)
1373 /* Circular dependency has installed it for us. */
1377 replacees = pkg_vec_alloc();
1378 pkg_get_installed_replacees(pkg, replacees);
1380 /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1382 sigemptyset(&newset);
1383 sigaddset(&newset, SIGINT);
1384 sigprocmask(SIG_BLOCK, &newset, &oldset);
1386 opkg_state_changed++;
1387 pkg->state_flag |= SF_FILELIST_CHANGED;
1390 pkg_remove_orphan_dependent(pkg, old_pkg);
1392 /* XXX: BUG: we really should treat replacement more like an upgrade
1393 * Instead, we're going to remove the replacees
1395 err = pkg_remove_installed_replacees(replacees);
1397 goto UNWIND_REMOVE_INSTALLED_REPLACEES;
1399 err = prerm_upgrade_old_pkg(pkg, old_pkg);
1401 goto UNWIND_PRERM_UPGRADE_OLD_PKG;
1403 err = prerm_deconfigure_conflictors(pkg, replacees);
1405 goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
1407 err = preinst_configure(pkg, old_pkg);
1409 goto UNWIND_PREINST_CONFIGURE;
1411 err = backup_modified_conffiles(pkg, old_pkg);
1413 goto UNWIND_BACKUP_MODIFIED_CONFFILES;
1415 err = check_data_file_clashes(pkg, old_pkg);
1417 goto UNWIND_CHECK_DATA_FILE_CLASHES;
1419 err = postrm_upgrade_old_pkg(pkg, old_pkg);
1421 goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
1426 /* point of no return: no unwinding after this */
1427 if (old_pkg && !conf->force_reinstall) {
1428 old_pkg->state_want = SW_DEINSTALL;
1430 if (old_pkg->state_flag & SF_NOPRUNE) {
1431 opkg_msg(INFO, "Not removing obsolesced files because "
1432 "package %s marked noprune.\n",
1435 opkg_msg(INFO, "Removing obsolesced files for %s\n",
1437 if (remove_obsolesced_files(pkg, old_pkg)) {
1438 opkg_msg(ERROR, "Failed to determine "
1439 "obsolete files from previously "
1440 "installed %s\n", old_pkg->name);
1444 /* removing files from old package, to avoid ghost files */
1445 remove_data_files_and_list(old_pkg);
1446 remove_maintainer_scripts(old_pkg);
1450 opkg_msg(INFO, "Installing maintainer scripts.\n");
1451 if (install_maintainer_scripts(pkg, old_pkg)) {
1452 opkg_msg(ERROR, "Failed to extract maintainer scripts for %s."
1453 " Package debris may remain!\n",
1458 /* the following just returns 0 */
1459 remove_disappeared(pkg);
1461 opkg_msg(INFO, "Installing data files for %s.\n", pkg->name);
1463 if (install_data_files(pkg)) {
1464 opkg_msg(ERROR, "Failed to extract data files for %s. "
1465 "Package debris may remain!\n",
1470 err = check_data_file_clashes_change(pkg, old_pkg);
1472 opkg_msg(ERROR, "check_data_file_clashes_change() failed for "
1473 "for files belonging to %s.\n",
1477 opkg_msg(INFO, "Resolving conf files for %s\n", pkg->name);
1478 resolve_conffiles(pkg);
1480 pkg->state_status = SS_UNPACKED;
1481 old_state_flag = pkg->state_flag;
1482 pkg->state_flag &= ~SF_PREFER;
1483 opkg_msg(DEBUG, "pkg=%s old_state_flag=%x state_flag=%x\n",
1484 pkg->name, old_state_flag, pkg->state_flag);
1486 if (old_pkg && !conf->force_reinstall) {
1487 old_pkg->state_status = SS_NOT_INSTALLED;
1490 time(&pkg->installed_time);
1492 ab_pkg = pkg->parent;
1494 ab_pkg->state_status = pkg->state_status;
1496 sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1497 pkg_vec_free (replacees);
1501 UNWIND_POSTRM_UPGRADE_OLD_PKG:
1502 postrm_upgrade_old_pkg_unwind(pkg, old_pkg);
1503 UNWIND_CHECK_DATA_FILE_CLASHES:
1504 check_data_file_clashes_unwind(pkg, old_pkg);
1505 UNWIND_BACKUP_MODIFIED_CONFFILES:
1506 backup_modified_conffiles_unwind(pkg, old_pkg);
1507 UNWIND_PREINST_CONFIGURE:
1508 preinst_configure_unwind(pkg, old_pkg);
1509 UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1510 prerm_deconfigure_conflictors_unwind(pkg, replacees);
1511 UNWIND_PRERM_UPGRADE_OLD_PKG:
1512 prerm_upgrade_old_pkg_unwind(pkg, old_pkg);
1513 UNWIND_REMOVE_INSTALLED_REPLACEES:
1514 pkg_remove_installed_replacees_unwind(replacees);
1517 sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1519 pkg_vec_free (replacees);