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 "includes.h"
  19 #include <errno.h>
  20 #include <dirent.h>
  21 #include <glob.h>
  22 #include <time.h>
  23 #include <signal.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_msg(ERROR, "\t%s", *unresolved);
  62                free(*unresolved);
  63                unresolved++;
  64           }
  65           free(tmp);
  66           opkg_msg(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;
 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                                 opkg_remove_pkg(p, 0);
 366                         } else
 367                                 opkg_msg(INFO, "%s was autoinstalled and is "
 368                                                 "still required by %d "
 369                                                 "installed packages.\n",
 370                                                 p->name, n_deps);
 371
 372                 }
 373         }
 374
 375         return 0;
 376 }
 377
 378 /* returns number of installed replacees */
 379 static int
 380 pkg_get_installed_replacees(pkg_t *pkg, pkg_vec_t *installed_replacees)
 381 {
 382      abstract_pkg_t **replaces = pkg->replaces;
 383      int replaces_count = pkg->replaces_count;
 384      int i, j;
 385      for (i = 0; i < replaces_count; i++) {
 386           abstract_pkg_t *ab_pkg = replaces[i];
 387           pkg_vec_t *pkg_vec = ab_pkg->pkgs;
 388           if (pkg_vec) {
 389                for (j = 0; j < pkg_vec->len; j++) {
 390                     pkg_t *replacee = pkg_vec->pkgs[j];
 391                     if (!pkg_conflicts(pkg, replacee))
 392                          continue;
 393                     if (replacee->state_status == SS_INSTALLED) {
 394                          pkg_vec_insert(installed_replacees, replacee);
 395                     }
 396                }
 397           }
 398      }
 399      return installed_replacees->len;
 400 }
 401
 402 static int
 403 pkg_remove_installed_replacees(pkg_vec_t *replacees)
 404 {
 405      int i;
 406      int replaces_count = replacees->len;
 407      for (i = 0; i < replaces_count; i++) {
 408           pkg_t *replacee = replacees->pkgs[i];
 409           int err;
 410           replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
 411           err = opkg_remove_pkg(replacee, 0);
 412           if (err)
 413                return err;
 414      }
 415      return 0;
 416 }
 417
 418 /* to unwind the removal: make sure they are installed */
 419 static int
 420 pkg_remove_installed_replacees_unwind(pkg_vec_t *replacees)
 421 {
 422      int i, err;
 423      int replaces_count = replacees->len;
 424      for (i = 0; i < replaces_count; i++) {
 425           pkg_t *replacee = replacees->pkgs[i];
 426           if (replacee->state_status != SS_INSTALLED) {
 427                opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
 428                err = opkg_install_pkg(replacee, 0);
 429                if (err)
 430                     return err;
 431           }
 432      }
 433      return 0;
 434 }
 435
 436 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
 437 static int
 438 opkg_install_check_downgrade(pkg_t *pkg, pkg_t *old_pkg, int message)
 439 {
 440      if (old_pkg) {
 441           char message_out[15];
 442           char *old_version = pkg_version_str_alloc(old_pkg);
 443           char *new_version = pkg_version_str_alloc(pkg);
 444           int cmp = pkg_compare_versions(old_pkg, pkg);
 445           int rc = 0;
 446
 447           memset(message_out,'\x0',15);
 448           strncpy (message_out,"Upgrading ",strlen("Upgrading "));
 449           if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
 450              cmp = -1 ;                                       /* then we force opkg to downgrade */
 451              strncpy (message_out,"Downgrading ",strlen("Downgrading "));         /* We need to use a value < 0 because in the 0 case we are asking to */
 452                                                               /* reinstall, and some check could fail asking the "force-reinstall" option */
 453           }
 454
 455           if (cmp > 0) {
 456                opkg_msg(NOTICE,
 457                             "Not downgrading package %s on %s from %s to %s.\n",
 458                             old_pkg->name, old_pkg->dest->name, old_version, new_version);
 459                rc = 1;
 460           } else if (cmp < 0) {
 461                opkg_msg(NOTICE, "%s%s on %s from %s to %s...\n",
 462                             message_out, pkg->name, old_pkg->dest->name, old_version, new_version);
 463                pkg->dest = old_pkg->dest;
 464                rc = 0;
 465           } else /* cmp == 0 */ {
 466                if (conf->force_reinstall) {
 467                     opkg_msg(NOTICE, "Reinstalling %s (%s) on %s...\n",
 468                                  pkg->name, new_version, old_pkg->dest->name);
 469                     pkg->dest = old_pkg->dest;
 470                     rc = 0;
 471                } else {
 472                     opkg_msg(NOTICE, "%s (%s) already install on %s."
 473                                    " Not reinstalling.\n",
 474                                  pkg->name, new_version, old_pkg->dest->name);
 475                     rc = 1;
 476                }
 477           }
 478           free(old_version);
 479           free(new_version);
 480           return rc;
 481      } else {
 482       char message_out[15] ;
 483       memset(message_out,'\x0',15);
 484       if ( message )
 485           strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
 486       else
 487           strncpy( message_out,"Installing ",strlen("Installing ") );
 488           char *version = pkg_version_str_alloc(pkg);
 489
 490           opkg_msg(NOTICE, "%s%s (%s) to %s...\n", message_out,
 491                        pkg->name, version, pkg->dest->name);
 492           free(version);
 493           return 0;
 494      }
 495 }
 496
 497
 498 static int
 499 prerm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
 500 {
 501      /* DPKG_INCOMPATIBILITY:
 502         dpkg does some things here that we don't do yet. Do we care?
 503
 504         1. If a version of the package is already installed, call
 505            old-prerm upgrade new-version
 506         2. If the script runs but exits with a non-zero exit status
 507            new-prerm failed-upgrade old-version
 508            Error unwind, for both the above cases:
 509            old-postinst abort-upgrade new-version
 510      */
 511      return 0;
 512 }
 513
 514 static int
 515 prerm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
 516 {
 517      /* DPKG_INCOMPATIBILITY:
 518         dpkg does some things here that we don't do yet. Do we care?
 519         (See prerm_upgrade_old_package for details)
 520      */
 521      return 0;
 522 }
 523
 524 static int
 525 prerm_deconfigure_conflictors(pkg_t *pkg, pkg_vec_t *conflictors)
 526 {
 527      /* DPKG_INCOMPATIBILITY:
 528         dpkg does some things here that we don't do yet. Do we care?
 529         2. If a 'conflicting' package is being removed at the same time:
 530                 1. If any packages depended on that conflicting package and
 531                    --auto-deconfigure is specified, call, for each such package:
 532                    deconfigured's-prerm deconfigure \
 533                    in-favour package-being-installed version \
 534                    removing conflicting-package version
 535                 Error unwind:
 536                    deconfigured's-postinst abort-deconfigure \
 537                    in-favour package-being-installed-but-failed version \
 538                    removing conflicting-package version
 539
 540                    The deconfigured packages are marked as requiring
 541                    configuration, so that if --install is used they will be
 542                    configured again if possible.
 543                 2. To prepare for removal of the conflicting package, call:
 544                    conflictor's-prerm remove in-favour package new-version
 545                 Error unwind:
 546                    conflictor's-postinst abort-remove in-favour package new-version
 547      */
 548      return 0;
 549 }
 550
 551 static int
 552 prerm_deconfigure_conflictors_unwind(pkg_t *pkg, pkg_vec_t *conflictors)
 553 {
 554      /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
 555         do yet. Do we care?  (See prerm_deconfigure_conflictors for
 556         details) */
 557      return 0;
 558 }
 559
 560 static int
 561 preinst_configure(pkg_t *pkg, pkg_t *old_pkg)
 562 {
 563      int err;
 564      char *preinst_args;
 565
 566      if (old_pkg) {
 567           char *old_version = pkg_version_str_alloc(old_pkg);
 568           sprintf_alloc(&preinst_args, "upgrade %s", old_version);
 569           free(old_version);
 570      } else if (pkg->state_status == SS_CONFIG_FILES) {
 571           char *pkg_version = pkg_version_str_alloc(pkg);
 572           sprintf_alloc(&preinst_args, "install %s", pkg_version);
 573           free(pkg_version);
 574      } else {
 575           preinst_args = xstrdup("install");
 576      }
 577
 578      err = pkg_run_script(pkg, "preinst", preinst_args);
 579      if (err) {
 580           opkg_msg(ERROR, "Aborting installation of %s.\n", pkg->name);
 581           return -1;
 582      }
 583
 584      free(preinst_args);
 585
 586      return 0;
 587 }
 588
 589 static int
 590 preinst_configure_unwind(pkg_t *pkg, pkg_t *old_pkg)
 591 {
 592      /* DPKG_INCOMPATIBILITY:
 593         dpkg does the following error unwind, should we?
 594         pkg->postrm abort-upgrade old-version
 595         OR pkg->postrm abort-install old-version
 596         OR pkg->postrm abort-install
 597      */
 598      return 0;
 599 }
 600
 601 static char *
 602 backup_filename_alloc(const char *file_name)
 603 {
 604      char *backup;
 605
 606      sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
 607
 608      return backup;
 609 }
 610
 611
 612 static int
 613 backup_make_backup(const char *file_name)
 614 {
 615      int err;
 616      char *backup;
 617
 618      backup = backup_filename_alloc(file_name);
 619      err = file_copy(file_name, backup);
 620      if (err) {
 621           opkg_msg(ERROR, "Failed to copy %s to %s\n",
 622                        file_name, backup);
 623      }
 624
 625      free(backup);
 626
 627      return err;
 628 }
 629
 630 static int
 631 backup_exists_for(const char *file_name)
 632 {
 633      int ret;
 634      char *backup;
 635
 636      backup = backup_filename_alloc(file_name);
 637
 638      ret = file_exists(backup);
 639
 640      free(backup);
 641
 642      return ret;
 643 }
 644
 645 static int
 646 backup_remove(const char *file_name)
 647 {
 648      char *backup;
 649
 650      backup = backup_filename_alloc(file_name);
 651      unlink(backup);
 652      free(backup);
 653
 654      return 0;
 655 }
 656
 657 static int
 658 backup_modified_conffiles(pkg_t *pkg, pkg_t *old_pkg)
 659 {
 660      int err;
 661      conffile_list_elt_t *iter;
 662      conffile_t *cf;
 663
 664      if (conf->noaction) return 0;
 665
 666      /* Backup all modified conffiles */
 667      if (old_pkg) {
 668           for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
 669                char *cf_name;
 670
 671                cf = iter->data;
 672                cf_name = root_filename_alloc(cf->name);
 673
 674                /* Don't worry if the conffile is just plain gone */
 675                if (file_exists(cf_name) && conffile_has_been_modified(cf)) {
 676                     err = backup_make_backup(cf_name);
 677                     if (err) {
 678                          return err;
 679                     }
 680                }
 681                free(cf_name);
 682           }
 683      }
 684
 685      /* Backup all conffiles that were not conffiles in old_pkg */
 686      for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
 687           char *cf_name;
 688           cf = (conffile_t *)iter->data;
 689           cf_name = root_filename_alloc(cf->name);
 690           /* Ignore if this was a conffile in old_pkg as well */
 691           if (pkg_get_conffile(old_pkg, cf->name)) {
 692                continue;
 693           }
 694
 695           if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
 696                err = backup_make_backup(cf_name);
 697                if (err) {
 698                     return err;
 699                }
 700           }
 701           free(cf_name);
 702      }
 703
 704      return 0;
 705 }
 706
 707 static int
 708 backup_modified_conffiles_unwind(pkg_t *pkg, pkg_t *old_pkg)
 709 {
 710      conffile_list_elt_t *iter;
 711
 712      if (old_pkg) {
 713           for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
 714                backup_remove(((nv_pair_t *)iter->data)->name);
 715           }
 716      }
 717
 718      for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
 719           backup_remove(((nv_pair_t *)iter->data)->name);
 720      }
 721
 722      return 0;
 723 }
 724
 725
 726 static int
 727 check_data_file_clashes(pkg_t *pkg, pkg_t *old_pkg)
 728 {
 729      /* DPKG_INCOMPATIBILITY:
 730         opkg takes a slightly different approach than dpkg at this
 731         point.  dpkg installs each file in the new package while
 732         creating a backup for any file that is replaced, (so that it
 733         can unwind if necessary).  To avoid complexity and redundant
 734         storage, opkg doesn't do any installation until later, (at the
 735         point at which dpkg removes the backups.
 736
 737         But, we do have to check for data file clashes, since after
 738         installing a package with a file clash, removing either of the
 739         packages involved in the clash has the potential to break the
 740         other package.
 741      */
 742      str_list_t *files_list;
 743      str_list_elt_t *iter, *niter;
 744
 745      int clashes = 0;
 746
 747      files_list = pkg_get_installed_files(pkg);
 748      if (files_list == NULL)
 749              return -1;
 750
 751      for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
 752              iter;
 753              iter = niter, niter = str_list_next(files_list, iter)) {
 754           char *root_filename;
 755           char *filename = (char *) iter->data;
 756           root_filename = root_filename_alloc(filename);
 757           if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
 758                pkg_t *owner;
 759                pkg_t *obs;
 760
 761                if (backup_exists_for(root_filename)) {
 762                     continue;
 763                }
 764
 765                /* Pre-existing files are OK if force-overwrite was asserted. */
 766                if (conf->force_overwrite) {
 767                     /* but we need to change who owns this file */
 768                     file_hash_set_file_owner(filename, pkg);
 769                     continue;
 770                }
 771
 772                owner = file_hash_get_file_owner(filename);
 773
 774                /* Pre-existing files are OK if owned by the pkg being upgraded. */
 775                if (owner && old_pkg) {
 776                     if (strcmp(owner->name, old_pkg->name) == 0) {
 777                          continue;
 778                     }
 779                }
 780
 781                /* Pre-existing files are OK if owned by a package replaced by new pkg. */
 782                if (owner) {
 783                     opkg_msg(DEBUG2, "Checking replaces for %s in package %s\n",
 784                                 filename, owner->name);
 785                     if (pkg_replaces(pkg, owner)) {
 786                          continue;
 787                     }
 788 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
 789    then it's ok to overwrite. */
 790                     if (strcmp(owner->name,pkg->name)==0){
 791                          opkg_msg(INFO, "Replacing pre-existing file %s"
 792                                         " owned by package %s\n",
 793                                         filename, owner->name);
 794                          continue;
 795                     }
 796                }
 797
 798                /* Pre-existing files are OK if they are obsolete */
 799                obs = hash_table_get(&conf->obs_file_hash, filename);
 800                if (obs) {
 801                     opkg_msg(INFO, "Pre-exiting file %s is obsolete."
 802                                    " obs_pkg=%s\n",
 803                                     filename, obs->name);
 804                     continue;
 805                }
 806
 807                /* We have found a clash. */
 808                opkg_msg(ERROR, "Package %s wants to install file %s\n"
 809                             "\tBut that file is already provided by package ",
 810                             pkg->name, filename);
 811                if (owner) {
 812                     opkg_msg(ERROR, "%s\n", owner->name);
 813                } else {
 814                     opkg_msg(ERROR, "<no package>\n"
 815                         "Please move this file out of the way and try again.\n");
 816                }
 817                clashes++;
 818           }
 819           free(root_filename);
 820      }
 821      pkg_free_installed_files(pkg);
 822
 823      return clashes;
 824 }
 825
 826 /*
 827  * XXX: This function sucks, as does the below comment.
 828  */
 829 static int
 830 check_data_file_clashes_change(pkg_t *pkg, pkg_t *old_pkg)
 831 {
 832     /* Basically that's the worst hack I could do to be able to change ownership of
 833        file list, but, being that we have no way to unwind the mods, due to structure
 834        of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
 835        What we do here is change the ownership of file in hash if a replace ( or similar events
 836        happens )
 837        Only the action that are needed to change name should be considered.
 838        @@@ To change after 1.0 release.
 839      */
 840      str_list_t *files_list;
 841      str_list_elt_t *iter, *niter;
 842
 843      char *root_filename = NULL;
 844
 845      files_list = pkg_get_installed_files(pkg);
 846      if (files_list == NULL)
 847              return -1;
 848
 849      for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
 850              iter;
 851              iter = niter, niter = str_list_next(files_list, niter)) {
 852           char *filename = (char *) iter->data;
 853           if (root_filename) {
 854               free(root_filename);
 855               root_filename = NULL;
 856           }
 857           root_filename = root_filename_alloc(filename);
 858           if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
 859                pkg_t *owner;
 860
 861                owner = file_hash_get_file_owner(filename);
 862
 863                if (conf->force_overwrite) {
 864                     /* but we need to change who owns this file */
 865                     file_hash_set_file_owner(filename, pkg);
 866                     continue;
 867                }
 868
 869
 870                /* Pre-existing files are OK if owned by a package replaced by new pkg. */
 871                if (owner) {
 872                     if (pkg_replaces(pkg, owner)) {
 873 /* It's now time to change the owner of that file.
 874    It has been "replaced" from the new "Replaces", then I need to inform lists file about that.  */
 875                          opkg_msg(INFO, "Replacing pre-existing file %s "
 876                                          "owned by package %s\n",
 877                                          filename, owner->name);
 878                          file_hash_set_file_owner(filename, pkg);
 879                          continue;
 880                     }
 881                }
 882
 883           }
 884      }
 885      if (root_filename) {
 886          free(root_filename);
 887          root_filename = NULL;
 888      }
 889      pkg_free_installed_files(pkg);
 890
 891      return 0;
 892 }
 893
 894 static int
 895 check_data_file_clashes_unwind(pkg_t *pkg, pkg_t *old_pkg)
 896 {
 897      /* Nothing to do since check_data_file_clashes doesn't change state */
 898      return 0;
 899 }
 900
 901 static int
 902 postrm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
 903 {
 904      /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
 905         1. If the package is being upgraded, call
 906            old-postrm upgrade new-version
 907         2. If this fails, attempt:
 908            new-postrm failed-upgrade old-version
 909         Error unwind, for both cases:
 910            old-preinst abort-upgrade new-version    */
 911      return 0;
 912 }
 913
 914 static int
 915 postrm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
 916 {
 917      /* DPKG_INCOMPATIBILITY:
 918         dpkg does some things here that we don't do yet. Do we care?
 919         (See postrm_upgrade_old_pkg for details)
 920      */
 921     return 0;
 922 }
 923
 924 static int
 925 remove_obsolesced_files(pkg_t *pkg, pkg_t *old_pkg)
 926 {
 927      int err;
 928      str_list_t *old_files;
 929      str_list_elt_t *of;
 930      str_list_t *new_files;
 931      str_list_elt_t *nf;
 932      hash_table_t new_files_table;
 933
 934      old_files = pkg_get_installed_files(old_pkg);
 935      if (old_files == NULL)
 936           return -1;
 937
 938      new_files = pkg_get_installed_files(pkg);
 939      if (new_files == NULL) {
 940           pkg_free_installed_files(old_pkg);
 941           return -1;
 942      }
 943
 944      new_files_table.entries = NULL;
 945      hash_table_init("new_files" , &new_files_table, 20);
 946      for (nf = str_list_first(new_files); nf; nf = str_list_next(new_files, nf)) {
 947          if (nf && nf->data)
 948             hash_table_insert(&new_files_table, nf->data, nf->data);
 949      }
 950
 951      for (of = str_list_first(old_files); of; of = str_list_next(old_files, of)) {
 952           pkg_t *owner;
 953           char *old, *new;
 954           old = (char *)of->data;
 955           new = (char *) hash_table_get (&new_files_table, old);
 956           if (new)
 957                continue;
 958
 959           if (file_is_dir(old)) {
 960                continue;
 961           }
 962           owner = file_hash_get_file_owner(old);
 963           if (owner != old_pkg) {
 964                /* in case obsolete file no longer belongs to old_pkg */
 965                continue;
 966           }
 967
 968           /* old file is obsolete */
 969           opkg_msg(INFO, "Removing obsolete file %s.\n", old);
 970           if (!conf->noaction) {
 971                err = unlink(old);
 972                if (err) {
 973                     opkg_perror(ERROR, "unlinking %s failed", old);
 974                }
 975           }
 976      }
 977
 978      hash_table_deinit(&new_files_table);
 979      pkg_free_installed_files(old_pkg);
 980      pkg_free_installed_files(pkg);
 981
 982      return 0;
 983 }
 984
 985 static int
 986 install_maintainer_scripts(pkg_t *pkg, pkg_t *old_pkg)
 987 {
 988      int ret;
 989      char *prefix;
 990
 991      sprintf_alloc(&prefix, "%s.", pkg->name);
 992      ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
 993                                                         pkg->dest->info_dir,
 994                                                         prefix);
 995      free(prefix);
 996      return ret;
 997 }
 998
 999 static int
1000 remove_disappeared(pkg_t *pkg)
1001 {
1002      /* DPKG_INCOMPATIBILITY:
1003         This is a fairly sophisticated dpkg operation. Shall we
1004         skip it? */
1005
1006      /* Any packages all of whose files have been overwritten during the
1007         installation, and which aren't required for dependencies, are
1008         considered to have been removed. For each such package
1009         1. disappearer's-postrm disappear overwriter overwriter-version
1010         2. The package's maintainer scripts are removed
1011         3. It is noted in the status database as being in a sane state,
1012            namely not installed (any conffiles it may have are ignored,
1013            rather than being removed by dpkg). Note that disappearing
1014            packages do not have their prerm called, because dpkg doesn't
1015            know in advance that the package is going to vanish.
1016      */
1017      return 0;
1018 }
1019
1020 static int
1021 install_data_files(pkg_t *pkg)
1022 {
1023      int err;
1024
1025      /* opkg takes a slightly different approach to data file backups
1026         than dpkg. Rather than removing backups at this point, we
1027         actually do the data file installation now. See comments in
1028         check_data_file_clashes() for more details. */
1029
1030      opkg_msg(INFO, "Extracting data files to %s.\n", pkg->dest->root_dir);
1031      err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
1032      if (err) {
1033           return err;
1034      }
1035
1036      /* The "Essential" control field may only be present in the control
1037       * file and not in the Packages list. Ensure we capture it regardless.
1038       *
1039       * XXX: This should be fixed outside of opkg, in the Package list.
1040       */
1041      set_flags_from_control(pkg) ;
1042
1043      opkg_msg(DEBUG, "Calling pkg_write_filelist.\n");
1044      err = pkg_write_filelist(pkg);
1045      if (err)
1046           return err;
1047
1048      /* XXX: FEATURE: opkg should identify any files which existed
1049         before installation and which were overwritten, (see
1050         check_data_file_clashes()). What it must do is remove any such
1051         files from the filelist of the old package which provided the
1052         file. Otherwise, if the old package were removed at some point
1053         it would break the new package. Removing the new package will
1054         also break the old one, but this cannot be helped since the old
1055         package's file has already been deleted. This is the importance
1056         of check_data_file_clashes(), and only allowing opkg to install
1057         a clashing package with a user force. */
1058
1059      return 0;
1060 }
1061
1062 static int
1063 resolve_conffiles(pkg_t *pkg)
1064 {
1065      conffile_list_elt_t *iter;
1066      conffile_t *cf;
1067      char *cf_backup;
1068      char *md5sum;
1069
1070      if (conf->noaction) return 0;
1071
1072      for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
1073           char *root_filename;
1074           cf = (conffile_t *)iter->data;
1075           root_filename = root_filename_alloc(cf->name);
1076
1077           /* Might need to initialize the md5sum for each conffile */
1078           if (cf->value == NULL) {
1079                cf->value = file_md5sum_alloc(root_filename);
1080           }
1081
1082           if (!file_exists(root_filename)) {
1083                free(root_filename);
1084                continue;
1085           }
1086
1087           cf_backup = backup_filename_alloc(root_filename);
1088
1089           if (file_exists(cf_backup)) {
1090               /* Let's compute md5 to test if files are changed */
1091               md5sum = file_md5sum_alloc(cf_backup);
1092               if (md5sum && cf->value && strcmp(cf->value,md5sum) != 0 ) {
1093                   if (conf->force_maintainer) {
1094                       opkg_msg(NOTICE, "Conffile %s using maintainer's setting.\n",
1095                                       cf_backup);
1096                   } else {
1097                       char *new_conffile;
1098                       sprintf_alloc(&new_conffile, "%s-opkg", root_filename);
1099                       opkg_msg(NOTICE, "Existing conffile %s "
1100                            "is different from the conffile in the new package."
1101                            " The new conffile will be placed at %s.\n",
1102                            root_filename, new_conffile);
1103                       rename(root_filename, new_conffile);
1104                       rename(cf_backup, root_filename);
1105                       free(new_conffile);
1106                   }
1107               }
1108               unlink(cf_backup);
1109               if (md5sum)
1110                   free(md5sum);
1111           }
1112
1113           free(cf_backup);
1114           free(root_filename);
1115      }
1116
1117      return 0;
1118 }
1119
1120
1121 int
1122 opkg_install_by_name(const char *pkg_name)
1123 {
1124      int cmp;
1125      pkg_t *old, *new;
1126      char *old_version, *new_version;
1127
1128      old = pkg_hash_fetch_installed_by_name(pkg_name);
1129      if (old)
1130         opkg_msg(DEBUG2, "Old versions from pkg_hash_fetch %s.\n",
1131                         old->version);
1132
1133      new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name);
1134      if (new == NULL)
1135         return -1;
1136
1137      opkg_msg(DEBUG2, "Versions from pkg_hash_fetch:");
1138      if ( old )
1139         opkg_msg(DEBUG2, " old %s ", old->version);
1140      opkg_msg(DEBUG2, " new %s\n", new->version);
1141
1142      new->state_flag |= SF_USER;
1143      if (old) {
1144           old_version = pkg_version_str_alloc(old);
1145           new_version = pkg_version_str_alloc(new);
1146
1147           cmp = pkg_compare_versions(old, new);
1148           if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
1149              opkg_msg(DEBUG, "Forcing downgrade\n");
1150              cmp = -1 ;                                       /* then we force opkg to downgrade */
1151                                                               /* We need to use a value < 0 because in the 0 case we are asking to */
1152                                                               /* reinstall, and some check could fail asking the "force-reinstall" option */
1153           }
1154           opkg_msg(DEBUG, "Comparing visible versions of pkg %s:"
1155                        "\n\t%s is installed "
1156                        "\n\t%s is available "
1157                        "\n\t%d was comparison result\n",
1158                        pkg_name, old_version, new_version, cmp);
1159           if (cmp == 0 && !conf->force_reinstall) {
1160                opkg_msg(NOTICE,
1161                             "Package %s (%s) installed in %s is up to date.\n",
1162                             old->name, old_version, old->dest->name);
1163                free(old_version);
1164                free(new_version);
1165                return 0;
1166           } else if (cmp > 0) {
1167                opkg_msg(NOTICE,
1168                             "Not downgrading package %s on %s from %s to %s.\n",
1169                             old->name, old->dest->name, old_version, new_version);
1170                free(old_version);
1171                free(new_version);
1172                return 0;
1173           } else if (cmp < 0) {
1174                new->dest = old->dest;
1175                old->state_want = SW_DEINSTALL;    /* Here probably the problem for bug 1277 */
1176           }
1177           free(old_version);
1178           free(new_version);
1179      }
1180
1181      opkg_msg(DEBUG2,"Calling opkg_install_pkg.\n");
1182      return opkg_install_pkg(new, 0);
1183 }
1184
1185 /**
1186  *  @brief Really install a pkg_t
1187  */
1188 int
1189 opkg_install_pkg(pkg_t *pkg, int from_upgrade)
1190 {
1191      int err = 0;
1192      int message = 0;
1193      pkg_t *old_pkg = NULL;
1194      pkg_vec_t *replacees;
1195      abstract_pkg_t *ab_pkg = NULL;
1196      int old_state_flag;
1197      char* file_md5;
1198 #ifdef HAVE_SHA256
1199      char* file_sha256;
1200 #endif
1201      sigset_t newset, oldset;
1202
1203      if ( from_upgrade )
1204         message = 1;            /* Coming from an upgrade, and should change the output message */
1205
1206      opkg_msg(DEBUG2, "Calling pkg_arch_supported.\n");
1207
1208      if (!pkg_arch_supported(pkg)) {
1209           opkg_msg(ERROR, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1210                        pkg->architecture, pkg->name);
1211           return -1;
1212      }
1213      if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
1214           err = satisfy_dependencies_for(pkg);
1215           if (err)
1216                   return -1;
1217
1218           opkg_msg(NOTICE, "Package %s is already installed on %s.\n",
1219                        pkg->name, pkg->dest->name);
1220           return 0;
1221      }
1222
1223      if (pkg->dest == NULL) {
1224           pkg->dest = conf->default_dest;
1225      }
1226
1227      old_pkg = pkg_hash_fetch_installed_by_name(pkg->name);
1228
1229      err = opkg_install_check_downgrade(pkg, old_pkg, message);
1230      if (err)
1231              return -1;
1232
1233      pkg->state_want = SW_INSTALL;
1234      if (old_pkg){
1235          old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependences */
1236      }
1237
1238      err = check_conflicts_for(pkg);
1239      if (err)
1240              return -1;
1241
1242      /* this setup is to remove the upgrade scenario in the end when
1243         installing pkg A, A deps B & B deps on A. So both B and A are
1244         installed. Then A's installation is started resulting in an
1245         uncecessary upgrade */
1246      if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0)
1247              return 0;
1248
1249      err = verify_pkg_installable(pkg);
1250      if (err)
1251              return -1;
1252
1253      if (pkg->local_filename == NULL) {
1254           err = opkg_download_pkg(pkg, conf->tmp_dir);
1255           if (err) {
1256                opkg_msg(ERROR, "Failed to download %s. "
1257                                "Perhaps you need to run 'opkg update'?\n",
1258                             pkg->name);
1259                return -1;
1260           }
1261      }
1262
1263      /* check that the repository is valid */
1264      #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
1265      char *list_file_name, *sig_file_name, *lists_dir;
1266
1267      /* check to ensure the package has come from a repository */
1268      if (conf->check_signature && pkg->src)
1269      {
1270        sprintf_alloc (&lists_dir, "%s",
1271                      (conf->restrict_to_default_dest)
1272                       ? conf->default_dest->lists_dir
1273                       : conf->lists_dir);
1274        sprintf_alloc (&list_file_name, "%s/%s", lists_dir, pkg->src->name);
1275        sprintf_alloc (&sig_file_name, "%s/%s.sig", lists_dir, pkg->src->name);
1276
1277        if (file_exists (sig_file_name))
1278        {
1279          if (opkg_verify_file (list_file_name, sig_file_name)){
1280            opkg_msg(ERROR, "Failed to verify the signature of %s.\n",
1281                            list_file_name);
1282            return -1;
1283          }
1284        }else{
1285          opkg_msg(ERROR, "Signature file is missing for %s. "
1286                          "Perhaps you need to run 'opkg update'?\n",
1287                          pkg->name);
1288          return -1;
1289        }
1290
1291        free (lists_dir);
1292        free (list_file_name);
1293        free (sig_file_name);
1294      }
1295      #endif
1296
1297      /* Check for md5 values */
1298      if (pkg->md5sum)
1299      {
1300          file_md5 = file_md5sum_alloc(pkg->local_filename);
1301          if (file_md5 && strcmp(file_md5, pkg->md5sum))
1302          {
1303               opkg_msg(ERROR, "Package %s md5sum mismatch. "
1304                         "Either the opkg or the package index are corrupt. "
1305                         "Try 'opkg update'.\n",
1306                         pkg->name);
1307               free(file_md5);
1308               return -1;
1309          }
1310          if (file_md5)
1311               free(file_md5);
1312      }
1313
1314 #ifdef HAVE_SHA256
1315      /* Check for sha256 value */
1316      if(pkg->sha256sum)
1317      {
1318          file_sha256 = file_sha256sum_alloc(pkg->local_filename);
1319          if (file_sha256 && strcmp(file_sha256, pkg->sha256sum))
1320          {
1321               opkg_msg(ERROR, "Package %s sha256sum mismatch. "
1322                         "Either the opkg or the package index are corrupt. "
1323                         "Try 'opkg update'.\n",
1324                         pkg->name);
1325               free(file_sha256);
1326               return -1;
1327          }
1328          if (file_sha256)
1329               free(file_sha256);
1330      }
1331 #endif
1332
1333      if (pkg->tmp_unpack_dir == NULL) {
1334           if (unpack_pkg_control_files(pkg) == -1) {
1335                opkg_msg(ERROR, "Failed to unpack control files from %s.\n",
1336                                pkg->local_filename);
1337                return -1;
1338           }
1339      }
1340
1341      err = update_file_ownership(pkg, old_pkg);
1342      if (err)
1343              return -1;
1344
1345      if (conf->nodeps == 0) {
1346           err = satisfy_dependencies_for(pkg);
1347           if (err)
1348                 return -1;
1349           if (pkg->state_status == SS_UNPACKED)
1350                /* Circular dependency has installed it for us. */
1351                 return 0;
1352      }
1353
1354      replacees = pkg_vec_alloc();
1355      pkg_get_installed_replacees(pkg, replacees);
1356
1357      /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1358
1359           sigemptyset(&newset);
1360           sigaddset(&newset, SIGINT);
1361           sigprocmask(SIG_BLOCK, &newset, &oldset);
1362
1363           opkg_state_changed++;
1364           pkg->state_flag |= SF_FILELIST_CHANGED;
1365
1366           if (old_pkg)
1367                pkg_remove_orphan_dependent(pkg, old_pkg);
1368
1369           /* XXX: BUG: we really should treat replacement more like an upgrade
1370            *      Instead, we're going to remove the replacees
1371            */
1372           err = pkg_remove_installed_replacees(replacees);
1373           if (err)
1374                   goto UNWIND_REMOVE_INSTALLED_REPLACEES;
1375
1376           err = prerm_upgrade_old_pkg(pkg, old_pkg);
1377           if (err)
1378                   goto UNWIND_PRERM_UPGRADE_OLD_PKG;
1379
1380           err = prerm_deconfigure_conflictors(pkg, replacees);
1381           if (err)
1382                   goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
1383
1384           err = preinst_configure(pkg, old_pkg);
1385           if (err)
1386                   goto UNWIND_PREINST_CONFIGURE;
1387
1388           err = backup_modified_conffiles(pkg, old_pkg);
1389           if (err)
1390                   goto UNWIND_BACKUP_MODIFIED_CONFFILES;
1391
1392           err = check_data_file_clashes(pkg, old_pkg);
1393           if (err)
1394                   goto UNWIND_CHECK_DATA_FILE_CLASHES;
1395
1396           err = postrm_upgrade_old_pkg(pkg, old_pkg);
1397           if (err)
1398                   goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
1399
1400           if (conf->noaction)
1401                   return 0;
1402
1403           /* point of no return: no unwinding after this */
1404           if (old_pkg && !conf->force_reinstall) {
1405                old_pkg->state_want = SW_DEINSTALL;
1406
1407                if (old_pkg->state_flag & SF_NOPRUNE) {
1408                     opkg_msg(INFO, "Not removing obsolesced files because "
1409                                     "package %s marked noprune.\n",
1410                                     old_pkg->name);
1411                } else {
1412                     opkg_msg(INFO, "Removing obsolesced files for %s\n",
1413                                     old_pkg->name);
1414                     if (remove_obsolesced_files(pkg, old_pkg)) {
1415                         opkg_msg(ERROR, "Failed to determine "
1416                                         "obsolete files from previously "
1417                                         "installed %s\n", old_pkg->name);
1418                     }
1419                }
1420
1421                /* removing files from old package, to avoid ghost files */
1422                remove_data_files_and_list(old_pkg);
1423                remove_maintainer_scripts(old_pkg);
1424           }
1425
1426
1427           opkg_msg(INFO, "Installing maintainer scripts.\n");
1428           if (install_maintainer_scripts(pkg, old_pkg)) {
1429                 opkg_msg(ERROR, "Failed to extract maintainer scripts for %s."
1430                                " Package debris may remain!\n",
1431                                pkg->name);
1432                 goto pkg_is_hosed;
1433           }
1434
1435           /* the following just returns 0 */
1436           remove_disappeared(pkg);
1437
1438           opkg_msg(INFO, "Installing data files for %s.\n", pkg->name);
1439
1440           if (install_data_files(pkg)) {
1441                 opkg_msg(ERROR, "Failed to extract data files for %s. "
1442                                 "Package debris may remain!\n",
1443                                pkg->name);
1444                 goto pkg_is_hosed;
1445           }
1446
1447           err = check_data_file_clashes_change(pkg, old_pkg);
1448           if (err) {
1449                 opkg_msg(ERROR, "check_data_file_clashes_change() failed for "
1450                                "for files belonging to %s.\n",
1451                                pkg->name);
1452           }
1453
1454           opkg_msg(INFO, "Resolving conf files for %s\n", pkg->name);
1455           resolve_conffiles(pkg);
1456
1457           pkg->state_status = SS_UNPACKED;
1458           old_state_flag = pkg->state_flag;
1459           pkg->state_flag &= ~SF_PREFER;
1460           opkg_msg(DEBUG, "pkg=%s old_state_flag=%x state_flag=%x\n",
1461                           pkg->name, old_state_flag, pkg->state_flag);
1462
1463           if (old_pkg && !conf->force_reinstall) {
1464                old_pkg->state_status = SS_NOT_INSTALLED;
1465           }
1466
1467           time(&pkg->installed_time);
1468
1469           ab_pkg = pkg->parent;
1470           if (ab_pkg)
1471                ab_pkg->state_status = pkg->state_status;
1472
1473           sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1474           pkg_vec_free (replacees);
1475           return 0;
1476
1477
1478      UNWIND_POSTRM_UPGRADE_OLD_PKG:
1479           postrm_upgrade_old_pkg_unwind(pkg, old_pkg);
1480      UNWIND_CHECK_DATA_FILE_CLASHES:
1481           check_data_file_clashes_unwind(pkg, old_pkg);
1482      UNWIND_BACKUP_MODIFIED_CONFFILES:
1483           backup_modified_conffiles_unwind(pkg, old_pkg);
1484      UNWIND_PREINST_CONFIGURE:
1485           preinst_configure_unwind(pkg, old_pkg);
1486      UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1487           prerm_deconfigure_conflictors_unwind(pkg, replacees);
1488      UNWIND_PRERM_UPGRADE_OLD_PKG:
1489           prerm_upgrade_old_pkg_unwind(pkg, old_pkg);
1490      UNWIND_REMOVE_INSTALLED_REPLACEES:
1491           pkg_remove_installed_replacees_unwind(replacees);
1492
1493 pkg_is_hosed:
1494           sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1495
1496           pkg_vec_free (replacees);
1497           return -1;
1498 }