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           pkg_t *obs = hash_table_get(&conf->obs_file_hash, new_file);
 160
 161           opkg_msg(DEBUG2, "%s: new_pkg=%s wants file %s, from owner=%s\n",
 162                 __func__, new_pkg->name, new_file, owner?owner->name:"<NULL>");
 163
 164           if (!owner || (owner == old_pkg) || obs)
 165                file_hash_set_file_owner(new_file, new_pkg);
 166      }
 167
 168      if (old_pkg) {
 169           old_list = pkg_get_installed_files(old_pkg);
 170           if (old_list == NULL) {
 171                   pkg_free_installed_files(new_pkg);
 172                   return -1;
 173           }
 174
 175           for (iter = str_list_first(old_list), niter = str_list_next(old_list, iter);
 176                   iter;
 177                   iter = niter, niter = str_list_next(old_list, niter)) {
 178                char *old_file = (char *)iter->data;
 179                pkg_t *owner = file_hash_get_file_owner(old_file);
 180                if (!owner || (owner == old_pkg)) {
 181                     /* obsolete */
 182                     hash_table_insert(&conf->obs_file_hash, old_file, old_pkg);
 183                }
 184           }
 185           pkg_free_installed_files(old_pkg);
 186      }
 187      pkg_free_installed_files(new_pkg);
 188      return 0;
 189 }
 190
 191 static int
 192 verify_pkg_installable(pkg_t *pkg)
 193 {
 194         unsigned long kbs_available, pkg_size_kbs;
 195         char *root_dir;
 196
 197         if (conf->force_space || pkg->installed_size == 0)
 198                 return 0;
 199
 200         root_dir = pkg->dest ? pkg->dest->root_dir :
 201                                                 conf->default_dest->root_dir;
 202         kbs_available = get_available_kbytes(root_dir);
 203
 204         pkg_size_kbs = (pkg->installed_size + 1023)/1024;
 205
 206         if (pkg_size_kbs >= kbs_available) {
 207                 opkg_msg(ERROR, "Only have %dkb available on filesystem %s, "
 208                         "pkg %s needs %d\n",
 209                         kbs_available, root_dir, pkg->name, pkg_size_kbs);
 210                 return -1;
 211         }
 212
 213      return 0;
 214 }
 215
 216 static int
 217 unpack_pkg_control_files(pkg_t *pkg)
 218 {
 219      int err;
 220      char *conffiles_file_name;
 221      char *root_dir;
 222      FILE *conffiles_file;
 223
 224      sprintf_alloc(&pkg->tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir, pkg->name);
 225
 226      pkg->tmp_unpack_dir = mkdtemp(pkg->tmp_unpack_dir);
 227      if (pkg->tmp_unpack_dir == NULL) {
 228           opkg_perror(ERROR, "Failed to create temporary directory '%s'",
 229                        pkg->tmp_unpack_dir);
 230           return -1;
 231      }
 232
 233      err = pkg_extract_control_files_to_dir(pkg, pkg->tmp_unpack_dir);
 234      if (err) {
 235           return err;
 236      }
 237
 238      /* XXX: CLEANUP: There might be a cleaner place to read in the
 239         conffiles. Seems like I should be able to get everything to go
 240         through pkg_init_from_file. If so, maybe it would make sense to
 241         move all of unpack_pkg_control_files to that function. */
 242
 243      /* Don't need to re-read conffiles if we already have it */
 244      if (!nv_pair_list_empty(&pkg->conffiles)) {
 245           return 0;
 246      }
 247
 248      sprintf_alloc(&conffiles_file_name, "%s/conffiles", pkg->tmp_unpack_dir);
 249      if (! file_exists(conffiles_file_name)) {
 250           free(conffiles_file_name);
 251           return 0;
 252      }
 253
 254      conffiles_file = fopen(conffiles_file_name, "r");
 255      if (conffiles_file == NULL) {
 256           opkg_perror(ERROR, "Failed to open %s", conffiles_file_name);
 257           free(conffiles_file_name);
 258           return -1;
 259      }
 260      free(conffiles_file_name);
 261
 262      while (1) {
 263           char *cf_name;
 264           char *cf_name_in_dest;
 265
 266           cf_name = file_read_line_alloc(conffiles_file);
 267           if (cf_name == NULL) {
 268                break;
 269           }
 270           if (cf_name[0] == '\0') {
 271                continue;
 272           }
 273
 274           /* Prepend dest->root_dir to conffile name.
 275              Take pains to avoid multiple slashes. */
 276           root_dir = pkg->dest->root_dir;
 277           if (conf->offline_root)
 278                /* skip the offline_root prefix */
 279                root_dir = pkg->dest->root_dir + strlen(conf->offline_root);
 280           sprintf_alloc(&cf_name_in_dest, "%s%s", root_dir,
 281                         cf_name[0] == '/' ? (cf_name + 1) : cf_name);
 282
 283           /* Can't get an md5sum now, (file isn't extracted yet).
 284              We'll wait until resolve_conffiles */
 285           conffile_list_append(&pkg->conffiles, cf_name_in_dest, NULL);
 286
 287           free(cf_name);
 288           free(cf_name_in_dest);
 289      }
 290
 291      fclose(conffiles_file);
 292
 293      return 0;
 294 }
 295
 296 /*
 297  * Remove packages which were auto_installed due to a dependency by old_pkg,
 298  * which are no longer a dependency in the new (upgraded) pkg.
 299  */
 300 static int
 301 pkg_remove_orphan_dependent(pkg_t *pkg, pkg_t *old_pkg)
 302 {
 303         int i, j, k, l, found,r, err = 0;
 304         int n_deps;
 305         pkg_t *p;
 306         struct compound_depend *cd0, *cd1;
 307         abstract_pkg_t **dependents;
 308
 309         int count0 = old_pkg->pre_depends_count +
 310                                 old_pkg->depends_count +
 311                                 old_pkg->recommends_count +
 312                                 old_pkg->suggests_count;
 313         int count1 = pkg->pre_depends_count +
 314                                 pkg->depends_count +
 315                                 pkg->recommends_count +
 316                                 pkg->suggests_count;
 317
 318         for (i=0; i<count0; i++) {
 319                 cd0 = &old_pkg->depends[i];
 320                 if (cd0->type != DEPEND)
 321                         continue;
 322                 for (j=0; j<cd0->possibility_count; j++) {
 323
 324                         found = 0;
 325
 326                         for (k=0; k<count1; k++) {
 327                                 cd1 = &pkg->depends[i];
 328                                 if (cd1->type != DEPEND)
 329                                         continue;
 330                                 for (l=0; l<cd1->possibility_count; l++) {
 331                                         if (cd0->possibilities[j]
 332                                          == cd1->possibilities[l]) {
 333                                                 found = 1;
 334                                                 break;
 335                                         }
 336                                 }
 337                                 if (found)
 338                                         break;
 339                         }
 340
 341                         if (found)
 342                                 continue;
 343
 344                         /*
 345                          * old_pkg has a dependency that pkg does not.
 346                          */
 347                         p = pkg_hash_fetch_installed_by_name(
 348                                         cd0->possibilities[j]->pkg->name);
 349
 350                         if (!p)
 351                                 continue;
 352
 353                         if (!p->auto_installed)
 354                                 continue;
 355
 356                         n_deps = pkg_has_installed_dependents(p, &dependents);
 357                         n_deps--; /* don't count old_pkg */
 358
 359                         if (n_deps == 0) {
 360                                 opkg_msg(NOTICE, "%s was autoinstalled and is "
 361                                                 "now orphaned, removing.\n",
 362                                                 p->name);
 363
 364                                 /* p has one installed dependency (old_pkg),
 365                                  * which we need to ignore during removal. */
 366                                 p->state_flag |= SF_REPLACE;
 367
 368                                 r = opkg_remove_pkg(p, 0);
 369                                 if (!err)
 370                                         err = r;
 371                         } else
 372                                 opkg_msg(INFO, "%s was autoinstalled and is "
 373                                                 "still required by %d "
 374                                                 "installed packages.\n",
 375                                                 p->name, n_deps);
 376
 377                 }
 378         }
 379
 380         return err;
 381 }
 382
 383 /* returns number of installed replacees */
 384 static int
 385 pkg_get_installed_replacees(pkg_t *pkg, pkg_vec_t *installed_replacees)
 386 {
 387      abstract_pkg_t **replaces = pkg->replaces;
 388      int replaces_count = pkg->replaces_count;
 389      int i, j;
 390      for (i = 0; i < replaces_count; i++) {
 391           abstract_pkg_t *ab_pkg = replaces[i];
 392           pkg_vec_t *pkg_vec = ab_pkg->pkgs;
 393           if (pkg_vec) {
 394                for (j = 0; j < pkg_vec->len; j++) {
 395                     pkg_t *replacee = pkg_vec->pkgs[j];
 396                     if (!pkg_conflicts(pkg, replacee))
 397                          continue;
 398                     if (replacee->state_status == SS_INSTALLED) {
 399                          pkg_vec_insert(installed_replacees, replacee);
 400                     }
 401                }
 402           }
 403      }
 404      return installed_replacees->len;
 405 }
 406
 407 static int
 408 pkg_remove_installed_replacees(pkg_vec_t *replacees)
 409 {
 410      int i;
 411      int replaces_count = replacees->len;
 412      for (i = 0; i < replaces_count; i++) {
 413           pkg_t *replacee = replacees->pkgs[i];
 414           int err;
 415           replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
 416           err = opkg_remove_pkg(replacee, 0);
 417           if (err)
 418                return err;
 419      }
 420      return 0;
 421 }
 422
 423 /* to unwind the removal: make sure they are installed */
 424 static int
 425 pkg_remove_installed_replacees_unwind(pkg_vec_t *replacees)
 426 {
 427      int i, err;
 428      int replaces_count = replacees->len;
 429      for (i = 0; i < replaces_count; i++) {
 430           pkg_t *replacee = replacees->pkgs[i];
 431           if (replacee->state_status != SS_INSTALLED) {
 432                opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
 433                err = opkg_install_pkg(replacee, 0);
 434                if (err)
 435                     return err;
 436           }
 437      }
 438      return 0;
 439 }
 440
 441 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
 442 static int
 443 opkg_install_check_downgrade(pkg_t *pkg, pkg_t *old_pkg, int message)
 444 {
 445      if (old_pkg) {
 446           char message_out[15];
 447           char *old_version = pkg_version_str_alloc(old_pkg);
 448           char *new_version = pkg_version_str_alloc(pkg);
 449           int cmp = pkg_compare_versions(old_pkg, pkg);
 450           int rc = 0;
 451
 452           memset(message_out,'\x0',15);
 453           strncpy (message_out,"Upgrading ",strlen("Upgrading "));
 454           if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
 455              cmp = -1 ;                                       /* then we force opkg to downgrade */
 456              strncpy (message_out,"Downgrading ",strlen("Downgrading "));         /* We need to use a value < 0 because in the 0 case we are asking to */
 457                                                               /* reinstall, and some check could fail asking the "force-reinstall" option */
 458           }
 459
 460           if (cmp > 0) {
 461               if(!conf->download_only)
 462                   opkg_msg(NOTICE,
 463                           "Not downgrading package %s on %s from %s to %s.\n",
 464                           old_pkg->name, old_pkg->dest->name, old_version, new_version);
 465                rc = 1;
 466           } else if (cmp < 0) {
 467               if(!conf->download_only)
 468                   opkg_msg(NOTICE, "%s%s on %s from %s to %s...\n",
 469                           message_out, pkg->name, old_pkg->dest->name, old_version, new_version);
 470                pkg->dest = old_pkg->dest;
 471                rc = 0;
 472           } else /* cmp == 0 */ {
 473                if (conf->force_reinstall) {
 474                if(!conf->download_only)
 475                    opkg_msg(NOTICE, "Reinstalling %s (%s) on %s...\n",
 476                            pkg->name, new_version, old_pkg->dest->name);
 477                     pkg->dest = old_pkg->dest;
 478                     rc = 0;
 479                } else {
 480                    if(!conf->download_only)
 481                        opkg_msg(NOTICE, "%s (%s) already install on %s."
 482                                " Not reinstalling.\n",
 483                                pkg->name, new_version, old_pkg->dest->name);
 484                     rc = 1;
 485                }
 486           }
 487           free(old_version);
 488           free(new_version);
 489           return rc;
 490      } else {
 491           char message_out[15] ;
 492           memset(message_out,'\x0',15);
 493           if ( message )
 494                strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
 495           else
 496                strncpy( message_out,"Installing ",strlen("Installing ") );
 497           char *version = pkg_version_str_alloc(pkg);
 498
 499           if(!conf->download_only)
 500                opkg_msg(NOTICE, "%s%s (%s) to %s...\n", message_out,
 501                   pkg->name, version, pkg->dest->name);
 502           free(version);
 503      }
 504      return 0;
 505 }
 506
 507
 508 static int
 509 prerm_upgrade_old_pkg(pkg_t *pkg, pkg_t *old_pkg)
 510 {
 511      /* DPKG_INCOMPATIBILITY:
 512         dpkg does some things here that we don't do yet. Do we care?
 513
 514         1. If a version of the package is already installed, call
 515            old-prerm upgrade new-version
 516         2. If the script runs but exits with a non-zero exit status
 517            new-prerm failed-upgrade old-version
 518            Error unwind, for both the above cases:
 519            old-postinst abort-upgrade new-version
 520      */
 521      return 0;
 522 }
 523
 524 static int
 525 prerm_upgrade_old_pkg_unwind(pkg_t *pkg, pkg_t *old_pkg)
 526 {
 527      /* DPKG_INCOMPATIBILITY:
 528         dpkg does some things here that we don't do yet. Do we care?
 529         (See prerm_upgrade_old_package for details)
 530      */
 531      return 0;
 532 }
 533
 534 static int
 535 prerm_deconfigure_conflictors(pkg_t *pkg, pkg_vec_t *conflictors)
 536 {
 537      /* DPKG_INCOMPATIBILITY:
 538         dpkg does some things here that we don't do yet. Do we care?
 539         2. If a 'conflicting' package is being removed at the same time:
 540                 1. If any packages depended on that conflicting package and
 541                    --auto-deconfigure is specified, call, for each such package:
 542                    deconfigured's-prerm deconfigure \
 543                    in-favour package-being-installed version \
 544                    removing conflicting-package version
 545                 Error unwind:
 546                    deconfigured's-postinst abort-deconfigure \
 547                    in-favour package-being-installed-but-failed version \
 548                    removing conflicting-package version
 549
 550                    The deconfigured packages are marked as requiring
 551                    configuration, so that if --install is used they will be
 552                    configured again if possible.
 553                 2. To prepare for removal of the conflicting package, call:
 554                    conflictor's-prerm remove in-favour package new-version
 555                 Error unwind:
 556                    conflictor's-postinst abort-remove in-favour package new-version
 557      */
 558      return 0;
 559 }
 560
 561 static int
 562 prerm_deconfigure_conflictors_unwind(pkg_t *pkg, pkg_vec_t *conflictors)
 563 {
 564      /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
 565         do yet. Do we care?  (See prerm_deconfigure_conflictors for
 566         details) */
 567      return 0;
 568 }
 569
 570 static int
 571 preinst_configure(pkg_t *pkg, pkg_t *old_pkg)
 572 {
 573      int err;
 574      char *preinst_args;
 575
 576      if (old_pkg) {
 577           char *old_version = pkg_version_str_alloc(old_pkg);
 578           sprintf_alloc(&preinst_args, "upgrade %s", old_version);
 579           free(old_version);
 580      } else if (pkg->state_status == SS_CONFIG_FILES) {
 581           char *pkg_version = pkg_version_str_alloc(pkg);
 582           sprintf_alloc(&preinst_args, "install %s", pkg_version);
 583           free(pkg_version);
 584      } else {
 585           preinst_args = xstrdup("install");
 586      }
 587
 588      err = pkg_run_script(pkg, "preinst", preinst_args);
 589      if (err) {
 590           opkg_msg(ERROR, "Aborting installation of %s.\n", pkg->name);
 591           return -1;
 592      }
 593
 594      free(preinst_args);
 595
 596      return 0;
 597 }
 598
 599 static int
 600 preinst_configure_unwind(pkg_t *pkg, pkg_t *old_pkg)
 601 {
 602      /* DPKG_INCOMPATIBILITY:
 603         dpkg does the following error unwind, should we?
 604         pkg->postrm abort-upgrade old-version
 605         OR pkg->postrm abort-install old-version
 606         OR pkg->postrm abort-install
 607      */
 608      return 0;
 609 }
 610
 611 static char *
 612 backup_filename_alloc(const char *file_name)
 613 {
 614      char *backup;
 615
 616      sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
 617
 618      return backup;
 619 }
 620
 621
 622 static int
 623 backup_make_backup(const char *file_name)
 624 {
 625      int err;
 626      char *backup;
 627
 628      backup = backup_filename_alloc(file_name);
 629      err = file_copy(file_name, backup);
 630      if (err) {
 631           opkg_msg(ERROR, "Failed to copy %s to %s\n",
 632                        file_name, backup);
 633      }
 634
 635      free(backup);
 636
 637      return err;
 638 }
 639
 640 static int
 641 backup_exists_for(const char *file_name)
 642 {
 643      int ret;
 644      char *backup;
 645
 646      backup = backup_filename_alloc(file_name);
 647
 648      ret = file_exists(backup);
 649
 650      free(backup);
 651
 652      return ret;
 653 }
 654
 655 static int
 656 backup_remove(const char *file_name)
 657 {
 658      char *backup;
 659
 660      backup = backup_filename_alloc(file_name);
 661      unlink(backup);
 662      free(backup);
 663
 664      return 0;
 665 }
 666
 667 static int
 668 backup_modified_conffiles(pkg_t *pkg, pkg_t *old_pkg)
 669 {
 670      int err;
 671      conffile_list_elt_t *iter;
 672      conffile_t *cf;
 673
 674      if (conf->noaction) return 0;
 675
 676      /* Backup all modified conffiles */
 677      if (old_pkg) {
 678           for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
 679                char *cf_name;
 680
 681                cf = iter->data;
 682                cf_name = root_filename_alloc(cf->name);
 683
 684                /* Don't worry if the conffile is just plain gone */
 685                if (file_exists(cf_name) && conffile_has_been_modified(cf)) {
 686                     err = backup_make_backup(cf_name);
 687                     if (err) {
 688                          return err;
 689                     }
 690                }
 691                free(cf_name);
 692           }
 693      }
 694
 695      /* Backup all conffiles that were not conffiles in old_pkg */
 696      for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
 697           char *cf_name;
 698           cf = (conffile_t *)iter->data;
 699           cf_name = root_filename_alloc(cf->name);
 700           /* Ignore if this was a conffile in old_pkg as well */
 701           if (pkg_get_conffile(old_pkg, cf->name)) {
 702                continue;
 703           }
 704
 705           if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
 706                err = backup_make_backup(cf_name);
 707                if (err) {
 708                     return err;
 709                }
 710           }
 711           free(cf_name);
 712      }
 713
 714      return 0;
 715 }
 716
 717 static int
 718 backup_modified_conffiles_unwind(pkg_t *pkg, pkg_t *old_pkg)
 719 {
 720      conffile_list_elt_t *iter;
 721
 722      if (old_pkg) {
 723           for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
 724                backup_remove(((nv_pair_t *)iter->data)->name);
 725           }
 726      }
 727
 728      for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
 729           backup_remove(((nv_pair_t *)iter->data)->name);
 730      }
 731
 732      return 0;
 733 }
 734
 735
 736 static int
 737 check_data_file_clashes(pkg_t *pkg, pkg_t *old_pkg)
 738 {
 739      /* DPKG_INCOMPATIBILITY:
 740         opkg takes a slightly different approach than dpkg at this
 741         point.  dpkg installs each file in the new package while
 742         creating a backup for any file that is replaced, (so that it
 743         can unwind if necessary).  To avoid complexity and redundant
 744         storage, opkg doesn't do any installation until later, (at the
 745         point at which dpkg removes the backups.
 746
 747         But, we do have to check for data file clashes, since after
 748         installing a package with a file clash, removing either of the
 749         packages involved in the clash has the potential to break the
 750         other package.
 751      */
 752      str_list_t *files_list;
 753      str_list_elt_t *iter, *niter;
 754      char *filename;
 755      int clashes = 0;
 756
 757      files_list = pkg_get_installed_files(pkg);
 758      if (files_list == NULL)
 759              return -1;
 760
 761      for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
 762              iter;
 763              iter = niter, niter = str_list_next(files_list, iter)) {
 764           filename = (char *) iter->data;
 765           if (file_exists(filename) && (! file_is_dir(filename))) {
 766                pkg_t *owner;
 767                pkg_t *obs;
 768
 769                if (backup_exists_for(filename)) {
 770                     continue;
 771                }
 772
 773                /* Pre-existing files are OK if force-overwrite was asserted. */
 774                if (conf->force_overwrite) {
 775                     /* but we need to change who owns this file */
 776                     file_hash_set_file_owner(filename, pkg);
 777                     continue;
 778                }
 779
 780                owner = file_hash_get_file_owner(filename);
 781
 782                /* Pre-existing files are OK if owned by the pkg being upgraded. */
 783                if (owner && old_pkg) {
 784                     if (strcmp(owner->name, old_pkg->name) == 0) {
 785                          continue;
 786                     }
 787                }
 788
 789                /* Pre-existing files are OK if owned by a package replaced by new pkg. */
 790                if (owner) {
 791                     opkg_msg(DEBUG2, "Checking replaces for %s in package %s\n",
 792                                 filename, owner->name);
 793                     if (pkg_replaces(pkg, owner)) {
 794                          continue;
 795                     }
 796 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
 797    then it's ok to overwrite. */
 798                     if (strcmp(owner->name,pkg->name)==0){
 799                          opkg_msg(INFO, "Replacing pre-existing file %s"
 800                                         " owned by package %s\n",
 801                                         filename, owner->name);
 802                          continue;
 803                     }
 804                }
 805
 806                /* Pre-existing files are OK if they are obsolete */
 807                obs = hash_table_get(&conf->obs_file_hash, filename);
 808                if (obs) {
 809                     opkg_msg(INFO, "Pre-exiting file %s is obsolete."
 810                                    " obs_pkg=%s\n",
 811                                     filename, obs->name);
 812                     continue;
 813                }
 814
 815                /* We have found a clash. */
 816                opkg_msg(ERROR, "Package %s wants to install file %s\n"
 817                             "\tBut that file is already provided by package ",
 818                             pkg->name, filename);
 819                if (owner) {
 820                     opkg_message(ERROR, "%s\n", owner->name);
 821                } else {
 822                     opkg_message(ERROR, "<no package>\n"
 823                         "Please move this file out of the way and try again.\n");
 824                }
 825                clashes++;
 826           }
 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(NOTICE, "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 }