libopkg/opkg_install.c

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