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 <stdio.h>
  19 #include <time.h>
  20 #include <signal.h>
  21 #include <unistd.h>
  22 #include <sys/stat.h>
  23
  24 #include "pkg.h"
  25 #include "pkg_hash.h"
  26 #include "pkg_extract.h"
  27
  28 #include "opkg_install.h"
  29 #include "opkg_configure.h"
  30 #include "opkg_download.h"
  31 #include "opkg_remove.h"
  32
  33 #include "opkg_utils.h"
  34 #include "opkg_message.h"
  35 #include "opkg_cmd.h"
  36 #include "opkg_defines.h"
  37
  38 #include "sprintf_alloc.h"
  39 #include "file_util.h"
  40 #include "xsystem.h"
  41 #include "libbb/libbb.h"
  42
  43 static pkg_vec_t * check_dependencies_for(pkg_t *pkg, bool silent)
  44 {
  45         char **tmp, **unresolved = NULL, *prev = NULL;
  46         pkg_vec_t *depends = pkg_vec_alloc();
  47
  48         pkg_hash_fetch_unsatisfied_dependencies(pkg, depends, &unresolved);
  49
  50         if (unresolved) {
  51                 if (silent == false)
  52                         opkg_msg(ERROR,
  53                                  "Cannot satisfy the following dependencies for %s:\n",
  54                                  pkg->name);
  55                 tmp = unresolved;
  56                 while (*unresolved) {
  57                         if (!prev || strcmp(*unresolved, prev))
  58                                 if (silent == false)
  59                                         opkg_message(ERROR, "\t%s\n", *unresolved);
  60                         prev = *unresolved;
  61                         unresolved++;
  62                 }
  63                 unresolved = tmp;
  64                 while (*unresolved) {
  65                         free(*unresolved);
  66                         unresolved++;
  67                 }
  68                 free(tmp);
  69                 pkg_vec_free(depends);
  70                 return NULL;
  71         }
  72
  73         return depends;
  74 }
  75
  76 static int satisfy_dependencies_for(pkg_t * pkg)
  77 {
  78         pkg_vec_t *depends;
  79         int i, err;
  80         pkg_t *dep;
  81
  82         depends = check_dependencies_for(pkg, false);
  83
  84         if (depends == NULL) {
  85                 if (!conf->force_depends) {
  86                         opkg_msg(INFO,
  87                                  "This could mean that your package list is out of date or that the packages\n"
  88                                  "mentioned above do not yet exist (try 'opkg update'). To proceed in spite\n"
  89                                  "of this problem try again with the '-force-depends' option.\n");
  90                 }
  91
  92                 return -1;
  93         }
  94
  95         /* Mark packages as to-be-installed */
  96         for (i = 0; i < depends->len; i++) {
  97                 /* Dependencies should be installed the same place as pkg */
  98                 if (depends->pkgs[i]->dest == NULL) {
  99                         depends->pkgs[i]->dest = pkg->dest;
 100                 }
 101                 depends->pkgs[i]->state_want = SW_INSTALL;
 102         }
 103
 104         for (i = 0; i < depends->len; i++) {
 105                 dep = depends->pkgs[i];
 106                 /* The package was uninstalled when we started, but another
 107                    dep earlier in this loop may have depended on it and pulled
 108                    it in, so check first. */
 109                 if ((dep->state_status != SS_INSTALLED)
 110                     && (dep->state_status != SS_UNPACKED)) {
 111                         opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
 112                         err = opkg_install_pkg(dep, 0);
 113                         /* mark this package as having been automatically installed to
 114                          * satisfy a dependancy */
 115                         dep->auto_installed = 1;
 116                         if (err) {
 117                                 pkg_vec_free(depends);
 118                                 return err;
 119                         }
 120                 }
 121         }
 122
 123         pkg_vec_free(depends);
 124
 125         return 0;
 126 }
 127
 128 static int check_conflicts_for(pkg_t * pkg)
 129 {
 130         int i;
 131         pkg_vec_t *conflicts = NULL;
 132         message_level_t level;
 133
 134         if (conf->force_depends) {
 135                 level = NOTICE;
 136         } else {
 137                 level = ERROR;
 138         }
 139
 140         if (!conf->force_depends)
 141                 conflicts = pkg_hash_fetch_conflicts(pkg);
 142
 143         if (conflicts) {
 144                 opkg_msg(level, "The following packages conflict with %s:\n",
 145                          pkg->name);
 146                 i = 0;
 147                 while (i < conflicts->len)
 148                         opkg_msg(level, "\t%s", conflicts->pkgs[i++]->name);
 149                 opkg_message(level, "\n");
 150                 pkg_vec_free(conflicts);
 151                 return -1;
 152         }
 153         return 0;
 154 }
 155
 156 static int check_reverse_depends_for(pkg_t *pkg, pkg_t *old_pkg)
 157 {
 158         int err = 0;
 159         int i, n_dependents;
 160         abstract_pkg_t **dependents, *dependent;
 161         pkg_vec_t *depends;
 162         pkg_t *updated;
 163
 164         opkg_msg(DEBUG, "Checking reverse depends for %s\n", old_pkg->name);
 165
 166         n_dependents = pkg_has_installed_dependents(old_pkg, &dependents);
 167
 168         /* pretend that old package does not exist */
 169         old_pkg->state_flag |= SF_IGNORE;
 170
 171         if (n_dependents == 0)
 172                 goto out;
 173
 174         while ((dependent = *dependents++) != NULL) {
 175                 if (dependent->state_status != SS_INSTALLED)
 176                         continue;
 177
 178                 if (dependent->pkgs == NULL)
 179                         continue;
 180
 181                 for (i = 0; i < dependent->pkgs->len; i++) {
 182                         if (dependent->pkgs->pkgs[i]->state_status != SS_INSTALLED)
 183                                 continue;
 184
 185                         depends = check_dependencies_for(dependent->pkgs->pkgs[i], true);
 186                         if (depends == NULL) {
 187 #if 0
 188                                 updated = pkg_hash_fetch_best_installation_candidate_by_name(dependent->pkgs->pkgs[i]->name);
 189                                 depends = updated ? check_dependencies_for(updated, false) : NULL;
 190                                 if (depends == NULL) {
 191                                         opkg_msg(ERROR, "Package %s reverse dependency check failed\n",
 192                                                  pkg->name);
 193                                         err = -1;
 194                                         goto out;
 195                                 }
 196                                 else {
 197                                         err = opkg_install_pkg(updated, 1);
 198                                         if (err)
 199                                                 goto out;
 200                                 }
 201 #else
 202                                 opkg_msg(ERROR, "Package %s reverse dependency check failed\n", pkg->name);
 203                                 err = -1;
 204                                 goto out;
 205 #endif
 206                         }
 207
 208                         pkg_vec_free(depends);
 209                 }
 210         }
 211
 212 out:
 213         old_pkg->state_flag &= ~SF_IGNORE;
 214         return err;
 215 }
 216
 217 static int update_file_ownership(pkg_t * new_pkg, pkg_t * old_pkg)
 218 {
 219         str_list_t *new_list, *old_list;
 220         str_list_elt_t *iter, *niter;
 221
 222         new_list = pkg_get_installed_files(new_pkg);
 223         if (new_list == NULL)
 224                 return -1;
 225
 226         for (iter = str_list_first(new_list), niter =
 227              str_list_next(new_list, iter); iter;
 228              iter = niter, niter = str_list_next(new_list, niter)) {
 229                 char *new_file = (char *)iter->data;
 230                 pkg_t *owner = file_hash_get_file_owner(new_file);
 231                 pkg_t *obs = hash_table_get(&conf->obs_file_hash, new_file);
 232
 233                 opkg_msg(DEBUG2,
 234                          "%s: new_pkg=%s wants file %s, from owner=%s\n",
 235                          __func__, new_pkg->name, new_file,
 236                          owner ? owner->name : "<NULL>");
 237
 238                 if (!owner || (owner == old_pkg) || obs)
 239                         file_hash_set_file_owner(new_file, new_pkg);
 240         }
 241
 242         if (old_pkg) {
 243                 old_list = pkg_get_installed_files(old_pkg);
 244                 if (old_list == NULL) {
 245                         pkg_free_installed_files(new_pkg);
 246                         return -1;
 247                 }
 248
 249                 for (iter = str_list_first(old_list), niter =
 250                      str_list_next(old_list, iter); iter;
 251                      iter = niter, niter = str_list_next(old_list, niter)) {
 252                         char *old_file = (char *)iter->data;
 253                         pkg_t *owner = file_hash_get_file_owner(old_file);
 254                         if (!owner || (owner == old_pkg)) {
 255                                 /* obsolete */
 256                                 hash_table_insert(&conf->obs_file_hash,
 257                                                   old_file, old_pkg);
 258                         }
 259                 }
 260                 pkg_free_installed_files(old_pkg);
 261         }
 262         pkg_free_installed_files(new_pkg);
 263         return 0;
 264 }
 265
 266 static int verify_pkg_installable(pkg_t * pkg)
 267 {
 268         unsigned long kbs_available, pkg_size_kbs;
 269         unsigned long installed_size;
 270         char *root_dir = NULL;
 271         struct stat s;
 272
 273         installed_size = (unsigned long) pkg_get_int(pkg, PKG_INSTALLED_SIZE);
 274
 275         if (conf->force_space || installed_size == 0)
 276                 return 0;
 277
 278         if (pkg->dest) {
 279                 if (!strcmp(pkg->dest->name, "root") && conf->overlay_root
 280                     && !stat(conf->overlay_root, &s) && (s.st_mode & S_IFDIR))
 281                         root_dir = conf->overlay_root;
 282                 else
 283                         root_dir = pkg->dest->root_dir;
 284         }
 285
 286         if (!root_dir)
 287                 root_dir = conf->default_dest->root_dir;
 288
 289         kbs_available = get_available_kbytes(root_dir);
 290
 291         pkg_size_kbs = (installed_size + 1023) / 1024;
 292
 293         if (pkg_size_kbs >= kbs_available) {
 294                 opkg_msg(ERROR, "Only have %ldkb available on filesystem %s, "
 295                          "pkg %s needs %ld\n",
 296                          kbs_available, root_dir, pkg->name, pkg_size_kbs);
 297                 return -1;
 298         }
 299
 300         return 0;
 301 }
 302
 303 static int unpack_pkg_control_files(pkg_t * pkg)
 304 {
 305         int err;
 306         char *conffiles_file_name;
 307         char *root_dir;
 308         char *tmp_unpack_dir;
 309         FILE *conffiles_file;
 310         conffile_list_t *cl;
 311
 312         sprintf_alloc(&tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir,
 313                       pkg->name);
 314
 315         tmp_unpack_dir = mkdtemp(tmp_unpack_dir);
 316         if (tmp_unpack_dir == NULL) {
 317                 opkg_perror(ERROR, "Failed to create temporary directory '%s'",
 318                             tmp_unpack_dir);
 319                 return -1;
 320         }
 321
 322         pkg_set_string(pkg, PKG_TMP_UNPACK_DIR, tmp_unpack_dir);
 323
 324         err = pkg_extract_control_files_to_dir(pkg, tmp_unpack_dir);
 325         if (err) {
 326                 return err;
 327         }
 328
 329         /* XXX: CLEANUP: There might be a cleaner place to read in the
 330            conffiles. Seems like I should be able to get everything to go
 331            through pkg_init_from_file. If so, maybe it would make sense to
 332            move all of unpack_pkg_control_files to that function. */
 333
 334         /* Don't need to re-read conffiles if we already have it */
 335         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
 336         if (cl && !nv_pair_list_empty(cl)) {
 337                 return 0;
 338         }
 339
 340         sprintf_alloc(&conffiles_file_name, "%s/conffiles",
 341                       tmp_unpack_dir);
 342         if (!file_exists(conffiles_file_name)) {
 343                 free(conffiles_file_name);
 344                 return 0;
 345         }
 346
 347         conffiles_file = fopen(conffiles_file_name, "r");
 348         if (conffiles_file == NULL) {
 349                 opkg_perror(ERROR, "Failed to open %s", conffiles_file_name);
 350                 free(conffiles_file_name);
 351                 return -1;
 352         }
 353         free(conffiles_file_name);
 354
 355         cl = xcalloc(1, sizeof(*cl));
 356         conffile_list_init(cl);
 357
 358         while (1) {
 359                 char *cf_name;
 360                 char *cf_name_in_dest;
 361                 int i;
 362
 363                 cf_name = file_read_line_alloc(conffiles_file);
 364                 if (cf_name == NULL) {
 365                         break;
 366                 }
 367                 if (cf_name[0] == '\0') {
 368                         continue;
 369                 }
 370                 for (i = strlen(cf_name) - 1;
 371                      (i >= 0) && (cf_name[i] == ' ' || cf_name[i] == '\t');
 372                      i--) {
 373                         cf_name[i] = '\0';
 374                 }
 375
 376                 /* Prepend dest->root_dir to conffile name.
 377                    Take pains to avoid multiple slashes. */
 378                 root_dir = pkg->dest->root_dir;
 379                 if (conf->offline_root)
 380                         /* skip the offline_root prefix */
 381                         root_dir =
 382                             pkg->dest->root_dir + strlen(conf->offline_root);
 383                 sprintf_alloc(&cf_name_in_dest, "%s%s", root_dir,
 384                               cf_name[0] == '/' ? (cf_name + 1) : cf_name);
 385
 386                 /* Can't get an md5sum now, (file isn't extracted yet).
 387                    We'll wait until resolve_conffiles */
 388                 conffile_list_append(cl, cf_name_in_dest, NULL);
 389
 390                 free(cf_name);
 391                 free(cf_name_in_dest);
 392         }
 393
 394         pkg_set_ptr(pkg, PKG_CONFFILES, cl);
 395
 396         fclose(conffiles_file);
 397
 398         return 0;
 399 }
 400
 401 /*
 402  * Remove packages which were auto_installed due to a dependency by old_pkg,
 403  * which are no longer a dependency in the new (upgraded) pkg.
 404  */
 405 static int pkg_remove_orphan_dependent(pkg_t * pkg, pkg_t * old_pkg)
 406 {
 407         int j, l, found, r, err = 0;
 408         int n_deps;
 409         pkg_t *p;
 410         struct compound_depend *cd0, *cd1;
 411         abstract_pkg_t **dependents;
 412
 413         for (cd0 = pkg_get_ptr(old_pkg, PKG_DEPENDS); cd0 && cd0->type; cd0++) {
 414                 if (cd0->type != DEPEND)
 415                         continue;
 416                 for (j = 0; j < cd0->possibility_count; j++) {
 417
 418                         found = 0;
 419
 420                         for (cd1 = pkg_get_ptr(pkg, PKG_DEPENDS); cd1 && cd1->type; cd1++) {
 421                                 if (cd1->type != DEPEND)
 422                                         continue;
 423                                 for (l = 0; l < cd1->possibility_count; l++) {
 424                                         if (cd0->possibilities[j]
 425                                             == cd1->possibilities[l]) {
 426                                                 found = 1;
 427                                                 break;
 428                                         }
 429                                 }
 430                                 if (found)
 431                                         break;
 432                         }
 433
 434                         if (found)
 435                                 continue;
 436
 437                         /*
 438                          * old_pkg has a dependency that pkg does not.
 439                          */
 440                         p = pkg_hash_fetch_installed_by_name(cd0->
 441                                                              possibilities[j]->
 442                                                              pkg->name);
 443
 444                         if (!p)
 445                                 continue;
 446
 447                         if (!p->auto_installed)
 448                                 continue;
 449
 450                         n_deps = pkg_has_installed_dependents(p, &dependents);
 451                         n_deps--;       /* don't count old_pkg */
 452
 453                         if (n_deps == 0) {
 454                                 opkg_msg(NOTICE, "%s was autoinstalled and is "
 455                                          "now orphaned, removing.\n", p->name);
 456
 457                                 /* p has one installed dependency (old_pkg),
 458                                  * which we need to ignore during removal. */
 459                                 p->state_flag |= SF_REPLACE;
 460
 461                                 r = opkg_remove_pkg(p, 0);
 462                                 if (!err)
 463                                         err = r;
 464                         } else
 465                                 opkg_msg(INFO, "%s was autoinstalled and is "
 466                                          "still required by %d "
 467                                          "installed packages.\n",
 468                                          p->name, n_deps);
 469
 470                 }
 471         }
 472
 473         return err;
 474 }
 475
 476 /* returns number of installed replacees */
 477 static int
 478 pkg_get_installed_replacees(pkg_t * pkg, pkg_vec_t * installed_replacees)
 479 {
 480         abstract_pkg_t **replaces = pkg_get_ptr(pkg, PKG_REPLACES);
 481         int j;
 482
 483         while (replaces && *replaces) {
 484                 abstract_pkg_t *ab_pkg = *replaces++;
 485                 pkg_vec_t *pkg_vec = ab_pkg->pkgs;
 486                 if (pkg_vec) {
 487                         for (j = 0; j < pkg_vec->len; j++) {
 488                                 pkg_t *replacee = pkg_vec->pkgs[j];
 489                                 if (!pkg_conflicts(pkg, replacee))
 490                                         continue;
 491                                 if (replacee->state_status == SS_INSTALLED) {
 492                                         pkg_vec_insert(installed_replacees,
 493                                                        replacee);
 494                                 }
 495                         }
 496                 }
 497         }
 498
 499         return installed_replacees->len;
 500 }
 501
 502 static int pkg_remove_installed_replacees(pkg_vec_t * replacees)
 503 {
 504         int i;
 505         int replaces_count = replacees->len;
 506         for (i = 0; i < replaces_count; i++) {
 507                 pkg_t *replacee = replacees->pkgs[i];
 508                 int err;
 509                 replacee->state_flag |= SF_REPLACE;     /* flag it so remove won't complain */
 510                 err = opkg_remove_pkg(replacee, 0);
 511                 if (err)
 512                         return err;
 513         }
 514         return 0;
 515 }
 516
 517 /* to unwind the removal: make sure they are installed */
 518 static int pkg_remove_installed_replacees_unwind(pkg_vec_t * replacees)
 519 {
 520         int i, err;
 521         int replaces_count = replacees->len;
 522         for (i = 0; i < replaces_count; i++) {
 523                 pkg_t *replacee = replacees->pkgs[i];
 524                 if (replacee->state_status != SS_INSTALLED) {
 525                         opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
 526                         err = opkg_install_pkg(replacee, 0);
 527                         if (err)
 528                                 return err;
 529                 }
 530         }
 531         return 0;
 532 }
 533
 534 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
 535 static int
 536 opkg_install_check_downgrade(pkg_t * pkg, pkg_t * old_pkg, int message)
 537 {
 538         if (old_pkg) {
 539                 char message_out[15];
 540                 char *old_version = pkg_version_str_alloc(old_pkg);
 541                 char *new_version = pkg_version_str_alloc(pkg);
 542                 int cmp = pkg_compare_versions(old_pkg, pkg);
 543                 int rc = 0;
 544
 545                 memset(message_out, '\x0', 15);
 546                 strncpy(message_out, "Upgrading ", strlen("Upgrading "));
 547                 if ((conf->force_downgrade == 1) && (cmp > 0)) {        /* We've been asked to allow downgrade  and version is precedent */
 548                         cmp = -1;       /* then we force opkg to downgrade */
 549                         strncpy(message_out, "Downgrading ", strlen("Downgrading "));   /* We need to use a value < 0 because in the 0 case we are asking to */
 550                         /* reinstall, and some check could fail asking the "force-reinstall" option */
 551                 }
 552
 553                 if (cmp > 0) {
 554                         if (!conf->download_only)
 555                                 opkg_msg(NOTICE,
 556                                          "Not downgrading package %s on %s from %s to %s.\n",
 557                                          old_pkg->name, old_pkg->dest->name,
 558                                          old_version, new_version);
 559                         rc = 1;
 560                 } else if (cmp < 0) {
 561                         if (!conf->download_only)
 562                                 opkg_msg(NOTICE,
 563                                          "%s%s on %s from %s to %s...\n",
 564                                          message_out, pkg->name,
 565                                          old_pkg->dest->name, old_version,
 566                                          new_version);
 567                         pkg->dest = old_pkg->dest;
 568                         rc = 0;
 569                 } else {        /* cmp == 0 */
 570
 571                         if (!conf->download_only)
 572                                 opkg_msg(NOTICE,
 573                                          "%s (%s) already install on %s.\n",
 574                                          pkg->name, new_version,
 575                                          old_pkg->dest->name);
 576                         rc = 1;
 577                 }
 578                 free(old_version);
 579                 free(new_version);
 580                 return rc;
 581         } else {
 582                 char message_out[15];
 583                 memset(message_out, '\x0', 15);
 584                 if (message)
 585                         strncpy(message_out, "Upgrading ",
 586                                 strlen("Upgrading "));
 587                 else
 588                         strncpy(message_out, "Installing ",
 589                                 strlen("Installing "));
 590                 char *version = pkg_version_str_alloc(pkg);
 591
 592                 if (!conf->download_only)
 593                         opkg_msg(NOTICE, "%s%s (%s) to %s...\n", message_out,
 594                                  pkg->name, version, pkg->dest->name);
 595                 free(version);
 596         }
 597         return 0;
 598 }
 599
 600 static int prerm_upgrade_old_pkg(pkg_t * pkg, pkg_t * old_pkg)
 601 {
 602         /* DPKG_INCOMPATIBILITY:
 603            dpkg does some things here that we don't do yet. Do we care?
 604
 605            1. If a version of the package is already installed, call
 606            old-prerm upgrade new-version
 607            2. If the script runs but exits with a non-zero exit status
 608            new-prerm failed-upgrade old-version
 609            Error unwind, for both the above cases:
 610            old-postinst abort-upgrade new-version
 611          */
 612         int err;
 613         char *script_args;
 614         char *new_version;
 615
 616         if (!old_pkg || !pkg)
 617                 return 0;
 618
 619         new_version = pkg_version_str_alloc(pkg);
 620
 621         sprintf_alloc(&script_args, "upgrade %s", new_version);
 622         free(new_version);
 623         err = pkg_run_script(old_pkg, "prerm", script_args);
 624         free(script_args);
 625         if (err != 0) {
 626                 opkg_msg(ERROR, "prerm script for package \"%s\" failed\n",
 627                          old_pkg->name);
 628                 return -1;
 629         }
 630         return 0;
 631 }
 632
 633 static int prerm_upgrade_old_pkg_unwind(pkg_t * pkg, pkg_t * old_pkg)
 634 {
 635         /* DPKG_INCOMPATIBILITY:
 636            dpkg does some things here that we don't do yet. Do we care?
 637            (See prerm_upgrade_old_package for details)
 638          */
 639         return 0;
 640 }
 641
 642 static int prerm_deconfigure_conflictors(pkg_t * pkg, pkg_vec_t * conflictors)
 643 {
 644         /* DPKG_INCOMPATIBILITY:
 645            dpkg does some things here that we don't do yet. Do we care?
 646            2. If a 'conflicting' package is being removed at the same time:
 647            1. If any packages depended on that conflicting package and
 648            --auto-deconfigure is specified, call, for each such package:
 649            deconfigured's-prerm deconfigure \
 650            in-favour package-being-installed version \
 651            removing conflicting-package version
 652            Error unwind:
 653            deconfigured's-postinst abort-deconfigure \
 654            in-favour package-being-installed-but-failed version \
 655            removing conflicting-package version
 656
 657            The deconfigured packages are marked as requiring
 658            configuration, so that if --install is used they will be
 659            configured again if possible.
 660            2. To prepare for removal of the conflicting package, call:
 661            conflictor's-prerm remove in-favour package new-version
 662            Error unwind:
 663            conflictor's-postinst abort-remove in-favour package new-version
 664          */
 665         return 0;
 666 }
 667
 668 static int
 669 prerm_deconfigure_conflictors_unwind(pkg_t * pkg, pkg_vec_t * conflictors)
 670 {
 671         /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
 672            do yet. Do we care?  (See prerm_deconfigure_conflictors for
 673            details) */
 674         return 0;
 675 }
 676
 677 static int preinst_configure(pkg_t * pkg, pkg_t * old_pkg)
 678 {
 679         int err;
 680         char *preinst_args;
 681
 682         if (old_pkg) {
 683                 char *old_version = pkg_version_str_alloc(old_pkg);
 684                 sprintf_alloc(&preinst_args, "upgrade %s", old_version);
 685                 free(old_version);
 686         } else if (pkg->state_status == SS_CONFIG_FILES) {
 687                 char *pkg_version = pkg_version_str_alloc(pkg);
 688                 sprintf_alloc(&preinst_args, "install %s", pkg_version);
 689                 free(pkg_version);
 690         } else {
 691                 preinst_args = xstrdup("install");
 692         }
 693
 694         err = pkg_run_script(pkg, "preinst", preinst_args);
 695         if (err) {
 696                 opkg_msg(ERROR, "Aborting installation of %s.\n", pkg->name);
 697                 return -1;
 698         }
 699
 700         free(preinst_args);
 701
 702         return 0;
 703 }
 704
 705 static int preinst_configure_unwind(pkg_t * pkg, pkg_t * old_pkg)
 706 {
 707         /* DPKG_INCOMPATIBILITY:
 708            dpkg does the following error unwind, should we?
 709            pkg->postrm abort-upgrade old-version
 710            OR pkg->postrm abort-install old-version
 711            OR pkg->postrm abort-install
 712          */
 713         return 0;
 714 }
 715
 716 static char *backup_filename_alloc(const char *file_name)
 717 {
 718         char *backup;
 719
 720         sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
 721
 722         return backup;
 723 }
 724
 725 static int backup_make_backup(const char *file_name)
 726 {
 727         int err;
 728         char *backup;
 729
 730         backup = backup_filename_alloc(file_name);
 731         err = file_copy(file_name, backup);
 732         if (err) {
 733                 opkg_msg(ERROR, "Failed to copy %s to %s\n", file_name, backup);
 734         }
 735
 736         free(backup);
 737
 738         return err;
 739 }
 740
 741 static int backup_exists_for(const char *file_name)
 742 {
 743         int ret;
 744         char *backup;
 745
 746         backup = backup_filename_alloc(file_name);
 747
 748         ret = file_exists(backup);
 749
 750         free(backup);
 751
 752         return ret;
 753 }
 754
 755 static int backup_remove(const char *file_name)
 756 {
 757         char *backup;
 758
 759         backup = backup_filename_alloc(file_name);
 760         unlink(backup);
 761         free(backup);
 762
 763         return 0;
 764 }
 765
 766 static int backup_modified_conffiles(pkg_t * pkg, pkg_t * old_pkg)
 767 {
 768         int err;
 769         conffile_list_elt_t *iter;
 770         conffile_t *cf;
 771         conffile_list_t *cl;
 772
 773         if (conf->noaction)
 774                 return 0;
 775
 776         /* Backup all modified conffiles */
 777         if (old_pkg) {
 778                 cl = pkg_get_ptr(old_pkg, PKG_CONFFILES);
 779
 780                 for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
 781                      iter = nv_pair_list_next(cl, iter)) {
 782                         char *cf_name;
 783
 784                         cf = iter->data;
 785                         cf_name = root_filename_alloc(cf->name);
 786
 787                         /* Don't worry if the conffile is just plain gone */
 788                         if (file_exists(cf_name)
 789                             && conffile_has_been_modified(cf)) {
 790                                 err = backup_make_backup(cf_name);
 791                                 if (err) {
 792                                         return err;
 793                                 }
 794                         }
 795                         free(cf_name);
 796                 }
 797         }
 798
 799         /* Backup all conffiles that were not conffiles in old_pkg */
 800         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
 801
 802         for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
 803              iter = nv_pair_list_next(cl, iter)) {
 804                 char *cf_name;
 805                 cf = (conffile_t *) iter->data;
 806                 cf_name = root_filename_alloc(cf->name);
 807                 /* Ignore if this was a conffile in old_pkg as well */
 808                 if (pkg_get_conffile(old_pkg, cf->name)) {
 809                         continue;
 810                 }
 811
 812                 if (file_exists(cf_name) && (!backup_exists_for(cf_name))) {
 813                         err = backup_make_backup(cf_name);
 814                         if (err) {
 815                                 return err;
 816                         }
 817                 }
 818                 free(cf_name);
 819         }
 820
 821         return 0;
 822 }
 823
 824 static int backup_modified_conffiles_unwind(pkg_t * pkg, pkg_t * old_pkg)
 825 {
 826         conffile_list_t *cl;
 827         conffile_list_elt_t *iter;
 828
 829         if (old_pkg) {
 830                 cl = pkg_get_ptr(old_pkg, PKG_CONFFILES);
 831
 832                 for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
 833                      iter = nv_pair_list_next(cl, iter)) {
 834                         backup_remove(((nv_pair_t *) iter->data)->name);
 835                 }
 836         }
 837
 838         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
 839
 840         for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
 841              iter = nv_pair_list_next(cl, iter)) {
 842                 backup_remove(((nv_pair_t *) iter->data)->name);
 843         }
 844
 845         return 0;
 846 }
 847
 848 static int check_data_file_clashes(pkg_t * pkg, pkg_t * old_pkg)
 849 {
 850         /* DPKG_INCOMPATIBILITY:
 851            opkg takes a slightly different approach than dpkg at this
 852            point.  dpkg installs each file in the new package while
 853            creating a backup for any file that is replaced, (so that it
 854            can unwind if necessary).  To avoid complexity and redundant
 855            storage, opkg doesn't do any installation until later, (at the
 856            point at which dpkg removes the backups.
 857
 858            But, we do have to check for data file clashes, since after
 859            installing a package with a file clash, removing either of the
 860            packages involved in the clash has the potential to break the
 861            other package.
 862          */
 863         str_list_t *files_list;
 864         str_list_elt_t *iter, *niter;
 865         char *filename;
 866         int clashes = 0;
 867
 868         files_list = pkg_get_installed_files(pkg);
 869         if (files_list == NULL)
 870                 return -1;
 871
 872         for (iter = str_list_first(files_list), niter =
 873              str_list_next(files_list, iter); iter;
 874              iter = niter, niter = str_list_next(files_list, iter)) {
 875                 filename = (char *)iter->data;
 876                 if (file_exists(filename) && (!file_is_dir(filename))) {
 877                         pkg_t *owner;
 878                         pkg_t *obs;
 879
 880                         if (backup_exists_for(filename)) {
 881                                 continue;
 882                         }
 883
 884                         /* Pre-existing files are OK if force-overwrite was asserted. */
 885                         if (conf->force_overwrite) {
 886                                 /* but we need to change who owns this file */
 887                                 file_hash_set_file_owner(filename, pkg);
 888                                 continue;
 889                         }
 890
 891                         owner = file_hash_get_file_owner(filename);
 892
 893                         /* Pre-existing files are OK if owned by the pkg being upgraded. */
 894                         if (owner && old_pkg) {
 895                                 if (strcmp(owner->name, old_pkg->name) == 0) {
 896                                         continue;
 897                                 }
 898                         }
 899
 900                         /* Pre-existing files are OK if owned by a package replaced by new pkg. */
 901                         if (owner) {
 902                                 opkg_msg(DEBUG2,
 903                                          "Checking replaces for %s in package %s\n",
 904                                          filename, owner->name);
 905                                 if (pkg_replaces(pkg, owner)) {
 906                                         continue;
 907                                 }
 908 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
 909    then it's ok to overwrite. */
 910                                 if (strcmp(owner->name, pkg->name) == 0) {
 911                                         opkg_msg(INFO,
 912                                                  "Replacing pre-existing file %s"
 913                                                  " owned by package %s\n",
 914                                                  filename, owner->name);
 915                                         continue;
 916                                 }
 917                         }
 918
 919                         /* Pre-existing files are OK if they are obsolete */
 920                         obs = hash_table_get(&conf->obs_file_hash, filename);
 921                         if (obs) {
 922                                 opkg_msg(INFO,
 923                                          "Pre-exiting file %s is obsolete."
 924                                          " obs_pkg=%s\n", filename, obs->name);
 925                                 continue;
 926                         }
 927
 928                         /* We have found a clash. */
 929                         opkg_msg(ERROR, "Package %s wants to install file %s\n"
 930                                  "\tBut that file is already provided by package ",
 931                                  pkg->name, filename);
 932                         if (owner) {
 933                                 opkg_message(ERROR, "%s\n", owner->name);
 934                         } else {
 935                                 opkg_message(ERROR, "<no package>\n"
 936                                              "Please move this file out of the way and try again.\n");
 937                         }
 938                         clashes++;
 939                 }
 940         }
 941         pkg_free_installed_files(pkg);
 942
 943         return clashes;
 944 }
 945
 946 /*
 947  * XXX: This function sucks, as does the below comment.
 948  */
 949 static int check_data_file_clashes_change(pkg_t * pkg, pkg_t * old_pkg)
 950 {
 951         /* Basically that's the worst hack I could do to be able to change ownership of
 952            file list, but, being that we have no way to unwind the mods, due to structure
 953            of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
 954            What we do here is change the ownership of file in hash if a replace ( or similar events
 955            happens )
 956            Only the action that are needed to change name should be considered.
 957            @@@ To change after 1.0 release.
 958          */
 959         str_list_t *files_list;
 960         str_list_elt_t *iter, *niter;
 961
 962         files_list = pkg_get_installed_files(pkg);
 963         if (files_list == NULL)
 964                 return -1;
 965
 966         for (iter = str_list_first(files_list), niter =
 967              str_list_next(files_list, iter); iter;
 968              iter = niter, niter = str_list_next(files_list, niter)) {
 969                 char *filename = (char *)iter->data;
 970                 if (file_exists(filename) && (!file_is_dir(filename))) {
 971                         pkg_t *owner;
 972
 973                         owner = file_hash_get_file_owner(filename);
 974
 975                         if (conf->force_overwrite) {
 976                                 /* but we need to change who owns this file */
 977                                 file_hash_set_file_owner(filename, pkg);
 978                                 continue;
 979                         }
 980
 981                         /* Pre-existing files are OK if owned by a package replaced by new pkg. */
 982                         if (owner) {
 983                                 if (pkg_replaces(pkg, owner)) {
 984 /* It's now time to change the owner of that file.
 985    It has been "replaced" from the new "Replaces", then I need to inform lists file about that.  */
 986                                         opkg_msg(INFO,
 987                                                  "Replacing pre-existing file %s "
 988                                                  "owned by package %s\n",
 989                                                  filename, owner->name);
 990                                         file_hash_set_file_owner(filename, pkg);
 991                                         continue;
 992                                 }
 993                         }
 994
 995                 }
 996         }
 997         pkg_free_installed_files(pkg);
 998
 999         return 0;
1000 }
1001
1002 static int check_data_file_clashes_unwind(pkg_t * pkg, pkg_t * old_pkg)
1003 {
1004         /* Nothing to do since check_data_file_clashes doesn't change state */
1005         return 0;
1006 }
1007
1008 static int postrm_upgrade_old_pkg(pkg_t * pkg, pkg_t * old_pkg)
1009 {
1010         /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
1011            1. If the package is being upgraded, call
1012            old-postrm upgrade new-version
1013            2. If this fails, attempt:
1014            new-postrm failed-upgrade old-version
1015            Error unwind, for both cases:
1016            old-preinst abort-upgrade new-version    */
1017         int err;
1018         char *script_args;
1019         char *new_version;
1020
1021         if (!old_pkg || !pkg)
1022                 return 0;
1023
1024         new_version = pkg_version_str_alloc(pkg);
1025
1026         sprintf_alloc(&script_args, "upgrade %s", new_version);
1027         free(new_version);
1028         err = pkg_run_script(old_pkg, "postrm", script_args);
1029         free(script_args);
1030         if (err != 0) {
1031                 opkg_msg(ERROR, "postrm script for package \"%s\" failed\n",
1032                          old_pkg->name);
1033                 return -1;
1034         }
1035         return 0;
1036 }
1037
1038 static int postrm_upgrade_old_pkg_unwind(pkg_t * pkg, pkg_t * old_pkg)
1039 {
1040         /* DPKG_INCOMPATIBILITY:
1041            dpkg does some things here that we don't do yet. Do we care?
1042            (See postrm_upgrade_old_pkg for details)
1043          */
1044         return 0;
1045 }
1046
1047 static int remove_obsolesced_files(pkg_t * pkg, pkg_t * old_pkg)
1048 {
1049         int err = 0;
1050         str_list_t *old_files;
1051         str_list_elt_t *of;
1052         str_list_t *new_files;
1053         str_list_elt_t *nf;
1054         hash_table_t new_files_table;
1055
1056         old_files = pkg_get_installed_files(old_pkg);
1057         if (old_files == NULL)
1058                 return -1;
1059
1060         new_files = pkg_get_installed_files(pkg);
1061         if (new_files == NULL) {
1062                 pkg_free_installed_files(old_pkg);
1063                 return -1;
1064         }
1065
1066         new_files_table.entries = NULL;
1067         hash_table_init("new_files", &new_files_table, 20);
1068         for (nf = str_list_first(new_files); nf;
1069              nf = str_list_next(new_files, nf)) {
1070                 if (nf && nf->data)
1071                         hash_table_insert(&new_files_table, nf->data, nf->data);
1072         }
1073
1074         for (of = str_list_first(old_files); of;
1075              of = str_list_next(old_files, of)) {
1076                 pkg_t *owner;
1077                 char *old, *new;
1078                 old = (char *)of->data;
1079                 new = (char *)hash_table_get(&new_files_table, old);
1080                 if (new)
1081                         continue;
1082
1083                 if (file_is_dir(old)) {
1084                         continue;
1085                 }
1086                 owner = file_hash_get_file_owner(old);
1087                 if (owner != old_pkg) {
1088                         /* in case obsolete file no longer belongs to old_pkg */
1089                         continue;
1090                 }
1091
1092                 /* old file is obsolete */
1093                 opkg_msg(NOTICE, "Removing obsolete file %s.\n", old);
1094                 if (!conf->noaction) {
1095                         err = unlink(old);
1096                         if (err) {
1097                                 opkg_perror(ERROR, "unlinking %s failed", old);
1098                         }
1099                 }
1100         }
1101
1102         hash_table_deinit(&new_files_table);
1103         pkg_free_installed_files(old_pkg);
1104         pkg_free_installed_files(pkg);
1105
1106         return err;
1107 }
1108
1109 static int install_maintainer_scripts(pkg_t * pkg, pkg_t * old_pkg)
1110 {
1111         int ret;
1112         char *prefix;
1113
1114         sprintf_alloc(&prefix, "%s.", pkg->name);
1115         ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
1116                                                            pkg->dest->info_dir,
1117                                                            prefix);
1118         free(prefix);
1119         return ret;
1120 }
1121
1122 static int remove_disappeared(pkg_t * pkg)
1123 {
1124         /* DPKG_INCOMPATIBILITY:
1125            This is a fairly sophisticated dpkg operation. Shall we
1126            skip it? */
1127
1128         /* Any packages all of whose files have been overwritten during the
1129            installation, and which aren't required for dependencies, are
1130            considered to have been removed. For each such package
1131            1. disappearer's-postrm disappear overwriter overwriter-version
1132            2. The package's maintainer scripts are removed
1133            3. It is noted in the status database as being in a sane state,
1134            namely not installed (any conffiles it may have are ignored,
1135            rather than being removed by dpkg). Note that disappearing
1136            packages do not have their prerm called, because dpkg doesn't
1137            know in advance that the package is going to vanish.
1138          */
1139         return 0;
1140 }
1141
1142 static int install_data_files(pkg_t * pkg)
1143 {
1144         int err;
1145
1146         /* opkg takes a slightly different approach to data file backups
1147            than dpkg. Rather than removing backups at this point, we
1148            actually do the data file installation now. See comments in
1149            check_data_file_clashes() for more details. */
1150
1151         opkg_msg(INFO, "Extracting data files to %s.\n", pkg->dest->root_dir);
1152         err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
1153         if (err) {
1154                 return err;
1155         }
1156
1157         opkg_msg(DEBUG, "Calling pkg_write_filelist.\n");
1158         err = pkg_write_filelist(pkg);
1159         if (err)
1160                 return err;
1161
1162         /* XXX: FEATURE: opkg should identify any files which existed
1163            before installation and which were overwritten, (see
1164            check_data_file_clashes()). What it must do is remove any such
1165            files from the filelist of the old package which provided the
1166            file. Otherwise, if the old package were removed at some point
1167            it would break the new package. Removing the new package will
1168            also break the old one, but this cannot be helped since the old
1169            package's file has already been deleted. This is the importance
1170            of check_data_file_clashes(), and only allowing opkg to install
1171            a clashing package with a user force. */
1172
1173         return 0;
1174 }
1175
1176 static int resolve_conffiles(pkg_t * pkg)
1177 {
1178         conffile_list_elt_t *iter;
1179         conffile_list_t *cl;
1180         conffile_t *cf;
1181         char *cf_backup;
1182         char *chksum;
1183
1184         if (conf->noaction)
1185                 return 0;
1186
1187         cl = pkg_get_ptr(pkg, PKG_CONFFILES);
1188
1189         for (iter = cl ? nv_pair_list_first(cl) : NULL; iter;
1190              iter = nv_pair_list_next(cl, iter)) {
1191                 char *root_filename;
1192                 cf = (conffile_t *) iter->data;
1193                 root_filename = root_filename_alloc(cf->name);
1194
1195                 /* Might need to initialize the md5sum for each conffile */
1196                 if (cf->value == NULL) {
1197                         cf->value = file_sha256sum_alloc(root_filename);
1198                 }
1199
1200                 if (!file_exists(root_filename)) {
1201                         free(root_filename);
1202                         continue;
1203                 }
1204
1205                 cf_backup = backup_filename_alloc(root_filename);
1206
1207                 if (file_exists(cf_backup)) {
1208                         /* Let's compute md5 to test if files are changed */
1209                         if (cf->value && strlen(cf->value) > 33) {
1210                                 chksum = file_sha256sum_alloc(cf_backup);
1211                         } else {
1212                                 chksum = file_md5sum_alloc(cf_backup);
1213                         }
1214
1215                         if (chksum && cf->value
1216                             && strcmp(cf->value, chksum) != 0) {
1217                                 if (conf->force_maintainer) {
1218                                         opkg_msg(NOTICE,
1219                                                  "Conffile %s using maintainer's setting.\n",
1220                                                  cf_backup);
1221                                 } else {
1222                                         char *new_conffile;
1223                                         sprintf_alloc(&new_conffile, "%s-opkg",
1224                                                       root_filename);
1225                                         opkg_msg(ERROR,
1226                                                  "Existing conffile %s "
1227                                                  "is different from the conffile in the new package."
1228                                                  " The new conffile will be placed at %s.\n",
1229                                                  root_filename, new_conffile);
1230                                         rename(root_filename, new_conffile);
1231                                         rename(cf_backup, root_filename);
1232                                         free(new_conffile);
1233                                 }
1234                         }
1235                         unlink(cf_backup);
1236                         if (chksum)
1237                                 free(chksum);
1238                 }
1239
1240                 free(cf_backup);
1241                 free(root_filename);
1242         }
1243
1244         return 0;
1245 }
1246
1247 int opkg_install_by_name(const char *pkg_name)
1248 {
1249         int cmp;
1250         pkg_t *old, *new;
1251         char *old_version, *new_version;
1252
1253         old = pkg_hash_fetch_installed_by_name(pkg_name);
1254         if (old)
1255                 opkg_msg(DEBUG2, "Old versions from pkg_hash_fetch %s.\n",
1256                          pkg_get_string(old, PKG_VERSION));
1257
1258         new = pkg_hash_fetch_best_installation_candidate_by_name(pkg_name);
1259         if (new == NULL) {
1260                 opkg_msg(NOTICE, "Unknown package '%s'.\n", pkg_name);
1261                 return -1;
1262         }
1263
1264         opkg_msg(DEBUG2, "Versions from pkg_hash_fetch:");
1265         if (old)
1266                 opkg_message(DEBUG2, " old %s ", pkg_get_string(old, PKG_VERSION));
1267         opkg_message(DEBUG2, " new %s\n", pkg_get_string(new, PKG_VERSION));
1268
1269         new->state_flag |= SF_USER;
1270         if (old) {
1271                 old_version = pkg_version_str_alloc(old);
1272                 new_version = pkg_version_str_alloc(new);
1273
1274                 cmp = pkg_compare_versions(old, new);
1275                 if ((conf->force_downgrade == 1) && (cmp > 0)) {        /* We've been asked to allow downgrade  and version is precedent */
1276                         opkg_msg(DEBUG, "Forcing downgrade\n");
1277                         cmp = -1;       /* then we force opkg to downgrade */
1278                         /* We need to use a value < 0 because in the 0 case we are asking to */
1279                         /* reinstall, and some check could fail asking the "force-reinstall" option */
1280                 }
1281                 opkg_msg(DEBUG, "Comparing visible versions of pkg %s:"
1282                          "\n\t%s is installed "
1283                          "\n\t%s is available "
1284                          "\n\t%d was comparison result\n",
1285                          pkg_name, old_version, new_version, cmp);
1286                 if (cmp == 0) {
1287                         opkg_msg(NOTICE,
1288                                  "Package %s (%s) installed in %s is up to date.\n",
1289                                  old->name, old_version, old->dest->name);
1290                         free(old_version);
1291                         free(new_version);
1292                         return 0;
1293                 } else if (cmp > 0) {
1294                         opkg_msg(NOTICE,
1295                                  "Not downgrading package %s on %s from %s to %s.\n",
1296                                  old->name, old->dest->name, old_version,
1297                                  new_version);
1298                         free(old_version);
1299                         free(new_version);
1300                         return 0;
1301                 } else if (cmp < 0) {
1302                         new->dest = old->dest;
1303                         old->state_want = SW_DEINSTALL;
1304                 }
1305                 free(old_version);
1306                 free(new_version);
1307         }
1308
1309         opkg_msg(DEBUG2, "Calling opkg_install_pkg.\n");
1310         return opkg_install_pkg(new, 0);
1311 }
1312
1313 /**
1314  *  @brief Really install a pkg_t
1315  */
1316 int opkg_install_pkg(pkg_t * pkg, int from_upgrade)
1317 {
1318         int err = 0;
1319         int message = 0;
1320         pkg_t *old_pkg = NULL;
1321         pkg_vec_t *replacees;
1322         abstract_pkg_t *ab_pkg = NULL;
1323         int old_state_flag;
1324         char *file_md5, *pkg_md5;
1325         char *file_sha256, *pkg_sha256;
1326         sigset_t newset, oldset;
1327         const char *local_filename;
1328         time_t now;
1329
1330         if (from_upgrade)
1331                 message = 1;    /* Coming from an upgrade, and should change the output message */
1332
1333         opkg_msg(DEBUG2, "Calling pkg_arch_supported.\n");
1334
1335         if (!pkg_arch_supported(pkg)) {
1336                 opkg_msg(ERROR,
1337                          "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
1338                          pkg_get_architecture(pkg), pkg->name);
1339                 return -1;
1340         }
1341         if (pkg->state_status == SS_INSTALLED && conf->nodeps == 0) {
1342                 err = satisfy_dependencies_for(pkg);
1343                 if (err)
1344                         return -1;
1345
1346                 opkg_msg(NOTICE, "Package %s is already installed on %s.\n",
1347                          pkg->name, pkg->dest->name);
1348                 return 0;
1349         }
1350
1351         if (pkg->dest == NULL) {
1352                 pkg->dest = conf->default_dest;
1353         }
1354
1355         old_pkg = pkg_hash_fetch_installed_by_name(pkg->name);
1356
1357         err = opkg_install_check_downgrade(pkg, old_pkg, message);
1358         if (err)
1359                 return -1;
1360
1361         pkg->state_want = SW_INSTALL;
1362         if (old_pkg) {
1363                 old_pkg->state_want = SW_DEINSTALL;     /* needed for check_data_file_clashes of dependencies */
1364
1365                 err = check_reverse_depends_for(pkg, old_pkg);
1366                 if (err)
1367                         return -1;
1368         }
1369
1370         err = check_conflicts_for(pkg);
1371         if (err)
1372                 return -1;
1373
1374         /* this setup is to remove the upgrade scenario in the end when
1375            installing pkg A, A deps B & B deps on A. So both B and A are
1376            installed. Then A's installation is started resulting in an
1377            uncecessary upgrade */
1378         if (pkg->state_status == SS_INSTALLED)
1379                 return 0;
1380
1381         err = verify_pkg_installable(pkg);
1382         if (err)
1383                 return -1;
1384
1385         local_filename = pkg_get_string(pkg, PKG_LOCAL_FILENAME);
1386
1387         if (local_filename == NULL) {
1388                 if (!conf->cache && conf->download_only) {
1389                         char cwd[4096];
1390                         if (getcwd(cwd, sizeof(cwd)) != NULL)
1391                                 err = opkg_download_pkg(pkg, cwd);
1392                         else
1393                                 return -1;
1394                 } else {
1395                         err = opkg_download_pkg(pkg, conf->tmp_dir);
1396                 }
1397                 if (err) {
1398                         opkg_msg(ERROR, "Failed to download %s. "
1399                                  "Perhaps you need to run 'opkg update'?\n",
1400                                  pkg->name);
1401                         return -1;
1402                 }
1403
1404                 local_filename = pkg_get_string(pkg, PKG_LOCAL_FILENAME);
1405         }
1406
1407         /* check that the repository is valid */
1408 #if defined(HAVE_USIGN)
1409         char *list_file_name, *sig_file_name, *lists_dir;
1410
1411         /* check to ensure the package has come from a repository */
1412         if (conf->check_signature && pkg->src) {
1413                 sprintf_alloc(&lists_dir, "%s", (conf->restrict_to_default_dest)
1414                               ? conf->default_dest->lists_dir
1415                               : conf->lists_dir);
1416                 sprintf_alloc(&list_file_name, "%s/%s", lists_dir,
1417                               pkg->src->name);
1418                 sprintf_alloc(&sig_file_name, "%s/%s.sig", lists_dir,
1419                               pkg->src->name);
1420
1421                 if (file_exists(sig_file_name)) {
1422                         if (opkg_verify_file(list_file_name, sig_file_name)) {
1423                                 opkg_msg(ERROR,
1424                                          "Failed to verify the signature of %s.\n",
1425                                          list_file_name);
1426                                 if (!conf->force_signature)
1427                                         return -1;
1428                         }
1429                 } else {
1430                         opkg_msg(ERROR, "Signature file is missing for %s. "
1431                                  "Perhaps you need to run 'opkg update'?\n",
1432                                  pkg->name);
1433                         if (!conf->force_signature)
1434                                 return -1;
1435                 }
1436
1437                 free(lists_dir);
1438                 free(list_file_name);
1439                 free(sig_file_name);
1440         }
1441 #endif
1442
1443         /* Check for md5 values */
1444         pkg_md5 = pkg_get_md5(pkg);
1445         if (pkg_md5) {
1446                 file_md5 = file_md5sum_alloc(local_filename);
1447                 if (file_md5 && strcmp(file_md5, pkg_md5)) {
1448                         if (!conf->force_checksum) {
1449                                 opkg_msg(ERROR, "Package %s md5sum mismatch. "
1450                                          "Either the opkg or the package index are corrupt. "
1451                                          "Try 'opkg update'.\n", pkg->name);
1452                                 free(file_md5);
1453                                 return -1;
1454                         } else {
1455                                 opkg_msg(NOTICE,
1456                                          "Ignored %s md5sum mismatch.\n",
1457                                          pkg->name);
1458                         }
1459                 }
1460                 if (file_md5)
1461                         free(file_md5);
1462         }
1463
1464         /* Check for sha256 value */
1465         pkg_sha256 = pkg_get_sha256(pkg);
1466         if (pkg_sha256) {
1467                 file_sha256 = file_sha256sum_alloc(local_filename);
1468                 if (file_sha256 && strcmp(file_sha256, pkg_sha256)) {
1469                         if (!conf->force_checksum) {
1470                                 opkg_msg(ERROR,
1471                                          "Package %s sha256sum mismatch. "
1472                                          "Either the opkg or the package index are corrupt. "
1473                                          "Try 'opkg update'.\n", pkg->name);
1474                                 free(file_sha256);
1475                                 return -1;
1476                         } else {
1477                                 opkg_msg(NOTICE,
1478                                          "Ignored %s sha256sum mismatch.\n",
1479                                          pkg->name);
1480                         }
1481                 }
1482                 if (file_sha256)
1483                         free(file_sha256);
1484         }
1485
1486         if (conf->download_only) {
1487                 if (conf->nodeps == 0) {
1488                         err = satisfy_dependencies_for(pkg);
1489                         if (err)
1490                                 return -1;
1491                 }
1492                 return 0;
1493         }
1494
1495         if (!pkg_get_string(pkg, PKG_TMP_UNPACK_DIR)) {
1496                 if (unpack_pkg_control_files(pkg) == -1) {
1497                         opkg_msg(ERROR,
1498                                  "Failed to unpack control files from %s.\n",
1499                                  local_filename);
1500                         return -1;
1501                 }
1502         }
1503
1504         err = update_file_ownership(pkg, old_pkg);
1505         if (err)
1506                 return -1;
1507
1508         if (conf->nodeps == 0) {
1509                 err = satisfy_dependencies_for(pkg);
1510                 if (err)
1511                         return -1;
1512                 if (pkg->state_status == SS_UNPACKED)
1513                         /* Circular dependency has installed it for us. */
1514                         return 0;
1515         }
1516
1517         replacees = pkg_vec_alloc();
1518         pkg_get_installed_replacees(pkg, replacees);
1519
1520         /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
1521
1522         sigemptyset(&newset);
1523         sigaddset(&newset, SIGINT);
1524         sigprocmask(SIG_BLOCK, &newset, &oldset);
1525
1526         opkg_state_changed++;
1527         pkg->state_flag |= SF_FILELIST_CHANGED;
1528
1529         if (old_pkg) {
1530                 pkg_remove_orphan_dependent(pkg, old_pkg);
1531                 old_pkg->is_upgrade = 1;
1532                 pkg->is_upgrade = 1;
1533         }
1534         /* XXX: BUG: we really should treat replacement more like an upgrade
1535          *      Instead, we're going to remove the replacees
1536          */
1537         err = pkg_remove_installed_replacees(replacees);
1538         if (err)
1539                 goto UNWIND_REMOVE_INSTALLED_REPLACEES;
1540
1541         err = prerm_upgrade_old_pkg(pkg, old_pkg);
1542         if (err)
1543                 goto UNWIND_PRERM_UPGRADE_OLD_PKG;
1544
1545         err = prerm_deconfigure_conflictors(pkg, replacees);
1546         if (err)
1547                 goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
1548
1549         err = preinst_configure(pkg, old_pkg);
1550         if (err)
1551                 goto UNWIND_PREINST_CONFIGURE;
1552
1553         err = backup_modified_conffiles(pkg, old_pkg);
1554         if (err)
1555                 goto UNWIND_BACKUP_MODIFIED_CONFFILES;
1556
1557         err = check_data_file_clashes(pkg, old_pkg);
1558         if (err)
1559                 goto UNWIND_CHECK_DATA_FILE_CLASHES;
1560
1561         err = postrm_upgrade_old_pkg(pkg, old_pkg);
1562         if (err)
1563                 goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
1564
1565         if (conf->noaction)
1566                 return 0;
1567
1568         /* point of no return: no unwinding after this */
1569         if (old_pkg) {
1570                 old_pkg->state_want = SW_DEINSTALL;
1571
1572                 if (old_pkg->state_flag & SF_NOPRUNE) {
1573                         opkg_msg(INFO, "Not removing obsolesced files because "
1574                                  "package %s marked noprune.\n", old_pkg->name);
1575                 } else {
1576                         opkg_msg(INFO, "Removing obsolesced files for %s\n",
1577                                  old_pkg->name);
1578                         if (remove_obsolesced_files(pkg, old_pkg)) {
1579                                 opkg_msg(ERROR, "Failed to determine "
1580                                          "obsolete files from previously "
1581                                          "installed %s\n", old_pkg->name);
1582                         }
1583                 }
1584
1585                 /* removing files from old package, to avoid ghost files */
1586                 remove_data_files_and_list(old_pkg);
1587                 remove_maintainer_scripts(old_pkg);
1588         }
1589
1590         opkg_msg(INFO, "%s maintainer scripts.\n",
1591                  (pkg->is_upgrade) ? ("Upgrading") : ("Installing"));
1592         if (install_maintainer_scripts(pkg, old_pkg)) {
1593                 opkg_msg(ERROR, "Failed to extract maintainer scripts for %s."
1594                          " Package debris may remain!\n", pkg->name);
1595                 goto pkg_is_hosed;
1596         }
1597
1598         /* the following just returns 0 */
1599         remove_disappeared(pkg);
1600
1601         opkg_msg(INFO, "Installing data files for %s.\n", pkg->name);
1602
1603         if (install_data_files(pkg)) {
1604                 opkg_msg(ERROR, "Failed to extract data files for %s. "
1605                          "Package debris may remain!\n", pkg->name);
1606                 goto pkg_is_hosed;
1607         }
1608
1609         err = check_data_file_clashes_change(pkg, old_pkg);
1610         if (err) {
1611                 opkg_msg(ERROR, "check_data_file_clashes_change() failed for "
1612                          "for files belonging to %s.\n", pkg->name);
1613         }
1614
1615         opkg_msg(INFO, "Resolving conf files for %s\n", pkg->name);
1616         resolve_conffiles(pkg);
1617
1618         pkg->state_status = SS_UNPACKED;
1619         old_state_flag = pkg->state_flag;
1620         pkg->state_flag &= ~SF_PREFER;
1621         opkg_msg(DEBUG, "pkg=%s old_state_flag=%x state_flag=%x\n",
1622                  pkg->name, old_state_flag, pkg->state_flag);
1623
1624         if (old_pkg)
1625                 old_pkg->state_status = SS_NOT_INSTALLED;
1626
1627         now = time(NULL);
1628         pkg_set_int(pkg, PKG_INSTALLED_TIME, now);
1629
1630         ab_pkg = pkg->parent;
1631         if (ab_pkg)
1632                 ab_pkg->state_status = pkg->state_status;
1633
1634         sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1635         pkg_vec_free(replacees);
1636         return 0;
1637
1638 UNWIND_POSTRM_UPGRADE_OLD_PKG:
1639         postrm_upgrade_old_pkg_unwind(pkg, old_pkg);
1640 UNWIND_CHECK_DATA_FILE_CLASHES:
1641         check_data_file_clashes_unwind(pkg, old_pkg);
1642 UNWIND_BACKUP_MODIFIED_CONFFILES:
1643         backup_modified_conffiles_unwind(pkg, old_pkg);
1644 UNWIND_PREINST_CONFIGURE:
1645         preinst_configure_unwind(pkg, old_pkg);
1646 UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1647         prerm_deconfigure_conflictors_unwind(pkg, replacees);
1648 UNWIND_PRERM_UPGRADE_OLD_PKG:
1649         prerm_upgrade_old_pkg_unwind(pkg, old_pkg);
1650 UNWIND_REMOVE_INSTALLED_REPLACEES:
1651         pkg_remove_installed_replacees_unwind(replacees);
1652
1653 pkg_is_hosed:
1654         sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1655
1656         pkg_vec_free(replacees);
1657         return -1;
1658 }