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.
25 typedef void (*sighandler_t)(int);
30 #include "pkg_extract.h"
32 #include "opkg_install.h"
33 #include "opkg_configure.h"
34 #include "opkg_download.h"
35 #include "opkg_remove.h"
37 #include "opkg_utils.h"
38 #include "opkg_message.h"
39 #include "opkg_state.h"
40 #include "opkg_defines.h"
42 #include "sprintf_alloc.h"
43 #include "file_util.h"
48 int satisfy_dependencies_for(opkg_conf_t *conf, pkg_t *pkg);
49 static int verify_pkg_installable(opkg_conf_t *conf, pkg_t *pkg);
50 static int unpack_pkg_control_files(opkg_conf_t *conf, pkg_t *pkg);
52 static int prerm_upgrade_old_pkg(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
53 static int prerm_upgrade_old_pkg_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
54 static int prerm_deconfigure_conflictors(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors);
55 static int prerm_deconfigure_conflictors_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors);
56 static int preinst_configure(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
57 static int preinst_configure_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
58 static int check_data_file_clashes(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
59 static int check_data_file_clashes_change(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
60 static int check_data_file_clashes_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
61 static int backup_modified_conffiles(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
62 static int backup_modified_conffiles_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
63 static int postrm_upgrade_old_pkg(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
64 static int postrm_upgrade_old_pkg_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
66 static int remove_obsolesced_files(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
67 static int install_maintainer_scripts(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg);
68 static int remove_disappeared(opkg_conf_t *conf, pkg_t *pkg);
69 static int install_data_files(opkg_conf_t *conf, pkg_t *pkg);
70 static int resolve_conffiles(opkg_conf_t *conf, pkg_t *pkg);
72 static int cleanup_temporary_files(opkg_conf_t *conf, pkg_t *pkg);
74 static int user_prefers_old_conffile(const char *file, const char *backup);
76 static char *backup_filename_alloc(const char *file_name);
77 static int backup_make_backup(opkg_conf_t *conf, const char *file_name);
78 static int backup_exists_for(const char *file_name);
79 static int backup_remove(const char *file_name);
82 int opkg_install_from_file(opkg_conf_t *conf, const char *filename)
86 char *old_version, *new_version;
93 err = pkg_init_from_file(pkg, filename);
98 if (!pkg->architecture) {
99 opkg_message(conf, OPKG_ERROR, "Package %s has no Architecture defined.\n", pkg->name);
103 /* XXX: CLEANUP: hash_insert_pkg has a nasty side effect of possibly
104 freeing the pkg that we pass in. It might be nice to clean this up
106 pkg = hash_insert_pkg(&conf->pkg_hash, pkg, 1,conf);
107 old = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name);
109 pkg->local_filename = strdup(filename);
112 old_version = pkg_version_str_alloc(old);
113 new_version = pkg_version_str_alloc(pkg);
115 cmp = pkg_compare_versions(old, pkg);
116 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
117 cmp = -1 ; /* then we force opkg to downgrade */
118 /* We need to use a value < 0 because in the 0 case we are asking to */
119 /* reinstall, and some check could fail asking the "force-reinstall" option */
122 opkg_message(conf, OPKG_NOTICE,
123 "Not downgrading package %s on %s from %s to %s.\n",
124 old->name, old->dest->name, old_version, new_version);
125 pkg->state_want = SW_DEINSTALL;
126 pkg->state_flag |= SF_OBSOLETE;
136 opkg_message(conf, OPKG_DEBUG2,"Function: %s calling opkg_install_pkg \n",__FUNCTION__);
137 return opkg_install_pkg(conf, pkg,0);
140 opkg_error_t opkg_install_by_name(opkg_conf_t *conf, const char *pkg_name)
144 char *old_version, *new_version;
146 opkg_message(conf, OPKG_DEBUG2, " Getting old from pkg_hash_fetch \n" );
147 old = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg_name);
149 opkg_message(conf, OPKG_DEBUG2, " Old versions from pkg_hash_fetch %s \n", old->version );
151 opkg_message(conf, OPKG_DEBUG2, " Getting new from pkg_hash_fetch \n" );
152 new = pkg_hash_fetch_best_installation_candidate_by_name(conf, pkg_name, &err);
154 opkg_message(conf, OPKG_DEBUG2, " New versions from pkg_hash_fetch %s \n", new->version );
156 /* Pigi Basically here is broken the version stuff.
157 What's happening is that nothing provide the version to differents
158 functions, so the returned struct is always the latest.
159 That's why the install by name don't work.
161 opkg_message(conf, OPKG_DEBUG2, " Versions from pkg_hash_fetch in %s ", __FUNCTION__ );
164 opkg_message(conf, OPKG_DEBUG2, " old %s ", old->version );
166 opkg_message(conf, OPKG_DEBUG2, " new %s ", new->version );
167 opkg_message(conf, OPKG_DEBUG2, " \n");
173 return OPKG_PKG_HAS_NO_CANDIDATE;
176 new->state_flag |= SF_USER;
178 old_version = pkg_version_str_alloc(old);
179 new_version = pkg_version_str_alloc(new);
181 cmp = pkg_compare_versions(old, new);
182 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
183 opkg_message(conf, OPKG_DEBUG, " Forcing downgrade \n");
184 cmp = -1 ; /* then we force opkg to downgrade */
185 /* We need to use a value < 0 because in the 0 case we are asking to */
186 /* reinstall, and some check could fail asking the "force-reinstall" option */
188 opkg_message(conf, OPKG_DEBUG,
189 "Comparing visible versions of pkg %s:"
190 "\n\t%s is installed "
191 "\n\t%s is available "
192 "\n\t%d was comparison result\n",
193 pkg_name, old_version, new_version, cmp);
194 if (cmp == 0 && !conf->force_reinstall) {
195 opkg_message(conf, OPKG_NOTICE,
196 "Package %s (%s) installed in %s is up to date.\n",
197 old->name, old_version, old->dest->name);
201 } else if (cmp > 0) {
202 opkg_message(conf, OPKG_NOTICE,
203 "Not downgrading package %s on %s from %s to %s.\n",
204 old->name, old->dest->name, old_version, new_version);
208 } else if (cmp < 0) {
209 new->dest = old->dest;
210 old->state_want = SW_DEINSTALL; /* Here probably the problem for bug 1277 */
214 /* XXX: CLEANUP: The error code of opkg_install_by_name is really
215 supposed to be an opkg_error_t, but opkg_install_pkg could
216 return any kind of integer, (might be errno from a syscall,
217 etc.). This is a real mess and will need to be cleaned up if
218 anyone ever wants to make a nice libopkg. */
220 opkg_message(conf, OPKG_DEBUG2,"Function: %s calling opkg_install_pkg \n",__FUNCTION__);
221 return opkg_install_pkg(conf, new,0);
224 opkg_error_t opkg_install_multi_by_name(opkg_conf_t *conf, const char *pkg_name)
226 abstract_pkg_vec_t *providers = pkg_hash_fetch_all_installation_candidates (&conf->pkg_hash, pkg_name);
229 abstract_pkg_t *ppkg ;
231 if (providers == NULL)
232 return OPKG_PKG_HAS_NO_CANDIDATE;
234 for (i = 0; i < providers->len; i++) {
235 ppkg = abstract_pkg_vec_get(providers, i);
236 opkg_message(conf, OPKG_DEBUG2,"Function: %s calling opkg_install_by_name %d \n",__FUNCTION__, i);
237 err = opkg_install_by_name(conf, ppkg->name);
240 /* XXX Maybe ppkg should be freed ? */
246 * Walk dependence graph starting with pkg, collect packages to be
247 * installed into pkgs_needed, in dependence order.
249 int pkg_mark_dependencies_for_installation(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *pkgs_needed)
252 pkg_vec_t *depends = pkg_vec_alloc();
253 char **unresolved = NULL;
256 ndepends = pkg_hash_fetch_unsatisfied_dependencies(conf,
261 opkg_message(conf, OPKG_ERROR,
262 "%s: Cannot satisfy the following dependencies for %s:\n\t",
263 conf->force_depends ? "Warning" : "ERROR", pkg->name);
264 while (*unresolved) {
265 opkg_message(conf, OPKG_ERROR, " %s", *unresolved);
268 opkg_message(conf, OPKG_ERROR, "\n");
269 if (! conf->force_depends) {
270 opkg_message(conf, OPKG_INFO,
271 "This could mean that your package list is out of date or that the packages\n"
272 "mentioned above do not yet exist (try 'opkg update'). To proceed in spite\n"
273 "of this problem try again with the '-force-depends' option.\n");
274 pkg_vec_free(depends);
275 return OPKG_PKG_DEPS_UNSATISFIED;
280 pkg_vec_free(depends);
284 for (i = 0; i < depends->len; i++) {
285 pkg_t *dep = depends->pkgs[i];
286 /* The package was uninstalled when we started, but another
287 dep earlier in this loop may have depended on it and pulled
288 it in, so check first. */
289 if ((dep->state_status != SS_INSTALLED)
290 && (dep->state_status != SS_UNPACKED)
291 && (dep->state_want != SW_INSTALL)) {
293 /* Mark packages as to-be-installed */
294 dep->state_want = SW_INSTALL;
296 /* Dependencies should be installed the same place as pkg */
297 if (dep->dest == NULL) {
298 dep->dest = pkg->dest;
301 err = pkg_mark_dependencies_for_installation(conf, dep, pkgs_needed);
303 pkg_vec_free(depends);
309 pkg_vec_insert(pkgs_needed, pkg);
311 pkg_vec_free(depends);
316 int name_mark_dependencies_for_installation(opkg_conf_t *conf, const char *pkg_name, pkg_vec_t *pkgs_needed)
320 char *old_version, *new_version;
322 old = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg_name);
324 new = pkg_hash_fetch_best_installation_candidate_by_name(conf, pkg_name);
326 return OPKG_PKG_HAS_NO_CANDIDATE;
329 old_version = pkg_version_str_alloc(old);
330 new_version = pkg_version_str_alloc(new);
332 cmp = pkg_compare_versions(old, new);
333 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
334 opkg_message(conf, OPKG_DEBUG, " Forcing downgrade ");
335 cmp = -1 ; /* then we force opkg to downgrade */
336 /* We need to use a value < 0 because in the 0 case we are asking to */
337 /* reinstall, and some check could fail asking the "force-reinstall" option */
339 opkg_message(conf, OPKG_DEBUG,
340 "comparing visible versions of pkg %s:"
341 "\n\t%s is installed "
342 "\n\t%s is available "
343 "\n\t%d was comparison result\n",
344 pkg_name, old_version, new_version, cmp);
345 if (cmp == 0 && !conf->force_reinstall) {
346 opkg_message(conf, OPKG_NOTICE,
347 "Package %s (%s) installed in %s is up to date.\n",
348 old->name, old_version, old->dest->name);
352 } else if (cmp > 0) {
353 opkg_message(conf, OPKG_NOTICE,
354 "Not downgrading package %s on %s from %s to %s.\n",
355 old->name, old->dest->name, old_version, new_version);
359 } else if (cmp < 0) {
360 new->dest = old->dest;
361 old->state_want = SW_DEINSTALL;
362 old->state_flag |= SF_OBSOLETE;
365 return pkg_mark_dependencies_for_installation(conf, new, pkgs_needed);
370 int satisfy_dependencies_for(opkg_conf_t *conf, pkg_t *pkg)
373 pkg_vec_t *depends = pkg_vec_alloc();
375 char **unresolved = NULL;
378 ndepends = pkg_hash_fetch_unsatisfied_dependencies(conf,
383 opkg_message(conf, OPKG_ERROR,
384 "%s: Cannot satisfy the following dependencies for %s:\n\t",
385 conf->force_depends ? "Warning" : "ERROR", pkg->name);
386 while (*unresolved) {
387 opkg_message(conf, OPKG_ERROR, " %s", *unresolved);
390 opkg_message(conf, OPKG_ERROR, "\n");
391 if (! conf->force_depends) {
392 opkg_message(conf, OPKG_INFO,
393 "This could mean that your package list is out of date or that the packages\n"
394 "mentioned above do not yet exist (try 'opkg update'). To proceed in spite\n"
395 "of this problem try again with the '-force-depends' option.\n");
396 pkg_vec_free(depends);
397 return OPKG_PKG_DEPS_UNSATISFIED;
402 pkg_vec_free(depends);
406 /* Mark packages as to-be-installed */
407 for (i=0; i < depends->len; i++) {
408 /* Dependencies should be installed the same place as pkg */
409 if (depends->pkgs[i]->dest == NULL) {
410 depends->pkgs[i]->dest = pkg->dest;
412 depends->pkgs[i]->state_want = SW_INSTALL;
415 for (i = 0; i < depends->len; i++) {
416 dep = depends->pkgs[i];
417 /* The package was uninstalled when we started, but another
418 dep earlier in this loop may have depended on it and pulled
419 it in, so check first. */
420 if ((dep->state_status != SS_INSTALLED)
421 && (dep->state_status != SS_UNPACKED)) {
422 opkg_message(conf, OPKG_DEBUG2,"Function: %s calling opkg_install_pkg \n",__FUNCTION__);
423 err = opkg_install_pkg(conf, dep,0);
424 /* mark this package as having been automatically installed to
425 * satisfy a dependancy */
426 dep->auto_installed = 1;
428 pkg_vec_free(depends);
434 pkg_vec_free(depends);
440 /* check all packages have their dependences satisfied, e.g., in case an upgraded package split */
441 int opkg_satisfy_all_dependences(opkg_conf_t *conf)
443 if (conf->nodeps == 0) {
445 pkg_vec_t *installed = pkg_vec_alloc();
446 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
447 for (i = 0; i < installed->len; i++) {
448 pkg_t *pkg = installed->pkgs[i];
449 satisfy_dependencies_for(conf, pkg);
451 pkg_vec_free(installed);
458 static int check_conflicts_for(opkg_conf_t *conf, pkg_t *pkg)
461 pkg_vec_t *conflicts = NULL;
464 if (conf->force_depends) {
472 if (!conf->force_depends)
473 conflicts = (pkg_vec_t *)pkg_hash_fetch_conflicts(&conf->pkg_hash, pkg);
476 opkg_message(conf, level,
477 "%s: The following packages conflict with %s:\n\t", prefix, pkg->name);
479 while (i < conflicts->len)
480 opkg_message(conf, level, " %s", conflicts->pkgs[i++]->name);
481 opkg_message(conf, level, "\n");
482 pkg_vec_free(conflicts);
483 return OPKG_PKG_DEPS_UNSATISFIED;
488 static int update_file_ownership(opkg_conf_t *conf, pkg_t *new_pkg, pkg_t *old_pkg)
490 str_list_t *new_list = pkg_get_installed_files(new_pkg);
491 str_list_elt_t *iter;
493 for (iter = new_list->head; iter; iter = iter->next) {
494 char *new_file = iter->data;
495 pkg_t *owner = file_hash_get_file_owner(conf, new_file);
497 opkg_message(conf, OPKG_ERROR, "Null new_file for new_pkg=%s\n", new_pkg->name);
498 if (!owner || (owner == old_pkg))
499 file_hash_set_file_owner(conf, new_file, new_pkg);
502 str_list_t *old_list = pkg_get_installed_files(old_pkg);
503 for (iter = old_list->head; iter; iter = iter->next) {
504 char *old_file = iter->data;
505 pkg_t *owner = file_hash_get_file_owner(conf, old_file);
506 if (owner == old_pkg) {
508 hash_table_insert(&conf->obs_file_hash, old_file, old_pkg);
511 pkg_free_installed_files(old_pkg);
513 pkg_free_installed_files(new_pkg);
517 static int verify_pkg_installable(opkg_conf_t *conf, pkg_t *pkg)
519 /* XXX: FEATURE: Anything else needed here? Maybe a check on free space? */
521 /* sma 6.20.02: yup; here's the first bit */
523 * XXX: BUG easy for cworth
524 * 1) please point the call below to the correct current root destination
525 * 2) we need to resolve how to check the required space for a pending pkg,
526 * my diddling with the .opk file size below isn't going to cut it.
527 * 3) return a proper error code instead of 1
529 int comp_size, blocks_available;
531 if (!conf->force_space && pkg->installed_size != NULL) {
532 blocks_available = get_available_blocks(conf->default_dest->root_dir);
534 comp_size = strtoul(pkg->installed_size, NULL, 0);
535 /* round up a blocks count without doing fancy-but-slow casting jazz */
536 comp_size = (int)((comp_size + 1023) / 1024);
538 if (comp_size >= blocks_available) {
539 opkg_message(conf, OPKG_ERROR,
540 "Only have %d available blocks on filesystem %s, pkg %s needs %d\n",
541 blocks_available, conf->default_dest->root_dir, pkg->name, comp_size);
548 static int unpack_pkg_control_files(opkg_conf_t *conf, pkg_t *pkg)
551 char *conffiles_file_name;
553 FILE *conffiles_file;
555 sprintf_alloc(&pkg->tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir, pkg->name);
557 pkg->tmp_unpack_dir = mkdtemp(pkg->tmp_unpack_dir);
558 if (pkg->tmp_unpack_dir == NULL) {
559 opkg_message(conf, OPKG_ERROR,
560 "%s: Failed to create temporary directory '%s': %s\n",
561 __FUNCTION__, pkg->tmp_unpack_dir, strerror(errno));
565 err = pkg_extract_control_files_to_dir(pkg, pkg->tmp_unpack_dir);
570 /* XXX: CLEANUP: There might be a cleaner place to read in the
571 conffiles. Seems like I should be able to get everything to go
572 through pkg_init_from_file. If so, maybe it would make sense to
573 move all of unpack_pkg_control_files to that function. */
575 /* Don't need to re-read conffiles if we already have it */
576 if (pkg->conffiles.head) {
580 sprintf_alloc(&conffiles_file_name, "%s/conffiles", pkg->tmp_unpack_dir);
581 if (! file_exists(conffiles_file_name)) {
582 free(conffiles_file_name);
586 conffiles_file = fopen(conffiles_file_name, "r");
587 if (conffiles_file == NULL) {
588 fprintf(stderr, "%s: failed to open %s: %s\n",
589 __FUNCTION__, conffiles_file_name, strerror(errno));
590 free(conffiles_file_name);
593 free(conffiles_file_name);
597 char *cf_name_in_dest;
599 cf_name = file_read_line_alloc(conffiles_file);
600 if (cf_name == NULL) {
604 if (cf_name[0] == '\0') {
608 /* Prepend dest->root_dir to conffile name.
609 Take pains to avoid multiple slashes. */
610 root_dir = pkg->dest->root_dir;
611 if (conf->offline_root)
612 /* skip the offline_root prefix */
613 root_dir = pkg->dest->root_dir + strlen(conf->offline_root);
614 sprintf_alloc(&cf_name_in_dest, "%s%s", root_dir,
615 cf_name[0] == '/' ? (cf_name + 1) : cf_name);
617 /* Can't get an md5sum now, (file isn't extracted yet).
618 We'll wait until resolve_conffiles */
619 conffile_list_append(&pkg->conffiles, cf_name_in_dest, NULL);
622 free(cf_name_in_dest);
625 fclose(conffiles_file);
630 /* returns number of installed replacees */
631 int pkg_get_installed_replacees(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *installed_replacees)
633 abstract_pkg_t **replaces = pkg->replaces;
634 int replaces_count = pkg->replaces_count;
636 for (i = 0; i < replaces_count; i++) {
637 abstract_pkg_t *ab_pkg = replaces[i];
638 pkg_vec_t *pkg_vec = ab_pkg->pkgs;
640 for (j = 0; j < pkg_vec->len; j++) {
641 pkg_t *replacee = pkg_vec->pkgs[j];
642 if (!pkg_conflicts(pkg, replacee))
644 if (replacee->state_status == SS_INSTALLED) {
645 pkg_vec_insert(installed_replacees, replacee);
650 return installed_replacees->len;
653 int pkg_remove_installed_replacees(opkg_conf_t *conf, pkg_vec_t *replacees)
656 int replaces_count = replacees->len;
657 for (i = 0; i < replaces_count; i++) {
658 pkg_t *replacee = replacees->pkgs[i];
660 replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
661 err = opkg_remove_pkg(conf, replacee,0);
668 /* to unwind the removal: make sure they are installed */
669 int pkg_remove_installed_replacees_unwind(opkg_conf_t *conf, pkg_vec_t *replacees)
672 int replaces_count = replacees->len;
673 for (i = 0; i < replaces_count; i++) {
674 pkg_t *replacee = replacees->pkgs[i];
675 if (replacee->state_status != SS_INSTALLED) {
676 opkg_message(conf, OPKG_DEBUG2,"Function: %s calling opkg_install_pkg \n",__FUNCTION__);
677 err = opkg_install_pkg(conf, replacee,0);
685 int caught_sigint = 0;
686 static void opkg_install_pkg_sigint_handler(int sig)
691 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
692 static int opkg_install_check_downgrade(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg, int message)
695 char message_out[15];
696 char *old_version = pkg_version_str_alloc(old_pkg);
697 char *new_version = pkg_version_str_alloc(pkg);
698 int cmp = pkg_compare_versions(old_pkg, pkg);
701 memset(message_out,'\x0',15);
702 strncpy (message_out,"Upgrading ",strlen("Upgrading "));
703 if ( (conf->force_downgrade==1) && (cmp > 0) ){ /* We've been asked to allow downgrade and version is precedent */
704 cmp = -1 ; /* then we force opkg to downgrade */
705 strncpy (message_out,"Downgrading ",strlen("Downgrading ")); /* We need to use a value < 0 because in the 0 case we are asking to */
706 /* reinstall, and some check could fail asking the "force-reinstall" option */
710 opkg_message(conf, OPKG_NOTICE,
711 "Not downgrading package %s on %s from %s to %s.\n",
712 old_pkg->name, old_pkg->dest->name, old_version, new_version);
714 } else if (cmp < 0) {
715 opkg_message(conf, OPKG_NOTICE,
716 "%s%s on %s from %s to %s...\n",
717 message_out, pkg->name, old_pkg->dest->name, old_version, new_version);
718 pkg->dest = old_pkg->dest;
720 } else /* cmp == 0 */ {
721 if (conf->force_reinstall) {
722 opkg_message(conf, OPKG_NOTICE,
723 "Reinstalling %s (%s) on %s...\n",
724 pkg->name, new_version, old_pkg->dest->name);
725 pkg->dest = old_pkg->dest;
728 opkg_message(conf, OPKG_NOTICE,
729 "Not installing %s (%s) on %s -- already installed.\n",
730 pkg->name, new_version, old_pkg->dest->name);
738 char message_out[15] ;
739 memset(message_out,'\x0',15);
741 strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
743 strncpy( message_out,"Installing ",strlen("Installing ") );
744 char *version = pkg_version_str_alloc(pkg);
746 opkg_message(conf, OPKG_NOTICE,
747 "%s%s (%s) to %s...\n", message_out,
748 pkg->name, version, pkg->dest->name);
754 /* and now the meat... */
755 int opkg_install_pkg(opkg_conf_t *conf, pkg_t *pkg, int from_upgrade)
759 pkg_t *old_pkg = NULL;
760 pkg_vec_t *replacees;
761 abstract_pkg_t *ab_pkg = NULL;
767 message = 1; /* Coming from an upgrade, and should change the output message */
770 opkg_message(conf, OPKG_ERROR,
771 "INTERNAL ERROR: null pkg passed to opkg_install_pkg\n");
772 return OPKG_INSTALL_ERR_INTERNAL;
775 opkg_message(conf, OPKG_DEBUG2, "Function: %s calling pkg_arch_supported %s \n", __FUNCTION__, __FUNCTION__);
777 if (!pkg_arch_supported(conf, pkg)) {
778 opkg_message(conf, OPKG_ERROR, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
779 pkg->architecture, pkg->name);
780 return OPKG_INSTALL_ERR_INTERNAL;
782 if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
783 err = satisfy_dependencies_for(conf, pkg);
784 if (err) { return OPKG_INSTALL_ERR_DEPENDENCIES; }
786 opkg_message(conf, OPKG_NOTICE,
787 "Package %s is already installed in %s.\n",
788 pkg->name, pkg->dest->name);
792 if (pkg->dest == NULL) {
793 pkg->dest = conf->default_dest;
796 old_pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name);
798 err = opkg_install_check_downgrade(conf, pkg, old_pkg, message);
799 if (err) { return OPKG_INSTALL_ERR_NO_DOWNGRADE; }
801 pkg->state_want = SW_INSTALL;
803 old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependences */
807 /* Abhaya: conflicts check */
808 err = check_conflicts_for(conf, pkg);
809 if (err) { return OPKG_INSTALL_ERR_CONFLICTS; }
811 /* this setup is to remove the upgrade scenario in the end when
812 installing pkg A, A deps B & B deps on A. So both B and A are
813 installed. Then A's installation is started resulting in an
814 uncecessary upgrade */
815 if (pkg->state_status == SS_INSTALLED
816 && conf->force_reinstall == 0) return 0;
818 err = verify_pkg_installable(conf, pkg);
819 if (err) { return OPKG_INSTALL_ERR_NO_SPACE; }
821 if (pkg->local_filename == NULL) {
822 err = opkg_download_pkg(conf, pkg, conf->tmp_dir);
824 opkg_message(conf, OPKG_ERROR,
825 "Failed to download %s. Perhaps you need to run 'opkg update'?\n",
827 return OPKG_INSTALL_ERR_DOWNLOAD;
831 /* check that the repository is valid */
833 char *list_file_name, *sig_file_name, *lists_dir;
835 /* check to ensure the package has come from a repository */
838 sprintf_alloc (&lists_dir, "%s",
839 (conf->restrict_to_default_dest)
840 ? conf->default_dest->lists_dir
842 sprintf_alloc (&list_file_name, "%s/%s", lists_dir, pkg->src->name);
843 sprintf_alloc (&sig_file_name, "%s/%s.sig", lists_dir, pkg->src->name);
845 if (file_exists (sig_file_name))
847 if (opkg_verify_file (conf, list_file_name, sig_file_name))
848 return OPKG_INSTALL_ERR_SIGNATURE;
852 free (list_file_name);
853 free (sig_file_name);
857 /* Check for md5 values */
860 file_md5 = file_md5sum_alloc(pkg->local_filename);
861 if (strcmp(file_md5, pkg->md5sum))
863 opkg_message(conf, OPKG_ERROR,
864 "Package %s md5sum mismatch. Either the opkg or the package index are corrupt. Try 'opkg update'.\n",
867 return OPKG_INSTALL_ERR_MD5;
872 if (pkg->tmp_unpack_dir == NULL) {
873 unpack_pkg_control_files(conf, pkg);
876 /* We should update the filelist here, so that upgrades of packages that split will not fail. -Jamey 27-MAR-03 */
877 /* Pigi: check if it will pass from here when replacing. It seems to fail */
878 /* That's rather strange that files don't change owner. Investigate !!!!!!*/
879 err = update_file_ownership(conf, pkg, old_pkg);
880 if (err) { return OPKG_ERR_UNKNOWN; }
882 if (conf->nodeps == 0) {
883 err = satisfy_dependencies_for(conf, pkg);
884 if (err) { return OPKG_INSTALL_ERR_DEPENDENCIES; }
887 replacees = pkg_vec_alloc();
888 pkg_get_installed_replacees(conf, pkg, replacees);
890 sprintf_alloc (&pkgid, "%s;%s;%s;", pkg->name, pkg->version, pkg->architecture);
891 opkg_set_current_state (conf, OPKG_STATE_INSTALLING_PKG, pkgid);
894 /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
896 sigset_t newset, oldset;
897 sighandler_t old_handler = NULL;
901 old_handler = signal(SIGINT, opkg_install_pkg_sigint_handler);
903 sigemptyset(&newset);
904 sigaddset(&newset, SIGINT);
905 sigprocmask(SIG_BLOCK, &newset, &oldset);
908 opkg_state_changed++;
909 pkg->state_flag |= SF_FILELIST_CHANGED;
911 /* XXX: BUG: we really should treat replacement more like an upgrade
912 * Instead, we're going to remove the replacees
914 err = pkg_remove_installed_replacees(conf, replacees);
915 if (err) goto UNWIND_REMOVE_INSTALLED_REPLACEES;
917 err = prerm_upgrade_old_pkg(conf, pkg, old_pkg);
918 if (err) goto UNWIND_PRERM_UPGRADE_OLD_PKG;
920 err = prerm_deconfigure_conflictors(conf, pkg, replacees);
921 if (err) goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
923 err = preinst_configure(conf, pkg, old_pkg);
924 if (err) goto UNWIND_PREINST_CONFIGURE;
926 err = backup_modified_conffiles(conf, pkg, old_pkg);
927 if (err) goto UNWIND_BACKUP_MODIFIED_CONFFILES;
929 err = check_data_file_clashes(conf, pkg, old_pkg);
930 if (err) goto UNWIND_CHECK_DATA_FILE_CLASHES;
932 err = postrm_upgrade_old_pkg(conf, pkg, old_pkg);
933 if (err) goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
935 if (conf->noaction) return 0;
937 /* point of no return: no unwinding after this */
938 if (old_pkg && !conf->force_reinstall) {
939 old_pkg->state_want = SW_DEINSTALL;
941 if (old_pkg->state_flag & SF_NOPRUNE) {
942 opkg_message(conf, OPKG_INFO,
943 " not removing obsolesced files because package marked noprune\n");
945 opkg_message(conf, OPKG_INFO,
946 " removing obsolesced files\n");
947 remove_obsolesced_files(conf, pkg, old_pkg);
949 /* removing files from old package, to avoid ghost files */
950 remove_data_files_and_list(conf, old_pkg);
951 /* Pigi : It should be better to remove also maintainer and postrem scripts here, just in case*/
952 remove_maintainer_scripts_except_postrm(conf, old_pkg);
953 remove_postrm(conf, old_pkg);
959 opkg_message(conf, OPKG_INFO,
960 " installing maintainer scripts\n");
961 install_maintainer_scripts(conf, pkg, old_pkg);
963 /* the following just returns 0 */
964 remove_disappeared(conf, pkg);
966 opkg_message(conf, OPKG_INFO,
967 " installing data files\n");
968 install_data_files(conf, pkg);
970 /* read comments from function for detail but I will execute this here as all other tests are ok.*/
971 err = check_data_file_clashes_change(conf, pkg, old_pkg);
973 opkg_message(conf, OPKG_INFO,
974 " resolving conf files\n");
975 resolve_conffiles(conf, pkg);
977 pkg->state_status = SS_UNPACKED;
978 old_state_flag = pkg->state_flag;
979 pkg->state_flag &= ~SF_PREFER;
980 opkg_message(conf, OPKG_DEBUG, " pkg=%s old_state_flag=%x state_flag=%x\n", pkg->name, old_state_flag, pkg->state_flag);
982 if (old_pkg && !conf->force_reinstall) {
983 old_pkg->state_status = SS_NOT_INSTALLED;
986 time(&pkg->installed_time);
988 opkg_message(conf, OPKG_INFO,
989 " cleanup temp files\n");
990 cleanup_temporary_files(conf, pkg);
992 ab_pkg = pkg->parent;
994 ab_pkg->state_status = pkg->state_status;
996 opkg_message(conf, OPKG_INFO, "Done.\n");
999 signal(SIGINT, old_handler);
1001 sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1002 pkg_vec_free (replacees);
1006 UNWIND_POSTRM_UPGRADE_OLD_PKG:
1007 postrm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
1008 UNWIND_CHECK_DATA_FILE_CLASHES:
1009 check_data_file_clashes_unwind(conf, pkg, old_pkg);
1010 UNWIND_BACKUP_MODIFIED_CONFFILES:
1011 backup_modified_conffiles_unwind(conf, pkg, old_pkg);
1012 UNWIND_PREINST_CONFIGURE:
1013 preinst_configure_unwind(conf, pkg, old_pkg);
1014 UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1015 prerm_deconfigure_conflictors_unwind(conf, pkg, replacees);
1016 UNWIND_PRERM_UPGRADE_OLD_PKG:
1017 prerm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
1018 UNWIND_REMOVE_INSTALLED_REPLACEES:
1019 pkg_remove_installed_replacees_unwind(conf, replacees);
1021 opkg_message(conf, OPKG_INFO,
1022 " cleanup temp files\n");
1023 cleanup_temporary_files(conf, pkg);
1025 opkg_message(conf, OPKG_INFO,
1028 signal(SIGINT, old_handler);
1030 sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1032 pkg_vec_free (replacees);
1033 return OPKG_ERR_UNKNOWN;
1035 opkg_set_current_state (conf, OPKG_STATE_NONE, NULL);
1038 static int prerm_upgrade_old_pkg(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1040 /* DPKG_INCOMPATIBILITY:
1041 dpkg does some things here that we don't do yet. Do we care?
1043 1. If a version of the package is already installed, call
1044 old-prerm upgrade new-version
1045 2. If the script runs but exits with a non-zero exit status
1046 new-prerm failed-upgrade old-version
1047 Error unwind, for both the above cases:
1048 old-postinst abort-upgrade new-version
1053 static int prerm_upgrade_old_pkg_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1055 /* DPKG_INCOMPATIBILITY:
1056 dpkg does some things here that we don't do yet. Do we care?
1057 (See prerm_upgrade_old_package for details)
1062 static int prerm_deconfigure_conflictors(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors)
1064 /* DPKG_INCOMPATIBILITY:
1065 dpkg does some things here that we don't do yet. Do we care?
1066 2. If a 'conflicting' package is being removed at the same time:
1067 1. If any packages depended on that conflicting package and
1068 --auto-deconfigure is specified, call, for each such package:
1069 deconfigured's-prerm deconfigure \
1070 in-favour package-being-installed version \
1071 removing conflicting-package version
1073 deconfigured's-postinst abort-deconfigure \
1074 in-favour package-being-installed-but-failed version \
1075 removing conflicting-package version
1077 The deconfigured packages are marked as requiring
1078 configuration, so that if --install is used they will be
1079 configured again if possible.
1080 2. To prepare for removal of the conflicting package, call:
1081 conflictor's-prerm remove in-favour package new-version
1083 conflictor's-postinst abort-remove in-favour package new-version
1088 static int prerm_deconfigure_conflictors_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors)
1090 /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
1091 do yet. Do we care? (See prerm_deconfigure_conflictors for
1096 static int preinst_configure(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1102 char *old_version = pkg_version_str_alloc(old_pkg);
1103 sprintf_alloc(&preinst_args, "upgrade %s", old_version);
1105 } else if (pkg->state_status == SS_CONFIG_FILES) {
1106 char *pkg_version = pkg_version_str_alloc(pkg);
1107 sprintf_alloc(&preinst_args, "install %s", pkg_version);
1110 preinst_args = strdup("install");
1113 err = pkg_run_script(conf, pkg, "preinst", preinst_args);
1115 opkg_message(conf, OPKG_ERROR,
1116 "Aborting installation of %s\n", pkg->name);
1125 static int preinst_configure_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1127 /* DPKG_INCOMPATIBILITY:
1128 dpkg does the following error unwind, should we?
1129 pkg->postrm abort-upgrade old-version
1130 OR pkg->postrm abort-install old-version
1131 OR pkg->postrm abort-install
1136 static int backup_modified_conffiles(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1139 conffile_list_elt_t *iter;
1142 if (conf->noaction) return 0;
1144 /* Backup all modified conffiles */
1146 for (iter = old_pkg->conffiles.head; iter; iter = iter->next) {
1150 cf_name = root_filename_alloc(conf, cf->name);
1152 /* Don't worry if the conffile is just plain gone */
1153 if (file_exists(cf_name) && conffile_has_been_modified(conf, cf)) {
1154 err = backup_make_backup(conf, cf_name);
1163 /* Backup all conffiles that were not conffiles in old_pkg */
1164 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
1167 cf_name = root_filename_alloc(conf, cf->name);
1168 /* Ignore if this was a conffile in old_pkg as well */
1169 if (pkg_get_conffile(old_pkg, cf->name)) {
1173 if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
1174 err = backup_make_backup(conf, cf_name);
1185 static int backup_modified_conffiles_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1187 conffile_list_elt_t *iter;
1190 for (iter = old_pkg->conffiles.head; iter; iter = iter->next) {
1191 backup_remove(iter->data->name);
1195 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
1196 backup_remove(iter->data->name);
1203 static int check_data_file_clashes(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1205 /* DPKG_INCOMPATIBILITY:
1206 opkg takes a slightly different approach than dpkg at this
1207 point. dpkg installs each file in the new package while
1208 creating a backup for any file that is replaced, (so that it
1209 can unwind if necessary). To avoid complexity and redundant
1210 storage, opkg doesn't do any installation until later, (at the
1211 point at which dpkg removes the backups.
1213 But, we do have to check for data file clashes, since after
1214 installing a package with a file clash, removing either of the
1215 packages involved in the clash has the potential to break the
1218 str_list_t *files_list;
1219 str_list_elt_t *iter;
1223 files_list = pkg_get_installed_files(pkg);
1224 for (iter = files_list->head; iter; iter = iter->next) {
1225 char *root_filename;
1226 char *filename = iter->data;
1227 root_filename = root_filename_alloc(conf, filename);
1228 if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
1231 /* Pre-existing conffiles are OK */
1232 /* @@@@ should have way to check that it is a conffile -Jamey */
1233 if (backup_exists_for(root_filename)) {
1237 /* Pre-existing files are OK if force-overwrite was asserted. */
1238 if (conf->force_overwrite) {
1239 /* but we need to change who owns this file */
1240 file_hash_set_file_owner(conf, filename, pkg);
1244 owner = file_hash_get_file_owner(conf, filename);
1246 /* Pre-existing files are OK if owned by the pkg being upgraded. */
1247 if (owner && old_pkg) {
1248 if (strcmp(owner->name, old_pkg->name) == 0) {
1253 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
1255 opkg_message(conf, OPKG_DEBUG2, "Checking for replaces for %s in package %s\n", filename, owner->name);
1256 if (pkg_replaces(pkg, owner)) {
1259 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
1260 then it's ok to overwrite. */
1261 if (strcmp(owner->name,pkg->name)==0){
1262 opkg_message(conf, OPKG_INFO, "Replacing pre-existing file %s owned by package %s\n", filename, owner->name);
1267 /* Pre-existing files are OK if they are obsolete */
1268 obs = hash_table_get(&conf->obs_file_hash, filename);
1270 opkg_message(conf, OPKG_INFO, "Pre-exiting file %s is obsolete. obs_pkg=%s\n", filename, obs->name);
1274 /* We have found a clash. */
1275 opkg_message(conf, OPKG_ERROR,
1276 "Package %s wants to install file %s\n"
1277 "\tBut that file is already provided by package ",
1278 pkg->name, filename);
1280 opkg_message(conf, OPKG_ERROR,
1281 "%s\n", owner->name);
1283 opkg_message(conf, OPKG_ERROR,
1284 "<no package>\nPlease move this file out of the way and try again.\n");
1288 free(root_filename);
1290 pkg_free_installed_files(pkg);
1295 static int check_data_file_clashes_change(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1297 /* Basically that's the worst hack I could do to be able to change ownership of
1298 file list, but, being that we have no way to unwind the mods, due to structure
1299 of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
1300 What we do here is change the ownership of file in hash if a replace ( or similar events
1302 Only the action that are needed to change name should be considered.
1303 @@@ To change after 1.0 release.
1305 str_list_t *files_list;
1306 str_list_elt_t *iter;
1310 files_list = pkg_get_installed_files(pkg);
1311 for (iter = files_list->head; iter; iter = iter->next) {
1312 char *root_filename;
1313 char *filename = iter->data;
1314 root_filename = root_filename_alloc(conf, filename);
1315 if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
1318 if (conf->force_overwrite) {
1319 /* but we need to change who owns this file */
1320 file_hash_set_file_owner(conf, filename, pkg);
1324 owner = file_hash_get_file_owner(conf, filename);
1326 /* Pre-existing files are OK if owned by a package replaced by new pkg. */
1328 if (pkg_replaces(pkg, owner)) {
1329 /* It's now time to change the owner of that file.
1330 It has been "replaced" from the new "Replaces", then I need to inform lists file about that. */
1331 opkg_message(conf, OPKG_INFO, "Replacing pre-existing file %s owned by package %s\n", filename, owner->name);
1332 file_hash_set_file_owner(conf, filename, pkg);
1338 free(root_filename);
1340 pkg_free_installed_files(pkg);
1345 static int check_data_file_clashes_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1347 /* Nothing to do since check_data_file_clashes doesn't change state */
1351 static int postrm_upgrade_old_pkg(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1353 /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
1354 1. If the package is being upgraded, call
1355 old-postrm upgrade new-version
1356 2. If this fails, attempt:
1357 new-postrm failed-upgrade old-version
1358 Error unwind, for both cases:
1359 old-preinst abort-upgrade new-version */
1363 static int postrm_upgrade_old_pkg_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1365 /* DPKG_INCOMPATIBILITY:
1366 dpkg does some things here that we don't do yet. Do we care?
1367 (See postrm_upgrade_old_pkg for details)
1372 static int remove_obsolesced_files(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1375 str_list_t *old_files;
1377 str_list_t *new_files;
1380 if (old_pkg == NULL) {
1384 old_files = pkg_get_installed_files(old_pkg);
1385 new_files = pkg_get_installed_files(pkg);
1387 for (of = old_files->head; of; of = of->next) {
1391 for (nf = new_files->head; nf; nf = nf->next) {
1393 if (strcmp(old, new) == 0) {
1397 if (file_is_dir(old)) {
1400 owner = file_hash_get_file_owner(conf, old);
1401 if (owner != old_pkg) {
1402 /* in case obsolete file no longer belongs to old_pkg */
1406 /* old file is obsolete */
1407 opkg_message(conf, OPKG_INFO,
1408 " removing obsolete file %s\n", old);
1409 if (!conf->noaction) {
1412 opkg_message(conf, OPKG_ERROR, " Warning: remove %s failed: %s\n", old,
1421 pkg_free_installed_files(old_pkg);
1422 pkg_free_installed_files(pkg);
1427 static int remove_obsolete_maintainer_scripts(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1435 opkg_message(conf, OPKG_ERROR, "%s: no dest for package %s\n", __FUNCTION__, pkg->name);
1438 sprintf_alloc(&globpattern, "%s/%s.*", pkg->dest->info_dir, pkg->name);
1439 err = glob(globpattern, 0, NULL, &globbuf);
1444 /* XXXX this should perhaps only remove the ones that are not overwritten in new package. Jamey 11/11/2003 */
1445 for (i = 0; i < globbuf.gl_pathc; i++) {
1446 opkg_message(conf, OPKG_DEBUG, "Removing control file %s from old_pkg %s\n",
1447 globbuf.gl_pathv[i], old_pkg->name);
1448 if (!conf->noaction)
1449 unlink(globbuf.gl_pathv[i]);
1456 static int install_maintainer_scripts(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1462 remove_obsolete_maintainer_scripts(conf, pkg, old_pkg);
1463 sprintf_alloc(&prefix, "%s.", pkg->name);
1464 ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
1465 pkg->dest->info_dir,
1471 static int remove_disappeared(opkg_conf_t *conf, pkg_t *pkg)
1473 /* DPKG_INCOMPATIBILITY:
1474 This is a fairly sophisticated dpkg operation. Shall we
1477 /* Any packages all of whose files have been overwritten during the
1478 installation, and which aren't required for dependencies, are
1479 considered to have been removed. For each such package
1480 1. disappearer's-postrm disappear overwriter overwriter-version
1481 2. The package's maintainer scripts are removed
1482 3. It is noted in the status database as being in a sane state,
1483 namely not installed (any conffiles it may have are ignored,
1484 rather than being removed by dpkg). Note that disappearing
1485 packages do not have their prerm called, because dpkg doesn't
1486 know in advance that the package is going to vanish.
1491 static int install_data_files(opkg_conf_t *conf, pkg_t *pkg)
1495 /* opkg takes a slightly different approach to data file backups
1496 than dpkg. Rather than removing backups at this point, we
1497 actually do the data file installation now. See comments in
1498 check_data_file_clashes() for more details. */
1500 opkg_message(conf, OPKG_INFO,
1501 " extracting data files to %s\n", pkg->dest->root_dir);
1502 err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
1507 /* XXX: BUG or FEATURE : We are actually loosing the Essential flag,
1508 so we can't save ourself from removing important packages
1509 At this point we (should) have extracted the .control file, so it
1510 would be a good idea to reload the data in it, and set the Essential
1511 state in *pkg. From now on the Essential is back in status file and
1512 we can protect again.
1513 We should operate this way:
1514 fopen the file ( pkg->dest->root_dir/pkg->name.control )
1515 check for "Essential" in it
1516 set the value in pkg->essential.
1517 This new routine could be useful also for every other flag
1519 set_flags_from_control(conf, pkg) ;
1521 opkg_message(conf, OPKG_DEBUG, " Calling pkg_write_filelist from %s\n", __FUNCTION__);
1522 err = pkg_write_filelist(conf, pkg);
1526 /* XXX: FEATURE: opkg should identify any files which existed
1527 before installation and which were overwritten, (see
1528 check_data_file_clashes()). What it must do is remove any such
1529 files from the filelist of the old package which provided the
1530 file. Otherwise, if the old package were removed at some point
1531 it would break the new package. Removing the new package will
1532 also break the old one, but this cannot be helped since the old
1533 package's file has already been deleted. This is the importance
1534 of check_data_file_clashes(), and only allowing opkg to install
1535 a clashing package with a user force. */
1540 static int resolve_conffiles(opkg_conf_t *conf, pkg_t *pkg)
1542 conffile_list_elt_t *iter;
1549 if (conf->noaction) return 0;
1551 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
1552 char *root_filename;
1554 root_filename = root_filename_alloc(conf, cf->name);
1556 /* Might need to initialize the md5sum for each conffile */
1557 if (cf->value == NULL) {
1558 cf->value = file_md5sum_alloc(root_filename);
1561 if (!file_exists(root_filename)) {
1562 free(root_filename);
1566 cf_backup = backup_filename_alloc(root_filename);
1569 if (file_exists(cf_backup)) {
1570 /* Let's compute md5 to test if files are changed */
1571 md5sum = file_md5sum_alloc(cf_backup);
1572 if (strcmp( cf->value,md5sum) != 0 ) {
1573 if (conf->force_defaults
1574 || user_prefers_old_conffile(cf->name, cf_backup) ) {
1575 rename(cf_backup, root_filename);
1583 free(root_filename);
1589 static int user_prefers_old_conffile(const char *file_name, const char *backup)
1592 const char *short_file_name;
1594 short_file_name = strrchr(file_name, '/');
1595 if (short_file_name) {
1598 short_file_name = file_name;
1602 response = get_user_response(" Configuration file '%s'\n"
1603 " ==> File on system created by you or by a script.\n"
1604 " ==> File also in package provided by package maintainer.\n"
1605 " What would you like to do about it ? Your options are:\n"
1606 " Y or I : install the package maintainer's version\n"
1607 " N or O : keep your currently-installed version\n"
1608 " D : show the differences between the versions (if diff is installed)\n"
1609 " The default action is to keep your current version.\n"
1610 " *** %s (Y/I/N/O/D) [default=N] ? ", file_name, short_file_name);
1611 if (strcmp(response, "y") == 0
1612 || strcmp(response, "i") == 0
1613 || strcmp(response, "yes") == 0) {
1618 if (strcmp(response, "d") == 0) {
1622 /* XXX: BUG rewrite to use exec or busybox's internal diff */
1623 sprintf_alloc(&cmd, "diff -u %s %s", backup, file_name);
1626 printf(" [Press ENTER to continue]\n");
1627 response = file_read_line_alloc(stdin);
1637 /* XXX: CLEANUP: I'd like to move all of the code for
1638 creating/cleaning pkg->tmp_unpack_dir directly into pkg.c. (Then,
1639 it would make sense to cleanup pkg->tmp_unpack_dir directly from
1640 pkg_deinit for example). */
1641 static int cleanup_temporary_files(opkg_conf_t *conf, pkg_t *pkg)
1644 struct dirent *dirent;
1647 #ifdef OPKG_DEBUG_NO_TMP_CLEANUP
1649 opkg_message(conf, OPKG_DEBUG,
1650 "%s: Not cleaning up %s since opkg compiled with OPKG_DEBUG_NO_TMP_CLEANUP\n",
1651 __FUNCTION__, pkg->tmp_unpack_dir);
1655 if (pkg->tmp_unpack_dir && file_is_dir(pkg->tmp_unpack_dir)) {
1656 tmp_dir = opendir(pkg->tmp_unpack_dir);
1659 dirent = readdir(tmp_dir);
1660 if (dirent == NULL) {
1663 sprintf_alloc(&tmp_file, "%s/%s",
1664 pkg->tmp_unpack_dir, dirent->d_name);
1665 if (! file_is_dir(tmp_file)) {
1671 rmdir(pkg->tmp_unpack_dir);
1672 free(pkg->tmp_unpack_dir);
1673 pkg->tmp_unpack_dir = NULL;
1677 opkg_message(conf, OPKG_INFO, "cleanup_temporary_files: pkg=%s local_filename=%s tmp_dir=%s\n",
1678 pkg->name, pkg->local_filename, conf->tmp_dir);
1679 if (pkg->local_filename && strncmp(pkg->local_filename, conf->tmp_dir, strlen(conf->tmp_dir)) == 0) {
1680 unlink(pkg->local_filename);
1681 free(pkg->local_filename);
1682 pkg->local_filename = NULL;
1688 static char *backup_filename_alloc(const char *file_name)
1692 sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
1697 int backup_make_backup(opkg_conf_t *conf, const char *file_name)
1702 backup = backup_filename_alloc(file_name);
1703 err = file_copy(file_name, backup);
1705 opkg_message(conf, OPKG_ERROR,
1706 "%s: Failed to copy %s to %s\n",
1707 __FUNCTION__, file_name, backup);
1715 static int backup_exists_for(const char *file_name)
1720 backup = backup_filename_alloc(file_name);
1722 ret = file_exists(backup);
1729 static int backup_remove(const char *file_name)
1733 backup = backup_filename_alloc(file_name);