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