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(ERROR, "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         opkg_msg(NOTICE, "Unknown package '%s'.\n", pkg_name);
1143         return -1;
1144      }
1145
1146      opkg_msg(DEBUG2, "Versions from pkg_hash_fetch:");
1147      if ( old )
1148         opkg_msg(DEBUG2, " old %s ", old->version);
1149      opkg_msg(DEBUG2, " new %s\n", new->version);
1150
1151      new->state_flag |= SF_USER;
1152      if (old) {
1153           old_version = pkg_version_str_alloc(old);
1154           new_version = pkg_version_str_alloc(new);
1155
1156           cmp = pkg_compare_versions(old, new);
1157           if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
1158              opkg_msg(DEBUG, "Forcing downgrade\n");
1159              cmp = -1 ;                                       /* then we force opkg to downgrade */
1160                                                               /* We need to use a value < 0 because in the 0 case we are asking to */
1161                                                               /* reinstall, and some check could fail asking the "force-reinstall" option */
1162           }
1163           opkg_msg(DEBUG, "Comparing visible versions of pkg %s:"
1164                        "\n\t%s is installed "
1165                        "\n\t%s is available "
1166                        "\n\t%d was comparison result\n",
1167                        pkg_name, old_version, new_version, cmp);
1168           if (cmp == 0 && !conf->force_reinstall) {
1169                opkg_msg(NOTICE,
1170                             "Package %s (%s) installed in %s is up to date.\n",
1171                             old->name, old_version, old->dest->name);
1172                free(old_version);
1173                free(new_version);
1174                return 0;
1175           } else if (cmp > 0) {
1176                opkg_msg(NOTICE,
1177                             "Not downgrading package %s on %s from %s to %s.\n",
1178                             old->name, old->dest->name, old_version, new_version);
1179                free(old_version);
1180                free(new_version);
1181                return 0;
1182           } else if (cmp < 0) {
1183                new->dest = old->dest;
1184                old->state_want = SW_DEINSTALL;    /* Here probably the problem for bug 1277 */
1185           }
1186           free(old_version);
1187           free(new_version);
1188      }
1189
1190      opkg_msg(DEBUG2,"Calling opkg_install_pkg.\n");
1191      return opkg_install_pkg(new, 0);
1192 }
1193
1194 /**
1195  *  @brief Really install a pkg_t
1196  */
1197 int
1198 opkg_install_pkg(pkg_t *pkg, int from_upgrade)
1199 {
1200      int err = 0;
1201      int message = 0;
1202      pkg_t *old_pkg = NULL;
1203      pkg_vec_t *replacees;
1204      abstract_pkg_t *ab_pkg = NULL;
1205      int old_state_flag;
1206      char* file_md5;
1207 #ifdef HAVE_SHA256
1208      char* file_sha256;
1209 #endif
1210      sigset_t newset, oldset;
1211
1212      if ( from_upgrade )
1213         message = 1;            /* Coming from an upgrade, and should change the output message */
1214
1215      opkg_msg(DEBUG2, "Calling pkg_arch_supported.\n");
1216
1217      if (!pkg_arch_supported(pkg)) {
1218           opkg_msg(ERROR, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1219                        pkg->architecture, pkg->name);
1220           return -1;
1221      }
1222      if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
1223           err = satisfy_dependencies_for(pkg);
1224           if (err)
1225                   return -1;
1226
1227           opkg_msg(NOTICE, "Package %s is already installed on %s.\n",
1228                        pkg->name, pkg->dest->name);
1229           return 0;
1230      }
1231
1232      if (pkg->dest == NULL) {
1233           pkg->dest = conf->default_dest;
1234      }
1235
1236      old_pkg = pkg_hash_fetch_installed_by_name(pkg->name);
1237
1238      err = opkg_install_check_downgrade(pkg, old_pkg, message);
1239      if (err)
1240              return -1;
1241
1242      pkg->state_want = SW_INSTALL;
1243      if (old_pkg){
1244          old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependencies */
1245      }
1246
1247      err = check_conflicts_for(pkg);
1248      if (err)
1249              return -1;
1250
1251      /* this setup is to remove the upgrade scenario in the end when
1252         installing pkg A, A deps B & B deps on A. So both B and A are
1253         installed. Then A's installation is started resulting in an
1254         uncecessary upgrade */
1255      if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0)
1256              return 0;
1257
1258      err = verify_pkg_installable(pkg);
1259      if (err)
1260              return -1;
1261
1262      if (pkg->local_filename == NULL) {
1263          if(!conf->cache && conf->download_only){
1264              char cwd[4096];
1265              if(getcwd(cwd, sizeof(cwd)) != NULL)
1266                 err = opkg_download_pkg(pkg, cwd);
1267              else
1268                 return -1;
1269          } else {
1270              err = opkg_download_pkg(pkg, conf->tmp_dir);
1271          }
1272           if (err) {
1273                opkg_msg(ERROR, "Failed to download %s. "
1274                                "Perhaps you need to run 'opkg update'?\n",
1275                             pkg->name);
1276                return -1;
1277           }
1278      }
1279
1280      /* check that the repository is valid */
1281      #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
1282      char *list_file_name, *sig_file_name, *lists_dir;
1283
1284      /* check to ensure the package has come from a repository */
1285      if (conf->check_signature && pkg->src)
1286      {
1287        sprintf_alloc (&lists_dir, "%s",
1288                      (conf->restrict_to_default_dest)
1289                       ? conf->default_dest->lists_dir
1290                       : conf->lists_dir);
1291        sprintf_alloc (&list_file_name, "%s/%s", lists_dir, pkg->src->name);
1292        sprintf_alloc (&sig_file_name, "%s/%s.sig", lists_dir, pkg->src->name);
1293
1294        if (file_exists (sig_file_name))
1295        {
1296          if (opkg_verify_file (list_file_name, sig_file_name)){
1297            opkg_msg(ERROR, "Failed to verify the signature of %s.\n",
1298                            list_file_name);
1299            return -1;
1300          }
1301        }else{
1302          opkg_msg(ERROR, "Signature file is missing for %s. "
1303                          "Perhaps you need to run 'opkg update'?\n",
1304                          pkg->name);
1305          return -1;
1306        }
1307
1308        free (lists_dir);
1309        free (list_file_name);
1310        free (sig_file_name);
1311      }
1312      #endif
1313
1314      /* Check for md5 values */
1315      if (pkg->md5sum)
1316      {
1317          file_md5 = file_md5sum_alloc(pkg->local_filename);
1318          if (file_md5 && strcmp(file_md5, pkg->md5sum))
1319          {
1320               opkg_msg(ERROR, "Package %s md5sum mismatch. "
1321                         "Either the opkg or the package index are corrupt. "
1322                         "Try 'opkg update'.\n",
1323                         pkg->name);
1324               free(file_md5);
1325               return -1;
1326          }
1327          if (file_md5)
1328               free(file_md5);
1329      }
1330
1331 #ifdef HAVE_SHA256
1332      /* Check for sha256 value */
1333      if(pkg->sha256sum)
1334      {
1335          file_sha256 = file_sha256sum_alloc(pkg->local_filename);
1336          if (file_sha256 && strcmp(file_sha256, pkg->sha256sum))
1337          {
1338               opkg_msg(ERROR, "Package %s sha256sum mismatch. "
1339                         "Either the opkg or the package index are corrupt. "
1340                         "Try 'opkg update'.\n",
1341                         pkg->name);
1342               free(file_sha256);
1343               return -1;
1344          }
1345          if (file_sha256)
1346               free(file_sha256);
1347      }
1348 #endif
1349      if(conf->download_only) {
1350          if (conf->nodeps == 0) {
1351              err = satisfy_dependencies_for(pkg);
1352              if (err)
1353                  return -1;
1354          }
1355          return 0;
1356      }
1357
1358      if (pkg->tmp_unpack_dir == NULL) {
1359           if (unpack_pkg_control_files(pkg) == -1) {
1360                opkg_msg(ERROR, "Failed to unpack control files from %s.\n",
1361                                pkg->local_filename);
1362                return -1;
1363           }
1364      }
1365
1366      err = update_file_ownership(pkg, old_pkg);
1367      if (err)
1368              return -1;
1369
1370      if (conf->nodeps == 0) {
1371           err = satisfy_dependencies_for(pkg);
1372           if (err)
1373                 return -1;
1374           if (pkg->state_status == SS_UNPACKED)
1375                /* Circular dependency has installed it for us. */
1376                 return 0;
1377      }
1378
1379      replacees = pkg_vec_alloc();
1380      pkg_get_installed_replacees(pkg, replacees);
1381
1382      /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1383
1384           sigemptyset(&newset);
1385           sigaddset(&newset, SIGINT);
1386           sigprocmask(SIG_BLOCK, &newset, &oldset);
1387
1388           opkg_state_changed++;
1389           pkg->state_flag |= SF_FILELIST_CHANGED;
1390
1391           if (old_pkg)
1392                pkg_remove_orphan_dependent(pkg, old_pkg);
1393
1394           /* XXX: BUG: we really should treat replacement more like an upgrade
1395            *      Instead, we're going to remove the replacees
1396            */
1397           err = pkg_remove_installed_replacees(replacees);
1398           if (err)
1399                   goto UNWIND_REMOVE_INSTALLED_REPLACEES;
1400
1401           err = prerm_upgrade_old_pkg(pkg, old_pkg);
1402           if (err)
1403                   goto UNWIND_PRERM_UPGRADE_OLD_PKG;
1404
1405           err = prerm_deconfigure_conflictors(pkg, replacees);
1406           if (err)
1407                   goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
1408
1409           err = preinst_configure(pkg, old_pkg);
1410           if (err)
1411                   goto UNWIND_PREINST_CONFIGURE;
1412
1413           err = backup_modified_conffiles(pkg, old_pkg);
1414           if (err)
1415                   goto UNWIND_BACKUP_MODIFIED_CONFFILES;
1416
1417           err = check_data_file_clashes(pkg, old_pkg);
1418           if (err)
1419                   goto UNWIND_CHECK_DATA_FILE_CLASHES;
1420
1421           err = postrm_upgrade_old_pkg(pkg, old_pkg);
1422           if (err)
1423                   goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
1424
1425           if (conf->noaction)
1426                   return 0;
1427
1428           /* point of no return: no unwinding after this */
1429           if (old_pkg && !conf->force_reinstall) {
1430                old_pkg->state_want = SW_DEINSTALL;
1431
1432                if (old_pkg->state_flag & SF_NOPRUNE) {
1433                     opkg_msg(INFO, "Not removing obsolesced files because "
1434                                     "package %s marked noprune.\n",
1435                                     old_pkg->name);
1436                } else {
1437                     opkg_msg(INFO, "Removing obsolesced files for %s\n",
1438                                     old_pkg->name);
1439                     if (remove_obsolesced_files(pkg, old_pkg)) {
1440                         opkg_msg(ERROR, "Failed to determine "
1441                                         "obsolete files from previously "
1442                                         "installed %s\n", old_pkg->name);
1443                     }
1444                }
1445
1446                /* removing files from old package, to avoid ghost files */
1447                remove_data_files_and_list(old_pkg);
1448                remove_maintainer_scripts(old_pkg);
1449           }
1450
1451
1452           opkg_msg(INFO, "Installing maintainer scripts.\n");
1453           if (install_maintainer_scripts(pkg, old_pkg)) {
1454                 opkg_msg(ERROR, "Failed to extract maintainer scripts for %s."
1455                                " Package debris may remain!\n",
1456                                pkg->name);
1457                 goto pkg_is_hosed;
1458           }
1459
1460           /* the following just returns 0 */
1461           remove_disappeared(pkg);
1462
1463           opkg_msg(INFO, "Installing data files for %s.\n", pkg->name);
1464
1465           if (install_data_files(pkg)) {
1466                 opkg_msg(ERROR, "Failed to extract data files for %s. "
1467                                 "Package debris may remain!\n",
1468                                pkg->name);
1469                 goto pkg_is_hosed;
1470           }
1471
1472           err = check_data_file_clashes_change(pkg, old_pkg);
1473           if (err) {
1474                 opkg_msg(ERROR, "check_data_file_clashes_change() failed for "
1475                                "for files belonging to %s.\n",
1476                                pkg->name);
1477           }
1478
1479           opkg_msg(INFO, "Resolving conf files for %s\n", pkg->name);
1480           resolve_conffiles(pkg);
1481
1482           pkg->state_status = SS_UNPACKED;
1483           old_state_flag = pkg->state_flag;
1484           pkg->state_flag &= ~SF_PREFER;
1485           opkg_msg(DEBUG, "pkg=%s old_state_flag=%x state_flag=%x\n",
1486                           pkg->name, old_state_flag, pkg->state_flag);
1487
1488           if (old_pkg && !conf->force_reinstall) {
1489                old_pkg->state_status = SS_NOT_INSTALLED;
1490           }
1491
1492           time(&pkg->installed_time);
1493
1494           ab_pkg = pkg->parent;
1495           if (ab_pkg)
1496                ab_pkg->state_status = pkg->state_status;
1497
1498           sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1499           pkg_vec_free (replacees);
1500           return 0;
1501
1502
1503      UNWIND_POSTRM_UPGRADE_OLD_PKG:
1504           postrm_upgrade_old_pkg_unwind(pkg, old_pkg);
1505      UNWIND_CHECK_DATA_FILE_CLASHES:
1506           check_data_file_clashes_unwind(pkg, old_pkg);
1507      UNWIND_BACKUP_MODIFIED_CONFFILES:
1508           backup_modified_conffiles_unwind(pkg, old_pkg);
1509      UNWIND_PREINST_CONFIGURE:
1510           preinst_configure_unwind(pkg, old_pkg);
1511      UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1512           prerm_deconfigure_conflictors_unwind(pkg, replacees);
1513      UNWIND_PRERM_UPGRADE_OLD_PKG:
1514           prerm_upgrade_old_pkg_unwind(pkg, old_pkg);
1515      UNWIND_REMOVE_INSTALLED_REPLACEES:
1516           pkg_remove_installed_replacees_unwind(replacees);
1517
1518 pkg_is_hosed:
1519           sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1520
1521           pkg_vec_free (replacees);
1522           return -1;
1523 }