libopkg/opkg_install.c

   1 /* opkg_install.c - the opkg package management system
   2
   3    Carl D. Worth
   4
   5    Copyright (C) 2001 University of Southern California
   6
   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.
  11
  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.
  16 */
  17
  18 #include "config.h"
  19
  20 #include <stdio.h>
  21 #include <time.h>
  22 #include <signal.h>
  23 #include <unistd.h>
  24
  25 #include "pkg.h"
  26 #include "pkg_hash.h"
  27 #include "pkg_extract.h"
  28
  29 #include "opkg_install.h"
  30 #include "opkg_configure.h"
  31 #include "opkg_download.h"
  32 #include "opkg_remove.h"
  33
  34 #include "opkg_utils.h"
  35 #include "opkg_message.h"
  36 #include "opkg_cmd.h"
  37 #include "opkg_defines.h"
  38
  39 #include "sprintf_alloc.h"
  40 #include "file_util.h"
  41 #include "xsystem.h"
  42 #include "libbb/libbb.h"
  43
  44 static int
  45 satisfy_dependencies_for(pkg_t *pkg)
  46 {
  47      int i, err;
  48      pkg_vec_t *depends = pkg_vec_alloc();
  49      pkg_t *dep;
  50      char **tmp, **unresolved = NULL;
  51      int ndepends;
  52
  53      ndepends = pkg_hash_fetch_unsatisfied_dependencies(pkg, depends,
  54                                                         &unresolved);
  55
  56      if (unresolved) {
  57           opkg_msg(ERROR, "Cannot satisfy the following dependencies for %s:\n",
  58                        pkg->name);
  59           tmp = unresolved;
  60           while (*unresolved) {
  61                opkg_message(ERROR, "\t%s", *unresolved);
  62                free(*unresolved);
  63                unresolved++;
  64           }
  65           free(tmp);
  66           opkg_message(ERROR, "\n");
  67           if (! conf->force_depends) {
  68                opkg_msg(INFO,
  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);
  73                return -1;
  74           }
  75      }
  76
  77      if (ndepends <= 0) {
  78           pkg_vec_free(depends);
  79           return 0;
  80      }
  81
  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;
  87           }
  88           depends->pkgs[i]->state_want = SW_INSTALL;
  89      }
  90
  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;
 103                if (err) {
 104                     pkg_vec_free(depends);
 105                     return err;
 106                }
 107           }
 108      }
 109
 110      pkg_vec_free(depends);
 111
 112      return 0;
 113 }
 114
 115 static int
 116 check_conflicts_for(pkg_t *pkg)
 117 {
 118      int i;
 119      pkg_vec_t *conflicts = NULL;
 120      message_level_t level;
 121
 122      if (conf->force_depends) {
 123           level = NOTICE;
 124      } else {
 125           level = ERROR;
 126      }
 127
 128      if (!conf->force_depends)
 129           conflicts = pkg_hash_fetch_conflicts(pkg);
 130
 131      if (conflicts) {
 132           opkg_msg(level, "The following packages conflict with %s:\n",
 133                        pkg->name);
 134           i = 0;
 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);
 139           return -1;
 140      }
 141      return 0;
 142 }
 143
 144 static int
 145 update_file_ownership(pkg_t *new_pkg, pkg_t *old_pkg)
 146 {
 147      str_list_t *new_list, *old_list;
 148      str_list_elt_t *iter, *niter;
 149
 150      new_list = pkg_get_installed_files(new_pkg);
 151      if (new_list == NULL)
 152              return -1;
 153
 154      for (iter = str_list_first(new_list), niter = str_list_next(new_list, iter);
 155              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);
 159           if (!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);
 163      }
 164
 165      if (old_pkg) {
 166           old_list = pkg_get_installed_files(old_pkg);
 167           if (old_list == NULL) {
 168                   pkg_free_installed_files(new_pkg);
 169                   return -1;
 170           }
 171
 172           for (iter = str_list_first(old_list), niter = str_list_next(old_list, iter);
 173                   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) {
 178                     /* obsolete */
 179                     hash_table_insert(&conf->obs_file_hash, old_file, old_pkg);
 180                }
 181           }
 182           pkg_free_installed_files(old_pkg);
 183      }
 184      pkg_free_installed_files(new_pkg);
 185      return 0;
 186 }
 187
 188 static int
 189 verify_pkg_installable(pkg_t *pkg)
 190 {
 191         unsigned long kbs_available, pkg_size_kbs;
 192         char *root_dir;
 193
 194         if (conf->force_space || pkg->installed_size == 0)
 195                 return 0;
 196
 197         root_dir = pkg->dest ? pkg->dest->root_dir :
 198                                                 conf->default_dest->root_dir;
 199         kbs_available = get_available_kbytes(root_dir);
 200
 201         pkg_size_kbs = (pkg->installed_size + 1023)/1024;
 202
 203         if (pkg_size_kbs >= kbs_available) {
 204                 opkg_msg(ERROR, "Only have %dkb available on filesystem %s, "
 205                         "pkg %s needs %d\n",
 206                         kbs_available, root_dir, pkg->name, pkg_size_kbs);
 207                 return -1;
 208         }
 209
 210      return 0;
 211 }
 212
 213 static int
 214 unpack_pkg_control_files(pkg_t *pkg)
 215 {
 216      int err;
 217      char *conffiles_file_name;
 218      char *root_dir;
 219      FILE *conffiles_file;
 220
 221      sprintf_alloc(&pkg->tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir, pkg->name);
 222
 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);
 227           return -1;
 228      }
 229
 230      err = pkg_extract_control_files_to_dir(pkg, pkg->tmp_unpack_dir);
 231      if (err) {
 232           return err;
 233      }
 234
 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. */
 239
 240      /* Don't need to re-read conffiles if we already have it */
 241      if (!nv_pair_list_empty(&pkg->conffiles)) {
 242           return 0;
 243      }
 244
 245      sprintf_alloc(&conffiles_file_name, "%s/conffiles", pkg->tmp_unpack_dir);
 246      if (! file_exists(conffiles_file_name)) {
 247           free(conffiles_file_name);
 248           return 0;
 249      }
 250
 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);
 255           return -1;
 256      }
 257      free(conffiles_file_name);
 258
 259      while (1) {
 260           char *cf_name;
 261           char *cf_name_in_dest;
 262
 263           cf_name = file_read_line_alloc(conffiles_file);
 264           if (cf_name == NULL) {
 265                break;
 266           }
 267           if (cf_name[0] == '\0') {
 268                continue;
 269           }
 270
 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);
 279
 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);
 283
 284           free(cf_name);
 285           free(cf_name_in_dest);
 286      }
 287
 288      fclose(conffiles_file);
 289
 290      return 0;
 291 }
 292
 293 /*
 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.
 296  */
 297 static int
 298 pkg_remove_orphan_dependent(pkg_t *pkg, pkg_t *old_pkg)
 299 {
 300         int i, j, k, l, found,r, err = 0;
 301         int n_deps;
 302         pkg_t *p;
 303         struct compound_depend *cd0, *cd1;
 304         abstract_pkg_t **dependents;
 305
 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 +
 311                                 pkg->depends_count +
 312                                 pkg->recommends_count +
 313                                 pkg->suggests_count;
 314
 315         for (i=0; i<count0; i++) {
 316                 cd0 = &old_pkg->depends[i];
 317                 if (cd0->type != DEPEND)
 318                         continue;
 319                 for (j=0; j<cd0->possibility_count; j++) {
 320
 321                         found = 0;
 322
 323                         for (k=0; k<count1; k++) {
 324                                 cd1 = &pkg->depends[i];
 325                                 if (cd1->type != DEPEND)
 326                                         continue;
 327                                 for (l=0; l<cd1->possibility_count; l++) {
 328                                         if (cd0->possibilities[j]
 329                                          == cd1->possibilities[l]) {
 330                                                 found = 1;
 331                                                 break;
 332                                         }
 333                                 }
 334                                 if (found)
 335                                         break;
 336                         }
 337
 338                         if (found)
 339                                 continue;
 340
 341                         /*
 342                          * old_pkg has a dependency that pkg does not.
 343                          */
 344                         p = pkg_hash_fetch_installed_by_name(
 345                                         cd0->possibilities[j]->pkg->name);
 346
 347                         if (!p)
 348                                 continue;
 349
 350                         if (!p->auto_installed)
 351                                 continue;
 352
 353                         n_deps = pkg_has_installed_dependents(p, &dependents);
 354                         n_deps--; /* don't count old_pkg */
 355
 356                         if (n_deps == 0) {
 357                                 opkg_msg(NOTICE, "%s was autoinstalled and is "
 358                                                 "now orphaned, removing.\n",
 359                                                 p->name);
 360
 361                                 /* p has one installed dependency (old_pkg),
 362                                  * which we need to ignore during removal. */
 363                                 p->state_flag |= SF_REPLACE;
 364
 365                                 r = opkg_remove_pkg(p, 0);
 366                                 if (!err)
 367                                         err = r;
 368                         } else
 369                                 opkg_msg(INFO, "%s was autoinstalled and is "
 370                                                 "still required by %d "
 371                                                 "installed packages.\n",
 372                                                 p->name, n_deps);
 373
 374                 }
 375         }
 376
 377         return err;
 378 }
 379
 380 /* returns number of installed replacees */
 381 static int
 382 pkg_get_installed_replacees(pkg_t *pkg, pkg_vec_t *installed_replacees)
 383 {
 384      abstract_pkg_t **replaces = pkg->replaces;
 385      int replaces_count = pkg->replaces_count;
 386      int i, j;
 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;
 390           if (pkg_vec) {
 391                for (j = 0; j < pkg_vec->len; j++) {
 392                     pkg_t *replacee = pkg_vec->pkgs[j];
 393                     if (!pkg_conflicts(pkg, replacee))
 394                          continue;
 395                     if (replacee->state_status == SS_INSTALLED) {
 396                          pkg_vec_insert(installed_replacees, replacee);
 397                     }
 398                }
 399           }
 400      }
 401      return installed_replacees->len;
 402 }
 403
 404 static int
 405 pkg_remove_installed_replacees(pkg_vec_t *replacees)
 406 {
 407      int i;
 408      int replaces_count = replacees->len;
 409      for (i = 0; i < replaces_count; i++) {
 410           pkg_t *replacee = replacees->pkgs[i];
 411           int err;
 412           replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
 413           err = opkg_remove_pkg(replacee, 0);
 414           if (err)
 415                return err;
 416      }
 417      return 0;
 418 }
 419
 420 /* to unwind the removal: make sure they are installed */
 421 static int
 422 pkg_remove_installed_replacees_unwind(pkg_vec_t *replacees)
 423 {
 424      int i, err;
 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);
 431                if (err)
 432                     return err;
 433           }
 434      }
 435      return 0;
 436 }
 437
 438 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
 439 static int
 440 opkg_install_check_downgrade(pkg_t *pkg, pkg_t *old_pkg, int message)
 441 {
 442      if (old_pkg) {
 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);
 447           int rc = 0;
 448
 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 */
 455           }
 456
 457           if (cmp > 0) {
 458               if(!conf->download_only)
 459                   opkg_msg(NOTICE,
 460                           "Not downgrading package %s on %s from %s to %s.\n",
 461                           old_pkg->name, old_pkg->dest->name, old_version, new_version);
 462                rc = 1;
 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;
 468                rc = 0;
 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;
 475                     rc = 0;
 476                } else {
 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);
 481                     rc = 1;
 482                }
 483           }
 484           free(old_version);
 485           free(new_version);
 486           return rc;
 487      } else {
 488           char message_out[15] ;
 489           memset(message_out,'\x0',15);
 490           if ( message )
 491                strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
 492           else
 493                strncpy( message_out,"Installing ",strlen("Installing ") );
 494           char *version = pkg_version_str_alloc(pkg);
 495
 496           if(!conf->download_only)
 497                opkg_msg(NOTICE, "%s%s (%s) to %s...\n", message_out,
 498                   pkg->name, version, pkg->dest->name);
 499           free(version);
 500      }
 501      return 0;
 502 }
 503
 504
 505 static int
 506 prerm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
 507 {
 508      /* DPKG_INCOMPATIBILITY:
 509         dpkg does some things here that we don't do yet. Do we care?
 510
 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
 517      */
 518      return 0;
 519 }
 520
 521 static int
 522 prerm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
 523 {
 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)
 527      */
 528      return 0;
 529 }
 530
 531 static int
 532 prerm_deconfigure_conflictors(pkg_t *pkg, pkg_vec_t *conflictors)
 533 {
 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
 542                 Error unwind:
 543                    deconfigured's-postinst abort-deconfigure \
 544                    in-favour package-being-installed-but-failed version \
 545                    removing conflicting-package version
 546
 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
 552                 Error unwind:
 553                    conflictor's-postinst abort-remove in-favour package new-version
 554      */
 555      return 0;
 556 }
 557
 558 static int
 559 prerm_deconfigure_conflictors_unwind(pkg_t *pkg, pkg_vec_t *conflictors)
 560 {
 561      /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
 562         do yet. Do we care?  (See prerm_deconfigure_conflictors for
 563         details) */
 564      return 0;
 565 }
 566
 567 static int
 568 preinst_configure(pkg_t *pkg, pkg_t *old_pkg)
 569 {
 570      int err;
 571      char *preinst_args;
 572
 573      if (old_pkg) {
 574           char *old_version = pkg_version_str_alloc(old_pkg);
 575           sprintf_alloc(&preinst_args, "upgrade %s", old_version);
 576           free(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);
 580           free(pkg_version);
 581      } else {
 582           preinst_args = xstrdup("install");
 583      }
 584
 585      err = pkg_run_script(pkg, "preinst", preinst_args);
 586      if (err) {
 587           opkg_msg(ERROR, "Aborting installation of %s.\n", pkg->name);
 588           return -1;
 589      }
 590
 591      free(preinst_args);
 592
 593      return 0;
 594 }
 595
 596 static int
 597 preinst_configure_unwind(pkg_t *pkg, pkg_t *old_pkg)
 598 {
 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
 604      */
 605      return 0;
 606 }
 607
 608 static char *
 609 backup_filename_alloc(const char *file_name)
 610 {
 611      char *backup;
 612
 613      sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
 614
 615      return backup;
 616 }
 617
 618
 619 static int
 620 backup_make_backup(const char *file_name)
 621 {
 622      int err;
 623      char *backup;
 624
 625      backup = backup_filename_alloc(file_name);
 626      err = file_copy(file_name, backup);
 627      if (err) {
 628           opkg_msg(ERROR, "Failed to copy %s to %s\n",
 629                        file_name, backup);
 630      }
 631
 632      free(backup);
 633
 634      return err;
 635 }
 636
 637 static int
 638 backup_exists_for(const char *file_name)
 639 {
 640      int ret;
 641      char *backup;
 642
 643      backup = backup_filename_alloc(file_name);
 644
 645      ret = file_exists(backup);
 646
 647      free(backup);
 648
 649      return ret;
 650 }
 651
 652 static int
 653 backup_remove(const char *file_name)
 654 {
 655      char *backup;
 656
 657      backup = backup_filename_alloc(file_name);
 658      unlink(backup);
 659      free(backup);
 660
 661      return 0;
 662 }
 663
 664 static int
 665 backup_modified_conffiles(pkg_t *pkg, pkg_t *old_pkg)
 666 {
 667      int err;
 668      conffile_list_elt_t *iter;
 669      conffile_t *cf;
 670
 671      if (conf->noaction) return 0;
 672
 673      /* Backup all modified conffiles */
 674      if (old_pkg) {
 675           for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
 676                char *cf_name;
 677
 678                cf = iter->data;
 679                cf_name = root_filename_alloc(cf->name);
 680
 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);
 684                     if (err) {
 685                          return err;
 686                     }
 687                }
 688                free(cf_name);
 689           }
 690      }
 691
 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)) {
 694           char *cf_name;
 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)) {
 699                continue;
 700           }
 701
 702           if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
 703                err = backup_make_backup(cf_name);
 704                if (err) {
 705                     return err;
 706                }
 707           }
 708           free(cf_name);
 709      }
 710
 711      return 0;
 712 }
 713
 714 static int
 715 backup_modified_conffiles_unwind(pkg_t *pkg, pkg_t *old_pkg)
 716 {
 717      conffile_list_elt_t *iter;
 718
 719      if (old_pkg) {
 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);
 722           }
 723      }
 724
 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);
 727      }
 728
 729      return 0;
 730 }
 731
 732
 733 static int
 734 check_data_file_clashes(pkg_t *pkg, pkg_t *old_pkg)
 735 {
 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.
 743
 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
 747         other package.
 748      */
 749      str_list_t *files_list;
 750      str_list_elt_t *iter, *niter;
 751
 752      int clashes = 0;
 753
 754      files_list = pkg_get_installed_files(pkg);
 755      if (files_list == NULL)
 756              return -1;
 757
 758      for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
 759              iter;
 760              iter = niter, niter = str_list_next(files_list, iter)) {
 761           char *root_filename;
 762           char *filename = (char *) iter->data;
 763           root_filename = root_filename_alloc(filename);
 764           if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
 765                pkg_t *owner;
 766                pkg_t *obs;
 767
 768                if (backup_exists_for(root_filename)) {
 769                     continue;
 770                }
 771
 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);
 776                     continue;
 777                }
 778
 779                owner = file_hash_get_file_owner(filename);
 780
 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) {
 784                          continue;
 785                     }
 786                }
 787
 788                /* Pre-existing files are OK if owned by a package replaced by new pkg. */
 789                if (owner) {
 790                     opkg_msg(DEBUG2, "Checking replaces for %s in package %s\n",
 791                                 filename, owner->name);
 792                     if (pkg_replaces(pkg, owner)) {
 793                          continue;
 794                     }
 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);
 801                          continue;
 802                     }
 803                }
 804
 805                /* Pre-existing files are OK if they are obsolete */
 806                obs = hash_table_get(&conf->obs_file_hash, filename);
 807                if (obs) {
 808                     opkg_msg(INFO, "Pre-exiting file %s is obsolete."
 809                                    " obs_pkg=%s\n",
 810                                     filename, obs->name);
 811                     continue;
 812                }
 813
 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);
 818                if (owner) {
 819                     opkg_msg(ERROR, "%s\n", owner->name);
 820                } else {
 821                     opkg_msg(ERROR, "<no package>\n"
 822                         "Please move this file out of the way and try again.\n");
 823                }
 824                clashes++;
 825           }
 826           free(root_filename);
 827      }
 828      pkg_free_installed_files(pkg);
 829
 830      return clashes;
 831 }
 832
 833 /*
 834  * XXX: This function sucks, as does the below comment.
 835  */
 836 static int
 837 check_data_file_clashes_change(pkg_t *pkg, pkg_t *old_pkg)
 838 {
 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
 843        happens )
 844        Only the action that are needed to change name should be considered.
 845        @@@ To change after 1.0 release.
 846      */
 847      str_list_t *files_list;
 848      str_list_elt_t *iter, *niter;
 849
 850      char *root_filename = NULL;
 851
 852      files_list = pkg_get_installed_files(pkg);
 853      if (files_list == NULL)
 854              return -1;
 855
 856      for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
 857              iter;
 858              iter = niter, niter = str_list_next(files_list, niter)) {
 859           char *filename = (char *) iter->data;
 860           if (root_filename) {
 861               free(root_filename);
 862               root_filename = NULL;
 863           }
 864           root_filename = root_filename_alloc(filename);
 865           if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
 866                pkg_t *owner;
 867
 868                owner = file_hash_get_file_owner(filename);
 869
 870                if (conf->force_overwrite) {
 871                     /* but we need to change who owns this file */
 872                     file_hash_set_file_owner(filename, pkg);
 873                     continue;
 874                }
 875
 876
 877                /* Pre-existing files are OK if owned by a package replaced by new pkg. */
 878                if (owner) {
 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);
 886                          continue;
 887                     }
 888                }
 889
 890           }
 891      }
 892      if (root_filename) {
 893          free(root_filename);
 894          root_filename = NULL;
 895      }
 896      pkg_free_installed_files(pkg);
 897
 898      return 0;
 899 }
 900
 901 static int
 902 check_data_file_clashes_unwind(pkg_t *pkg, pkg_t *old_pkg)
 903 {
 904      /* Nothing to do since check_data_file_clashes doesn't change state */
 905      return 0;
 906 }
 907
 908 static int
 909 postrm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
 910 {
 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    */
 918      return 0;
 919 }
 920
 921 static int
 922 postrm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
 923 {
 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)
 927      */
 928     return 0;
 929 }
 930
 931 static int
 932 remove_obsolesced_files(pkg_t *pkg, pkg_t *old_pkg)
 933 {
 934      int err = 0;
 935      str_list_t *old_files;
 936      str_list_elt_t *of;
 937      str_list_t *new_files;
 938      str_list_elt_t *nf;
 939      hash_table_t new_files_table;
 940
 941      old_files = pkg_get_installed_files(old_pkg);
 942      if (old_files == NULL)
 943           return -1;
 944
 945      new_files = pkg_get_installed_files(pkg);
 946      if (new_files == NULL) {
 947           pkg_free_installed_files(old_pkg);
 948           return -1;
 949      }
 950
 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)) {
 954          if (nf && nf->data)
 955             hash_table_insert(&new_files_table, nf->data, nf->data);
 956      }
 957
 958      for (of = str_list_first(old_files); of; of = str_list_next(old_files, of)) {
 959           pkg_t *owner;
 960           char *old, *new;
 961           old = (char *)of->data;
 962           new = (char *) hash_table_get (&new_files_table, old);
 963           if (new)
 964                continue;
 965
 966           if (file_is_dir(old)) {
 967                continue;
 968           }
 969           owner = file_hash_get_file_owner(old);
 970           if (owner != old_pkg) {
 971                /* in case obsolete file no longer belongs to old_pkg */
 972                continue;
 973           }
 974
 975           /* old file is obsolete */
 976           opkg_msg(INFO, "Removing obsolete file %s.\n", old);
 977           if (!conf->noaction) {
 978                err = unlink(old);
 979                if (err) {
 980                     opkg_perror(ERROR, "unlinking %s failed", old);
 981                }
 982           }
 983      }
 984
 985      hash_table_deinit(&new_files_table);
 986      pkg_free_installed_files(old_pkg);
 987      pkg_free_installed_files(pkg);
 988
 989      return err;
 990 }
 991
 992 static int
 993 install_maintainer_scripts(pkg_t *pkg, pkg_t *old_pkg)
 994 {
 995      int ret;
 996      char *prefix;
 997
 998      sprintf_alloc(&prefix, "%s.", pkg->name);
 999      ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
1000                                                         pkg->dest->info_dir,
1001                                                         prefix);
1002      free(prefix);
1003      return ret;
1004 }
1005
1006 static int
1007 remove_disappeared(pkg_t *pkg)
1008 {
1009      /* DPKG_INCOMPATIBILITY:
1010         This is a fairly sophisticated dpkg operation. Shall we
1011         skip it? */
1012
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.
1023      */
1024      return 0;
1025 }
1026
1027 static int
1028 install_data_files(pkg_t *pkg)
1029 {
1030      int err;
1031
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. */
1036
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);
1039      if (err) {
1040           return err;
1041      }
1042
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.
1045       *
1046       * XXX: This should be fixed outside of opkg, in the Package list.
1047       */
1048      set_flags_from_control(pkg) ;
1049
1050      opkg_msg(DEBUG, "Calling pkg_write_filelist.\n");
1051      err = pkg_write_filelist(pkg);
1052      if (err)
1053           return err;
1054
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. */
1065
1066      return 0;
1067 }
1068
1069 static int
1070 resolve_conffiles(pkg_t *pkg)
1071 {
1072      conffile_list_elt_t *iter;
1073      conffile_t *cf;
1074      char *cf_backup;
1075      char *md5sum;
1076
1077      if (conf->noaction) return 0;
1078
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);
1083
1084           /* Might need to initialize the md5sum for each conffile */
1085           if (cf->value == NULL) {
1086                cf->value = file_md5sum_alloc(root_filename);
1087           }
1088
1089           if (!file_exists(root_filename)) {
1090                free(root_filename);
1091                continue;
1092           }
1093
1094           cf_backup = backup_filename_alloc(root_filename);
1095
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",
1102                                       cf_backup);
1103                   } else {
1104                       char *new_conffile;
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);
1112                       free(new_conffile);
1113                   }
1114               }
1115               unlink(cf_backup);
1116               if (md5sum)
1117                   free(md5sum);
1118           }
1119
1120           free(cf_backup);
1121           free(root_filename);
1122      }
1123
1124      return 0;
1125 }
1126
1127
1128 int
1129 opkg_install_by_name(const char *pkg_name)
1130 {
1131      int cmp;
1132      pkg_t *old, *new;
1133      char *old_version, *new_version;
1134
1135      old = pkg_hash_fetch_installed_by_name(pkg_name);
1136      if (old)
1137         opkg_msg(DEBUG2, "Old versions from pkg_hash_fetch %s.\n",
1138                         old->version);
1139
1140      new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name);
1141      if (new == NULL)
1142         return -1;
1143
1144      opkg_msg(DEBUG2, "Versions from pkg_hash_fetch:");
1145      if ( old )
1146         opkg_msg(DEBUG2, " old %s ", old->version);
1147      opkg_msg(DEBUG2, " new %s\n", new->version);
1148
1149      new->state_flag |= SF_USER;
1150      if (old) {
1151           old_version = pkg_version_str_alloc(old);
1152           new_version = pkg_version_str_alloc(new);
1153
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 */
1160           }
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) {
1167                opkg_msg(NOTICE,
1168                             "Package %s (%s) installed in %s is up to date.\n",
1169                             old->name, old_version, old->dest->name);
1170                free(old_version);
1171                free(new_version);
1172                return 0;
1173           } else if (cmp > 0) {
1174                opkg_msg(NOTICE,
1175                             "Not downgrading package %s on %s from %s to %s.\n",
1176                             old->name, old->dest->name, old_version, new_version);
1177                free(old_version);
1178                free(new_version);
1179                return 0;
1180           } else if (cmp < 0) {
1181                new->dest = old->dest;
1182                old->state_want = SW_DEINSTALL;    /* Here probably the problem for bug 1277 */
1183           }
1184           free(old_version);
1185           free(new_version);
1186      }
1187
1188      opkg_msg(DEBUG2,"Calling opkg_install_pkg.\n");
1189      return opkg_install_pkg(new, 0);
1190 }
1191
1192 /**
1193  *  @brief Really install a pkg_t
1194  */
1195 int
1196 opkg_install_pkg(pkg_t *pkg, int from_upgrade)
1197 {
1198      int err = 0;
1199      int message = 0;
1200      pkg_t *old_pkg = NULL;
1201      pkg_vec_t *replacees;
1202      abstract_pkg_t *ab_pkg = NULL;
1203      int old_state_flag;
1204      char* file_md5;
1205 #ifdef HAVE_SHA256
1206      char* file_sha256;
1207 #endif
1208      sigset_t newset, oldset;
1209
1210      if ( from_upgrade )
1211         message = 1;            /* Coming from an upgrade, and should change the output message */
1212
1213      opkg_msg(DEBUG2, "Calling pkg_arch_supported.\n");
1214
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);
1218           return -1;
1219      }
1220      if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
1221           err = satisfy_dependencies_for(pkg);
1222           if (err)
1223                   return -1;
1224
1225           opkg_msg(NOTICE, "Package %s is already installed on %s.\n",
1226                        pkg->name, pkg->dest->name);
1227           return 0;
1228      }
1229
1230      if (pkg->dest == NULL) {
1231           pkg->dest = conf->default_dest;
1232      }
1233
1234      old_pkg = pkg_hash_fetch_installed_by_name(pkg->name);
1235
1236      err = opkg_install_check_downgrade(pkg, old_pkg, message);
1237      if (err)
1238              return -1;
1239
1240      pkg->state_want = SW_INSTALL;
1241      if (old_pkg){
1242          old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependencies */
1243      }
1244
1245      err = check_conflicts_for(pkg);
1246      if (err)
1247              return -1;
1248
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)
1254              return 0;
1255
1256      err = verify_pkg_installable(pkg);
1257      if (err)
1258              return -1;
1259
1260      if (pkg->local_filename == NULL) {
1261          if(!conf->cache && conf->download_only){
1262              char cwd[4096];
1263              if(getcwd(cwd, sizeof(cwd)) != NULL)
1264                 err = opkg_download_pkg(pkg, cwd);
1265              else
1266                 return -1;
1267          } else {
1268              err = opkg_download_pkg(pkg, conf->tmp_dir);
1269          }
1270           if (err) {
1271                opkg_msg(ERROR, "Failed to download %s. "
1272                                "Perhaps you need to run 'opkg update'?\n",
1273                             pkg->name);
1274                return -1;
1275           }
1276      }
1277
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;
1281
1282      /* check to ensure the package has come from a repository */
1283      if (conf->check_signature && pkg->src)
1284      {
1285        sprintf_alloc (&lists_dir, "%s",
1286                      (conf->restrict_to_default_dest)
1287                       ? conf->default_dest->lists_dir
1288                       : conf->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);
1291
1292        if (file_exists (sig_file_name))
1293        {
1294          if (opkg_verify_file (list_file_name, sig_file_name)){
1295            opkg_msg(ERROR, "Failed to verify the signature of %s.\n",
1296                            list_file_name);
1297            return -1;
1298          }
1299        }else{
1300          opkg_msg(ERROR, "Signature file is missing for %s. "
1301                          "Perhaps you need to run 'opkg update'?\n",
1302                          pkg->name);
1303          return -1;
1304        }
1305
1306        free (lists_dir);
1307        free (list_file_name);
1308        free (sig_file_name);
1309      }
1310      #endif
1311
1312      /* Check for md5 values */
1313      if (pkg->md5sum)
1314      {
1315          file_md5 = file_md5sum_alloc(pkg->local_filename);
1316          if (file_md5 && strcmp(file_md5, pkg->md5sum))
1317          {
1318               opkg_msg(ERROR, "Package %s md5sum mismatch. "
1319                         "Either the opkg or the package index are corrupt. "
1320                         "Try 'opkg update'.\n",
1321                         pkg->name);
1322               free(file_md5);
1323               return -1;
1324          }
1325          if (file_md5)
1326               free(file_md5);
1327      }
1328
1329 #ifdef HAVE_SHA256
1330      /* Check for sha256 value */
1331      if(pkg->sha256sum)
1332      {
1333          file_sha256 = file_sha256sum_alloc(pkg->local_filename);
1334          if (file_sha256 && strcmp(file_sha256, pkg->sha256sum))
1335          {
1336               opkg_msg(ERROR, "Package %s sha256sum mismatch. "
1337                         "Either the opkg or the package index are corrupt. "
1338                         "Try 'opkg update'.\n",
1339                         pkg->name);
1340               free(file_sha256);
1341               return -1;
1342          }
1343          if (file_sha256)
1344               free(file_sha256);
1345      }
1346 #endif
1347      if(conf->download_only) {
1348          if (conf->nodeps == 0) {
1349              err = satisfy_dependencies_for(pkg);
1350              if (err)
1351                  return -1;
1352          }
1353          return 0;
1354      }
1355
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);
1360                return -1;
1361           }
1362      }
1363
1364      err = update_file_ownership(pkg, old_pkg);
1365      if (err)
1366              return -1;
1367
1368      if (conf->nodeps == 0) {
1369           err = satisfy_dependencies_for(pkg);
1370           if (err)
1371                 return -1;
1372           if (pkg->state_status == SS_UNPACKED)
1373                /* Circular dependency has installed it for us. */
1374                 return 0;
1375      }
1376
1377      replacees = pkg_vec_alloc();
1378      pkg_get_installed_replacees(pkg, replacees);
1379
1380      /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1381
1382           sigemptyset(&newset);
1383           sigaddset(&newset, SIGINT);
1384           sigprocmask(SIG_BLOCK, &newset, &oldset);
1385
1386           opkg_state_changed++;
1387           pkg->state_flag |= SF_FILELIST_CHANGED;
1388
1389           if (old_pkg)
1390                pkg_remove_orphan_dependent(pkg, old_pkg);
1391
1392           /* XXX: BUG: we really should treat replacement more like an upgrade
1393            *      Instead, we're going to remove the replacees
1394            */
1395           err = pkg_remove_installed_replacees(replacees);
1396           if (err)
1397                   goto UNWIND_REMOVE_INSTALLED_REPLACEES;
1398
1399           err = prerm_upgrade_old_pkg(pkg, old_pkg);
1400           if (err)
1401                   goto UNWIND_PRERM_UPGRADE_OLD_PKG;
1402
1403           err = prerm_deconfigure_conflictors(pkg, replacees);
1404           if (err)
1405                   goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
1406
1407           err = preinst_configure(pkg, old_pkg);
1408           if (err)
1409                   goto UNWIND_PREINST_CONFIGURE;
1410
1411           err = backup_modified_conffiles(pkg, old_pkg);
1412           if (err)
1413                   goto UNWIND_BACKUP_MODIFIED_CONFFILES;
1414
1415           err = check_data_file_clashes(pkg, old_pkg);
1416           if (err)
1417                   goto UNWIND_CHECK_DATA_FILE_CLASHES;
1418
1419           err = postrm_upgrade_old_pkg(pkg, old_pkg);
1420           if (err)
1421                   goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
1422
1423           if (conf->noaction)
1424                   return 0;
1425
1426           /* point of no return: no unwinding after this */
1427           if (old_pkg && !conf->force_reinstall) {
1428                old_pkg->state_want = SW_DEINSTALL;
1429
1430                if (old_pkg->state_flag & SF_NOPRUNE) {
1431                     opkg_msg(INFO, "Not removing obsolesced files because "
1432                                     "package %s marked noprune.\n",
1433                                     old_pkg->name);
1434                } else {
1435                     opkg_msg(INFO, "Removing obsolesced files for %s\n",
1436                                     old_pkg->name);
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);
1441                     }
1442                }
1443
1444                /* removing files from old package, to avoid ghost files */
1445                remove_data_files_and_list(old_pkg);
1446                remove_maintainer_scripts(old_pkg);
1447           }
1448
1449
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",
1454                                pkg->name);
1455                 goto pkg_is_hosed;
1456           }
1457
1458           /* the following just returns 0 */
1459           remove_disappeared(pkg);
1460
1461           opkg_msg(INFO, "Installing data files for %s.\n", pkg->name);
1462
1463           if (install_data_files(pkg)) {
1464                 opkg_msg(ERROR, "Failed to extract data files for %s. "
1465                                 "Package debris may remain!\n",
1466                                pkg->name);
1467                 goto pkg_is_hosed;
1468           }
1469
1470           err = check_data_file_clashes_change(pkg, old_pkg);
1471           if (err) {
1472                 opkg_msg(ERROR, "check_data_file_clashes_change() failed for "
1473                                "for files belonging to %s.\n",
1474                                pkg->name);
1475           }
1476
1477           opkg_msg(INFO, "Resolving conf files for %s\n", pkg->name);
1478           resolve_conffiles(pkg);
1479
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);
1485
1486           if (old_pkg && !conf->force_reinstall) {
1487                old_pkg->state_status = SS_NOT_INSTALLED;
1488           }
1489
1490           time(&pkg->installed_time);
1491
1492           ab_pkg = pkg->parent;
1493           if (ab_pkg)
1494                ab_pkg->state_status = pkg->state_status;
1495
1496           sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1497           pkg_vec_free (replacees);
1498           return 0;
1499
1500
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);
1515
1516 pkg_is_hosed:
1517           sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1518
1519           pkg_vec_free (replacees);
1520           return -1;
1521 }