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      char *root_dir;
 479
 480      if (!conf->force_space && pkg->installed_size != NULL) {
 481           root_dir = pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir;
 482           blocks_available = get_available_blocks(root_dir);
 483
 484           comp_size = strtoul(pkg->installed_size, NULL, 0);
 485           /* round up a blocks count without doing fancy-but-slow casting jazz */
 486           comp_size = (int)((comp_size + 1023) / 1024);
 487
 488           if (comp_size >= blocks_available) {
 489                opkg_message(conf, OPKG_ERROR,
 490                             "Only have %d available blocks on filesystem %s, pkg %s needs %d\n",
 491                             blocks_available, root_dir, pkg->name, comp_size);
 492                return ENOSPC;
 493           }
 494      }
 495      return 0;
 496 }
 497
 498 static int unpack_pkg_control_files(opkg_conf_t *conf, pkg_t *pkg)
 499 {
 500      int err;
 501      char *conffiles_file_name;
 502      char *root_dir;
 503      FILE *conffiles_file;
 504
 505      sprintf_alloc(&pkg->tmp_unpack_dir, "%s/%s-XXXXXX", conf->tmp_dir, pkg->name);
 506
 507      pkg->tmp_unpack_dir = mkdtemp(pkg->tmp_unpack_dir);
 508      if (pkg->tmp_unpack_dir == NULL) {
 509           opkg_message(conf, OPKG_ERROR,
 510                        "%s: Failed to create temporary directory '%s': %s\n",
 511                        __FUNCTION__, pkg->tmp_unpack_dir, strerror(errno));
 512           return errno;
 513      }
 514
 515      err = pkg_extract_control_files_to_dir(pkg, pkg->tmp_unpack_dir);
 516      if (err) {
 517           return err;
 518      }
 519
 520      /* XXX: CLEANUP: There might be a cleaner place to read in the
 521         conffiles. Seems like I should be able to get everything to go
 522         through pkg_init_from_file. If so, maybe it would make sense to
 523         move all of unpack_pkg_control_files to that function. */
 524
 525      /* Don't need to re-read conffiles if we already have it */
 526      if (!nv_pair_list_empty(&pkg->conffiles)) {
 527           return 0;
 528      }
 529
 530      sprintf_alloc(&conffiles_file_name, "%s/conffiles", pkg->tmp_unpack_dir);
 531      if (! file_exists(conffiles_file_name)) {
 532           free(conffiles_file_name);
 533           return 0;
 534      }
 535
 536      conffiles_file = fopen(conffiles_file_name, "r");
 537      if (conffiles_file == NULL) {
 538           fprintf(stderr, "%s: failed to open %s: %s\n",
 539                   __FUNCTION__, conffiles_file_name, strerror(errno));
 540           free(conffiles_file_name);
 541           return errno;
 542      }
 543      free(conffiles_file_name);
 544
 545      while (1) {
 546           char *cf_name;
 547           char *cf_name_in_dest;
 548
 549           cf_name = file_read_line_alloc(conffiles_file);
 550           if (cf_name == NULL) {
 551                break;
 552           }
 553           str_chomp(cf_name);
 554           if (cf_name[0] == '\0') {
 555                continue;
 556           }
 557
 558           /* Prepend dest->root_dir to conffile name.
 559              Take pains to avoid multiple slashes. */
 560           root_dir = pkg->dest->root_dir;
 561           if (conf->offline_root)
 562                /* skip the offline_root prefix */
 563                root_dir = pkg->dest->root_dir + strlen(conf->offline_root);
 564           sprintf_alloc(&cf_name_in_dest, "%s%s", root_dir,
 565                         cf_name[0] == '/' ? (cf_name + 1) : cf_name);
 566
 567           /* Can't get an md5sum now, (file isn't extracted yet).
 568              We'll wait until resolve_conffiles */
 569           conffile_list_append(&pkg->conffiles, cf_name_in_dest, NULL);
 570
 571           free(cf_name);
 572           free(cf_name_in_dest);
 573      }
 574
 575      fclose(conffiles_file);
 576
 577      return 0;
 578 }
 579
 580 static int pkg_remove_orphan_dependent(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
 581 {
 582     int i, j, found;
 583     char *buf, *d_str;
 584     pkg_t *p;
 585     if (!old_pkg)
 586         return 0;
 587     if (!pkg) {
 588         fprintf(stderr, "pkg shall not be NULL here.  please send to the bugzilla!! [%s %d]\n", __FILE__, __LINE__);
 589         return -1;
 590     }
 591     if (old_pkg->depends_count == 0)
 592         return 0;
 593     for (i=0;i<old_pkg->depends_count;i++) {
 594         found = 0;
 595         for (j=0;j<pkg->depends_count;j++) {
 596             if (!strcmp(old_pkg->depends_str[i], pkg->depends_str[j])) {
 597                 found = 1;
 598                 break;
 599             }
 600         }
 601         if (found)
 602             continue;
 603         d_str = old_pkg->depends_str[i];
 604         buf = calloc (1, strlen (d_str) + 1);
 605         j=0;
 606         while (d_str[j] != '\0' && d_str[j] != ' ') {
 607             buf[j]=d_str[j];
 608             ++j;
 609         }
 610         buf[j]='\0';
 611         buf = realloc (buf, strlen (buf) + 1);
 612         p = pkg_hash_fetch_installed_by_name (&conf->pkg_hash, buf);
 613         if (!p) {
 614             fprintf(stderr, "The pkg %s had been removed!!\n", buf);
 615             free(buf);
 616             continue;
 617         }
 618         if (p->auto_installed) {
 619             int deps;
 620             abstract_pkg_t **dependents;
 621             deps = pkg_has_installed_dependents(conf, NULL, p, &dependents);
 622             if (deps == 0) {
 623                 opkg_message (conf, OPKG_NOTICE,"%s was autoinstalled but is now orphaned, remove it.\n", buf);
 624                 opkg_remove_pkg(conf, p, 0);
 625             } else
 626                 opkg_message (conf, OPKG_INFO, "%s was autoinstalled and is still required by %d installed packages\n", buf, deps);
 627         }
 628         free(buf);
 629     }
 630     return 0;
 631 }
 632
 633 /* returns number of installed replacees */
 634 int pkg_get_installed_replacees(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *installed_replacees)
 635 {
 636      abstract_pkg_t **replaces = pkg->replaces;
 637      int replaces_count = pkg->replaces_count;
 638      int i, j;
 639      for (i = 0; i < replaces_count; i++) {
 640           abstract_pkg_t *ab_pkg = replaces[i];
 641           pkg_vec_t *pkg_vec = ab_pkg->pkgs;
 642           if (pkg_vec) {
 643                for (j = 0; j < pkg_vec->len; j++) {
 644                     pkg_t *replacee = pkg_vec->pkgs[j];
 645                     if (!pkg_conflicts(pkg, replacee))
 646                          continue;
 647                     if (replacee->state_status == SS_INSTALLED) {
 648                          pkg_vec_insert(installed_replacees, replacee);
 649                     }
 650                }
 651           }
 652      }
 653      return installed_replacees->len;
 654 }
 655
 656 int pkg_remove_installed_replacees(opkg_conf_t *conf, pkg_vec_t *replacees)
 657 {
 658      int i;
 659      int replaces_count = replacees->len;
 660      for (i = 0; i < replaces_count; i++) {
 661           pkg_t *replacee = replacees->pkgs[i];
 662           int err;
 663           replacee->state_flag |= SF_REPLACE; /* flag it so remove won't complain */
 664           err = opkg_remove_pkg(conf, replacee,0);
 665           if (err)
 666                return err;
 667      }
 668      return 0;
 669 }
 670
 671 /* to unwind the removal: make sure they are installed */
 672 int pkg_remove_installed_replacees_unwind(opkg_conf_t *conf, pkg_vec_t *replacees)
 673 {
 674      int i, err;
 675      int replaces_count = replacees->len;
 676      for (i = 0; i < replaces_count; i++) {
 677           pkg_t *replacee = replacees->pkgs[i];
 678           if (replacee->state_status != SS_INSTALLED) {
 679                opkg_message(conf, OPKG_DEBUG2,"Function: %s calling opkg_install_pkg \n",__FUNCTION__);
 680                err = opkg_install_pkg(conf, replacee,0);
 681                if (err)
 682                     return err;
 683           }
 684      }
 685      return 0;
 686 }
 687
 688 int caught_sigint = 0;
 689 static void opkg_install_pkg_sigint_handler(int sig)
 690 {
 691      caught_sigint = sig;
 692 }
 693
 694 /* compares versions of pkg and old_pkg, returns 0 if OK to proceed with installation of pkg, 1 otherwise */
 695 static int opkg_install_check_downgrade(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg, int message)
 696 {
 697      if (old_pkg) {
 698           char message_out[15];
 699           char *old_version = pkg_version_str_alloc(old_pkg);
 700           char *new_version = pkg_version_str_alloc(pkg);
 701           int cmp = pkg_compare_versions(old_pkg, pkg);
 702           int rc = 0;
 703
 704           memset(message_out,'\x0',15);
 705           strncpy (message_out,"Upgrading ",strlen("Upgrading "));
 706           if ( (conf->force_downgrade==1) && (cmp > 0) ){     /* We've been asked to allow downgrade  and version is precedent */
 707              cmp = -1 ;                                       /* then we force opkg to downgrade */
 708              strncpy (message_out,"Downgrading ",strlen("Downgrading "));         /* We need to use a value < 0 because in the 0 case we are asking to */
 709                                                               /* reinstall, and some check could fail asking the "force-reinstall" option */
 710           }
 711
 712           if (cmp > 0) {
 713                opkg_message(conf, OPKG_NOTICE,
 714                             "Not downgrading package %s on %s from %s to %s.\n",
 715                             old_pkg->name, old_pkg->dest->name, old_version, new_version);
 716                rc = 1;
 717           } else if (cmp < 0) {
 718                opkg_message(conf, OPKG_NOTICE,
 719                             "%s%s on %s from %s to %s...\n",
 720                             message_out, pkg->name, old_pkg->dest->name, old_version, new_version);
 721                pkg->dest = old_pkg->dest;
 722                rc = 0;
 723           } else /* cmp == 0 */ {
 724                if (conf->force_reinstall) {
 725                     opkg_message(conf, OPKG_NOTICE,
 726                                  "Reinstalling %s (%s) on %s...\n",
 727                                  pkg->name, new_version, old_pkg->dest->name);
 728                     pkg->dest = old_pkg->dest;
 729                     rc = 0;
 730                } else {
 731                     opkg_message(conf, OPKG_NOTICE,
 732                                  "Not installing %s (%s) on %s -- already installed.\n",
 733                                  pkg->name, new_version, old_pkg->dest->name);
 734                     rc = 1;
 735                }
 736           }
 737           free(old_version);
 738           free(new_version);
 739           return rc;
 740      } else {
 741       char message_out[15] ;
 742       memset(message_out,'\x0',15);
 743       if ( message )
 744           strncpy( message_out,"Upgrading ",strlen("Upgrading ") );
 745       else
 746           strncpy( message_out,"Installing ",strlen("Installing ") );
 747           char *version = pkg_version_str_alloc(pkg);
 748
 749           opkg_message(conf, OPKG_NOTICE,
 750                        "%s%s (%s) to %s...\n", message_out,
 751                        pkg->name, version, pkg->dest->name);
 752           free(version);
 753           return 0;
 754      }
 755 }
 756
 757 /**
 758  *  @brief Really install a pkg_t
 759  */
 760 int opkg_install_pkg(opkg_conf_t *conf, pkg_t *pkg, int from_upgrade)
 761 {
 762      int err = 0;
 763      int message = 0;
 764      pkg_t *old_pkg = NULL;
 765      pkg_vec_t *replacees;
 766      abstract_pkg_t *ab_pkg = NULL;
 767      int old_state_flag;
 768      char* file_md5;
 769      char *pkgid;
 770
 771      if ( from_upgrade )
 772         message = 1;            /* Coming from an upgrade, and should change the output message */
 773
 774      if (!pkg) {
 775           opkg_message(conf, OPKG_ERROR,
 776                        "INTERNAL ERROR: null pkg passed to opkg_install_pkg\n");
 777           return OPKG_INSTALL_ERR_INTERNAL;
 778      }
 779
 780      opkg_message(conf, OPKG_DEBUG2, "Function: %s calling pkg_arch_supported %s \n", __FUNCTION__, __FUNCTION__);
 781
 782      if (!pkg_arch_supported(conf, pkg)) {
 783           opkg_message(conf, OPKG_ERROR, "INTERNAL ERROR: architecture %s for pkg %s is unsupported.\n",
 784                        pkg->architecture, pkg->name);
 785           return OPKG_INSTALL_ERR_INTERNAL;
 786      }
 787      if (pkg->state_status == SS_INSTALLED && conf->force_reinstall == 0 && conf->nodeps == 0) {
 788           err = satisfy_dependencies_for(conf, pkg);
 789           if (err) { return OPKG_INSTALL_ERR_DEPENDENCIES; }
 790
 791           opkg_message(conf, OPKG_NOTICE,
 792                        "Package %s is already installed in %s.\n",
 793                        pkg->name, pkg->dest->name);
 794           return 0;
 795      }
 796
 797      if (pkg->dest == NULL) {
 798           pkg->dest = conf->default_dest;
 799      }
 800
 801      old_pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name);
 802
 803      err = opkg_install_check_downgrade(conf, pkg, old_pkg, message);
 804      if (err) { return OPKG_INSTALL_ERR_NO_DOWNGRADE; }
 805
 806      pkg->state_want = SW_INSTALL;
 807      if (old_pkg){
 808          old_pkg->state_want = SW_DEINSTALL; /* needed for check_data_file_clashes of dependences */
 809      }
 810
 811
 812      /* Abhaya: conflicts check */
 813      err = check_conflicts_for(conf, pkg);
 814      if (err) { return OPKG_INSTALL_ERR_CONFLICTS; }
 815
 816      /* this setup is to remove the upgrade scenario in the end when
 817         installing pkg A, A deps B & B deps on A. So both B and A are
 818         installed. Then A's installation is started resulting in an
 819         uncecessary upgrade */
 820      if (pkg->state_status == SS_INSTALLED
 821          && conf->force_reinstall == 0) return 0;
 822
 823      err = verify_pkg_installable(conf, pkg);
 824      if (err) { return OPKG_INSTALL_ERR_NO_SPACE; }
 825
 826      if (pkg->local_filename == NULL) {
 827           err = opkg_download_pkg(conf, pkg, conf->tmp_dir);
 828           if (err) {
 829                opkg_message(conf, OPKG_ERROR,
 830                             "Failed to download %s. Perhaps you need to run 'opkg update'?\n",
 831                             pkg->name);
 832                return OPKG_INSTALL_ERR_DOWNLOAD;
 833           }
 834      }
 835
 836      /* check that the repository is valid */
 837      #if HAVE_GPGME
 838      char *list_file_name, *sig_file_name, *lists_dir;
 839
 840      /* check to ensure the package has come from a repository */
 841      if (conf->check_signature && pkg->src)
 842      {
 843        sprintf_alloc (&lists_dir, "%s",
 844                      (conf->restrict_to_default_dest)
 845                       ? conf->default_dest->lists_dir
 846                       : conf->lists_dir);
 847        sprintf_alloc (&list_file_name, "%s/%s", lists_dir, pkg->src->name);
 848        sprintf_alloc (&sig_file_name, "%s/%s.sig", lists_dir, pkg->src->name);
 849
 850        if (file_exists (sig_file_name))
 851        {
 852          if (opkg_verify_file (conf, list_file_name, sig_file_name))
 853            return OPKG_INSTALL_ERR_SIGNATURE;
 854        }
 855
 856        free (lists_dir);
 857        free (list_file_name);
 858        free (sig_file_name);
 859      }
 860      #endif
 861
 862      /* Check for md5 values */
 863      if (pkg->md5sum)
 864      {
 865          file_md5 = file_md5sum_alloc(pkg->local_filename);
 866          if (strcmp(file_md5, pkg->md5sum))
 867          {
 868               opkg_message(conf, OPKG_ERROR,
 869                            "Package %s md5sum mismatch. Either the opkg or the package index are corrupt. Try 'opkg update'.\n",
 870                            pkg->name);
 871               free(file_md5);
 872               return OPKG_INSTALL_ERR_MD5;
 873          }
 874          free(file_md5);
 875      }
 876
 877      if (pkg->tmp_unpack_dir == NULL) {
 878           unpack_pkg_control_files(conf, pkg);
 879      }
 880
 881      /* We should update the filelist here, so that upgrades of packages that split will not fail. -Jamey 27-MAR-03 */
 882 /* Pigi: check if it will pass from here when replacing. It seems to fail */
 883 /* That's rather strange that files don't change owner. Investigate !!!!!!*/
 884      err = update_file_ownership(conf, pkg, old_pkg);
 885      if (err) { return OPKG_ERR_UNKNOWN; }
 886
 887      if (conf->nodeps == 0) {
 888           err = satisfy_dependencies_for(conf, pkg);
 889           if (err) { return OPKG_INSTALL_ERR_DEPENDENCIES; }
 890      }
 891
 892      replacees = pkg_vec_alloc();
 893      pkg_get_installed_replacees(conf, pkg, replacees);
 894
 895      sprintf_alloc (&pkgid, "%s;%s;%s;", pkg->name, pkg->version, pkg->architecture);
 896      opkg_set_current_state (conf, OPKG_STATE_INSTALLING_PKG, pkgid);
 897      free (pkgid);
 898
 899      /* this next section we do with SIGINT blocked to prevent inconsistency between opkg database and filesystem */
 900      {
 901           sigset_t newset, oldset;
 902           sighandler_t old_handler = NULL;
 903           int use_signal = 0;
 904           caught_sigint = 0;
 905           if (use_signal) {
 906                old_handler = signal(SIGINT, opkg_install_pkg_sigint_handler);
 907           } else {
 908                sigemptyset(&newset);
 909                sigaddset(&newset, SIGINT);
 910                sigprocmask(SIG_BLOCK, &newset, &oldset);
 911           }
 912
 913           opkg_state_changed++;
 914           pkg->state_flag |= SF_FILELIST_CHANGED;
 915
 916           pkg_remove_orphan_dependent(conf, pkg, old_pkg);
 917
 918           /* XXX: BUG: we really should treat replacement more like an upgrade
 919            *      Instead, we're going to remove the replacees
 920            */
 921           err = pkg_remove_installed_replacees(conf, replacees);
 922           if (err) goto UNWIND_REMOVE_INSTALLED_REPLACEES;
 923
 924           err = prerm_upgrade_old_pkg(conf, pkg, old_pkg);
 925           if (err) goto UNWIND_PRERM_UPGRADE_OLD_PKG;
 926
 927           err = prerm_deconfigure_conflictors(conf, pkg, replacees);
 928           if (err) goto UNWIND_PRERM_DECONFIGURE_CONFLICTORS;
 929
 930           err = preinst_configure(conf, pkg, old_pkg);
 931           if (err) goto UNWIND_PREINST_CONFIGURE;
 932
 933           err = backup_modified_conffiles(conf, pkg, old_pkg);
 934           if (err) goto UNWIND_BACKUP_MODIFIED_CONFFILES;
 935
 936           err = check_data_file_clashes(conf, pkg, old_pkg);
 937           if (err) goto UNWIND_CHECK_DATA_FILE_CLASHES;
 938
 939           err = postrm_upgrade_old_pkg(conf, pkg, old_pkg);
 940           if (err) goto UNWIND_POSTRM_UPGRADE_OLD_PKG;
 941
 942           if (conf->noaction) return 0;
 943
 944           /* point of no return: no unwinding after this */
 945           if (old_pkg && !conf->force_reinstall) {
 946                old_pkg->state_want = SW_DEINSTALL;
 947
 948                if (old_pkg->state_flag & SF_NOPRUNE) {
 949                     opkg_message(conf, OPKG_INFO,
 950                                  "  not removing obsolesced files because package marked noprune\n");
 951                } else {
 952                     opkg_message(conf, OPKG_INFO,
 953                                  "  removing obsolesced files\n");
 954                     remove_obsolesced_files(conf, pkg, old_pkg);
 955                }
 956                /* removing files from old package, to avoid ghost files */
 957                remove_data_files_and_list(conf, old_pkg);
 958 /* Pigi : It should be better to remove also maintainer and postrem scripts here, just in case*/
 959                remove_maintainer_scripts_except_postrm(conf, old_pkg);
 960                remove_postrm(conf, old_pkg);
 961 /* Pigi */
 962
 963           }
 964
 965
 966           opkg_message(conf, OPKG_INFO,
 967                        "  installing maintainer scripts\n");
 968           install_maintainer_scripts(conf, pkg, old_pkg);
 969
 970           /* the following just returns 0 */
 971           remove_disappeared(conf, pkg);
 972
 973           opkg_message(conf, OPKG_INFO,
 974                        "  installing data files\n");
 975           install_data_files(conf, pkg);
 976
 977 /* read comments from function for detail but I will execute this here as all other tests are ok.*/
 978           err = check_data_file_clashes_change(conf, pkg, old_pkg);
 979
 980           opkg_message(conf, OPKG_INFO,
 981                        "  resolving conf files\n");
 982           resolve_conffiles(conf, pkg);
 983
 984           pkg->state_status = SS_UNPACKED;
 985           old_state_flag = pkg->state_flag;
 986           pkg->state_flag &= ~SF_PREFER;
 987           opkg_message(conf, OPKG_DEBUG, "   pkg=%s old_state_flag=%x state_flag=%x\n", pkg->name, old_state_flag, pkg->state_flag);
 988
 989           if (old_pkg && !conf->force_reinstall) {
 990                old_pkg->state_status = SS_NOT_INSTALLED;
 991           }
 992
 993           time(&pkg->installed_time);
 994
 995           opkg_message(conf, OPKG_INFO,
 996                        "  cleanup temp files\n");
 997           cleanup_temporary_files(conf, pkg);
 998
 999           ab_pkg = pkg->parent;
1000           if (ab_pkg)
1001                ab_pkg->state_status = pkg->state_status;
1002
1003           opkg_message(conf, OPKG_INFO, "Done.\n");
1004
1005           if (use_signal)
1006                signal(SIGINT, old_handler);
1007           else
1008                sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1009           pkg_vec_free (replacees);
1010           return 0;
1011
1012
1013      UNWIND_POSTRM_UPGRADE_OLD_PKG:
1014           postrm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
1015      UNWIND_CHECK_DATA_FILE_CLASHES:
1016           check_data_file_clashes_unwind(conf, pkg, old_pkg);
1017      UNWIND_BACKUP_MODIFIED_CONFFILES:
1018           backup_modified_conffiles_unwind(conf, pkg, old_pkg);
1019      UNWIND_PREINST_CONFIGURE:
1020           preinst_configure_unwind(conf, pkg, old_pkg);
1021      UNWIND_PRERM_DECONFIGURE_CONFLICTORS:
1022           prerm_deconfigure_conflictors_unwind(conf, pkg, replacees);
1023      UNWIND_PRERM_UPGRADE_OLD_PKG:
1024           prerm_upgrade_old_pkg_unwind(conf, pkg, old_pkg);
1025      UNWIND_REMOVE_INSTALLED_REPLACEES:
1026           pkg_remove_installed_replacees_unwind(conf, replacees);
1027
1028           opkg_message(conf, OPKG_INFO,
1029                        "  cleanup temp files\n");
1030           cleanup_temporary_files(conf, pkg);
1031
1032           opkg_message(conf, OPKG_INFO,
1033                        "Failed.\n");
1034           if (use_signal)
1035                signal(SIGINT, old_handler);
1036           else
1037                sigprocmask(SIG_UNBLOCK, &newset, &oldset);
1038
1039           pkg_vec_free (replacees);
1040           return OPKG_ERR_UNKNOWN;
1041      }
1042      opkg_set_current_state (conf, OPKG_STATE_NONE, NULL);
1043 }
1044
1045 static int prerm_upgrade_old_pkg(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1046 {
1047      /* DPKG_INCOMPATIBILITY:
1048         dpkg does some things here that we don't do yet. Do we care?
1049
1050         1. If a version of the package is already installed, call
1051            old-prerm upgrade new-version
1052         2. If the script runs but exits with a non-zero exit status
1053            new-prerm failed-upgrade old-version
1054            Error unwind, for both the above cases:
1055            old-postinst abort-upgrade new-version
1056      */
1057      return 0;
1058 }
1059
1060 static int prerm_upgrade_old_pkg_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1061 {
1062      /* DPKG_INCOMPATIBILITY:
1063         dpkg does some things here that we don't do yet. Do we care?
1064         (See prerm_upgrade_old_package for details)
1065      */
1066      return 0;
1067 }
1068
1069 static int prerm_deconfigure_conflictors(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors)
1070 {
1071      /* DPKG_INCOMPATIBILITY:
1072         dpkg does some things here that we don't do yet. Do we care?
1073         2. If a 'conflicting' package is being removed at the same time:
1074                 1. If any packages depended on that conflicting package and
1075                    --auto-deconfigure is specified, call, for each such package:
1076                    deconfigured's-prerm deconfigure \
1077                    in-favour package-being-installed version \
1078                    removing conflicting-package version
1079                 Error unwind:
1080                    deconfigured's-postinst abort-deconfigure \
1081                    in-favour package-being-installed-but-failed version \
1082                    removing conflicting-package version
1083
1084                    The deconfigured packages are marked as requiring
1085                    configuration, so that if --install is used they will be
1086                    configured again if possible.
1087                 2. To prepare for removal of the conflicting package, call:
1088                    conflictor's-prerm remove in-favour package new-version
1089                 Error unwind:
1090                    conflictor's-postinst abort-remove in-favour package new-version
1091      */
1092      return 0;
1093 }
1094
1095 static int prerm_deconfigure_conflictors_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *conflictors)
1096 {
1097      /* DPKG_INCOMPATIBILITY: dpkg does some things here that we don't
1098         do yet. Do we care?  (See prerm_deconfigure_conflictors for
1099         details) */
1100      return 0;
1101 }
1102
1103 static int preinst_configure(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1104 {
1105      int err;
1106      char *preinst_args;
1107
1108      if (old_pkg) {
1109           char *old_version = pkg_version_str_alloc(old_pkg);
1110           sprintf_alloc(&preinst_args, "upgrade %s", old_version);
1111           free(old_version);
1112      } else if (pkg->state_status == SS_CONFIG_FILES) {
1113           char *pkg_version = pkg_version_str_alloc(pkg);
1114           sprintf_alloc(&preinst_args, "install %s", pkg_version);
1115           free(pkg_version);
1116      } else {
1117           preinst_args = strdup("install");
1118      }
1119
1120      err = pkg_run_script(conf, pkg, "preinst", preinst_args);
1121      if (err) {
1122           opkg_message(conf, OPKG_ERROR,
1123                        "Aborting installation of %s\n", pkg->name);
1124           return 1;
1125      }
1126
1127      free(preinst_args);
1128
1129      return 0;
1130 }
1131
1132 static int preinst_configure_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1133 {
1134      /* DPKG_INCOMPATIBILITY:
1135         dpkg does the following error unwind, should we?
1136         pkg->postrm abort-upgrade old-version
1137         OR pkg->postrm abort-install old-version
1138         OR pkg->postrm abort-install
1139      */
1140      return 0;
1141 }
1142
1143 static int backup_modified_conffiles(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1144 {
1145      int err;
1146      conffile_list_elt_t *iter;
1147      conffile_t *cf;
1148
1149      if (conf->noaction) return 0;
1150
1151      /* Backup all modified conffiles */
1152      if (old_pkg) {
1153           for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
1154                char *cf_name;
1155
1156                cf = iter->data;
1157                cf_name = root_filename_alloc(conf, cf->name);
1158
1159                /* Don't worry if the conffile is just plain gone */
1160                if (file_exists(cf_name) && conffile_has_been_modified(conf, cf)) {
1161                     err = backup_make_backup(conf, cf_name);
1162                     if (err) {
1163                          return err;
1164                     }
1165                }
1166                free(cf_name);
1167           }
1168      }
1169
1170      /* Backup all conffiles that were not conffiles in old_pkg */
1171      for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
1172           char *cf_name;
1173           cf = (conffile_t *)iter->data;
1174           cf_name = root_filename_alloc(conf, cf->name);
1175           /* Ignore if this was a conffile in old_pkg as well */
1176           if (pkg_get_conffile(old_pkg, cf->name)) {
1177                continue;
1178           }
1179
1180           if (file_exists(cf_name) && (! backup_exists_for(cf_name))) {
1181                err = backup_make_backup(conf, cf_name);
1182                if (err) {
1183                     return err;
1184                }
1185           }
1186           free(cf_name);
1187      }
1188
1189      return 0;
1190 }
1191
1192 static int backup_modified_conffiles_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1193 {
1194      conffile_list_elt_t *iter;
1195
1196      if (old_pkg) {
1197           for (iter = nv_pair_list_first(&old_pkg->conffiles); iter; iter = nv_pair_list_next(&old_pkg->conffiles, iter)) {
1198                backup_remove(((nv_pair_t *)iter->data)->name);
1199           }
1200      }
1201
1202      for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
1203           backup_remove(((nv_pair_t *)iter->data)->name);
1204      }
1205
1206      return 0;
1207 }
1208
1209
1210 static int check_data_file_clashes(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1211 {
1212      /* DPKG_INCOMPATIBILITY:
1213         opkg takes a slightly different approach than dpkg at this
1214         point.  dpkg installs each file in the new package while
1215         creating a backup for any file that is replaced, (so that it
1216         can unwind if necessary).  To avoid complexity and redundant
1217         storage, opkg doesn't do any installation until later, (at the
1218         point at which dpkg removes the backups.
1219
1220         But, we do have to check for data file clashes, since after
1221         installing a package with a file clash, removing either of the
1222         packages involved in the clash has the potential to break the
1223         other package.
1224      */
1225      str_list_t *files_list;
1226      str_list_elt_t *iter, *niter;
1227
1228      int clashes = 0;
1229
1230      files_list = pkg_get_installed_files(pkg);
1231      for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
1232              iter;
1233              iter = niter, niter = str_list_next(files_list, iter)) {
1234           char *root_filename;
1235           char *filename = (char *) iter->data;
1236           root_filename = root_filename_alloc(conf, filename);
1237           if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
1238                pkg_t *owner;
1239                pkg_t *obs;
1240                /* Pre-existing conffiles are OK */
1241                /* @@@@ should have way to check that it is a conffile -Jamey */
1242                if (backup_exists_for(root_filename)) {
1243                     continue;
1244                }
1245
1246                /* Pre-existing files are OK if force-overwrite was asserted. */
1247                if (conf->force_overwrite) {
1248                     /* but we need to change who owns this file */
1249                     file_hash_set_file_owner(conf, filename, pkg);
1250                     continue;
1251                }
1252
1253                owner = file_hash_get_file_owner(conf, filename);
1254
1255                /* Pre-existing files are OK if owned by the pkg being upgraded. */
1256                if (owner && old_pkg) {
1257                     if (strcmp(owner->name, old_pkg->name) == 0) {
1258                          continue;
1259                     }
1260                }
1261
1262                /* Pre-existing files are OK if owned by a package replaced by new pkg. */
1263                if (owner) {
1264                     opkg_message(conf, OPKG_DEBUG2, "Checking for replaces for %s in package %s\n", filename, owner->name);
1265                     if (pkg_replaces(pkg, owner)) {
1266                          continue;
1267                     }
1268 /* If the file that would be installed is owned by the same package, ( as per a reinstall or similar )
1269    then it's ok to overwrite. */
1270                     if (strcmp(owner->name,pkg->name)==0){
1271                          opkg_message(conf, OPKG_INFO, "Replacing pre-existing file %s owned by package %s\n", filename, owner->name);
1272                          continue;
1273                     }
1274                }
1275
1276                /* Pre-existing files are OK if they are obsolete */
1277                obs = hash_table_get(&conf->obs_file_hash, filename);
1278                if (obs) {
1279                     opkg_message(conf, OPKG_INFO, "Pre-exiting file %s is obsolete.  obs_pkg=%s\n", filename, obs->name);
1280                     continue;
1281                }
1282
1283                /* We have found a clash. */
1284                opkg_message(conf, OPKG_ERROR,
1285                             "Package %s wants to install file %s\n"
1286                             "\tBut that file is already provided by package ",
1287                             pkg->name, filename);
1288                if (owner) {
1289                     opkg_message(conf, OPKG_ERROR,
1290                                  "%s\n", owner->name);
1291                } else {
1292                     opkg_message(conf, OPKG_ERROR,
1293                                  "<no package>\nPlease move this file out of the way and try again.\n");
1294                }
1295                clashes++;
1296           }
1297           free(root_filename);
1298      }
1299      pkg_free_installed_files(pkg);
1300
1301      return clashes;
1302 }
1303
1304 static int check_data_file_clashes_change(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1305 {
1306     /* Basically that's the worst hack I could do to be able to change ownership of
1307        file list, but, being that we have no way to unwind the mods, due to structure
1308        of hash table, probably is the quickest hack too, whishing it would not slow-up thing too much.
1309        What we do here is change the ownership of file in hash if a replace ( or similar events
1310        happens )
1311        Only the action that are needed to change name should be considered.
1312        @@@ To change after 1.0 release.
1313      */
1314      str_list_t *files_list;
1315      str_list_elt_t *iter, *niter;
1316
1317      char *root_filename = NULL;
1318
1319      int clashes = 0;
1320
1321      files_list = pkg_get_installed_files(pkg);
1322      for (iter = str_list_first(files_list), niter = str_list_next(files_list, iter);
1323              iter;
1324              iter = niter, niter = str_list_next(files_list, niter)) {
1325           char *filename = (char *) iter->data;
1326           if (root_filename) {
1327               free(root_filename);
1328               root_filename = NULL;
1329           }
1330           root_filename = root_filename_alloc(conf, filename);
1331           if (file_exists(root_filename) && (! file_is_dir(root_filename))) {
1332                pkg_t *owner;
1333
1334                owner = file_hash_get_file_owner(conf, filename);
1335
1336                if (conf->force_overwrite) {
1337                     /* but we need to change who owns this file */
1338                     file_hash_set_file_owner(conf, filename, pkg);
1339                     continue;
1340                }
1341
1342
1343                /* Pre-existing files are OK if owned by a package replaced by new pkg. */
1344                if (owner) {
1345                     if (pkg_replaces(pkg, owner)) {
1346 /* It's now time to change the owner of that file.
1347    It has been "replaced" from the new "Replaces", then I need to inform lists file about that.  */
1348                          opkg_message(conf, OPKG_INFO, "Replacing pre-existing file %s owned by package %s\n", filename, owner->name);
1349                          file_hash_set_file_owner(conf, filename, pkg);
1350                          continue;
1351                     }
1352                }
1353
1354           }
1355      }
1356      if (root_filename) {
1357          free(root_filename);
1358          root_filename = NULL;
1359      }
1360      pkg_free_installed_files(pkg);
1361
1362      return clashes;
1363 }
1364
1365 static int check_data_file_clashes_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1366 {
1367      /* Nothing to do since check_data_file_clashes doesn't change state */
1368      return 0;
1369 }
1370
1371 static int postrm_upgrade_old_pkg(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1372 {
1373      /* DPKG_INCOMPATIBILITY: dpkg does the following here, should we?
1374         1. If the package is being upgraded, call
1375            old-postrm upgrade new-version
1376         2. If this fails, attempt:
1377            new-postrm failed-upgrade old-version
1378         Error unwind, for both cases:
1379            old-preinst abort-upgrade new-version    */
1380      return 0;
1381 }
1382
1383 static int postrm_upgrade_old_pkg_unwind(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1384 {
1385      /* DPKG_INCOMPATIBILITY:
1386         dpkg does some things here that we don't do yet. Do we care?
1387         (See postrm_upgrade_old_pkg for details)
1388      */
1389     return 0;
1390 }
1391
1392 static int remove_obsolesced_files(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1393 {
1394      int err;
1395      str_list_t *old_files;
1396      str_list_elt_t *of;
1397      str_list_t *new_files;
1398      str_list_elt_t *nf;
1399      hash_table_t new_files_table;
1400
1401      if (old_pkg == NULL) {
1402           return 0;
1403      }
1404
1405      old_files = pkg_get_installed_files(old_pkg);
1406      new_files = pkg_get_installed_files(pkg);
1407
1408      new_files_table.entries = NULL;
1409      hash_table_init("new_files" , &new_files_table, 20);
1410      for (nf = str_list_first(new_files); nf; nf = str_list_next(new_files, nf)) {
1411          if (nf && nf->data)
1412             hash_table_insert(&new_files_table, nf->data, nf->data);
1413      }
1414
1415      for (of = str_list_first(old_files); of; of = str_list_next(old_files, of)) {
1416           pkg_t *owner;
1417           char *old, *new;
1418           old = (char *)of->data;
1419           new = (char *) hash_table_get (&new_files_table, old);
1420           if (new)
1421                continue;
1422
1423           if (file_is_dir(old)) {
1424                continue;
1425           }
1426           owner = file_hash_get_file_owner(conf, old);
1427           if (owner != old_pkg) {
1428                /* in case obsolete file no longer belongs to old_pkg */
1429                continue;
1430           }
1431
1432           /* old file is obsolete */
1433           opkg_message(conf, OPKG_INFO,
1434                        "    removing obsolete file %s\n", old);
1435           if (!conf->noaction) {
1436                err = unlink(old);
1437                if (err) {
1438                     opkg_message(conf, OPKG_ERROR, "    Warning: remove %s failed: %s\n", old,
1439                                  strerror(errno));
1440                }
1441           }
1442      }
1443
1444      hash_table_deinit(&new_files_table);
1445      pkg_free_installed_files(old_pkg);
1446      pkg_free_installed_files(pkg);
1447
1448      return 0;
1449 }
1450
1451 static int remove_obsolete_maintainer_scripts(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1452 {
1453      int i;
1454      int err = 0;
1455      char *globpattern;
1456      glob_t globbuf;
1457      if (0) {
1458           if (!pkg->dest) {
1459                opkg_message(conf, OPKG_ERROR, "%s: no dest for package %s\n", __FUNCTION__, pkg->name);
1460                return -1;
1461           }
1462           sprintf_alloc(&globpattern, "%s/%s.*", pkg->dest->info_dir, pkg->name);
1463           err = glob(globpattern, 0, NULL, &globbuf);
1464           free(globpattern);
1465           if (err) {
1466                return err;
1467           }
1468           /* XXXX this should perhaps only remove the ones that are not overwritten in new package.  Jamey 11/11/2003 */
1469           for (i = 0; i < globbuf.gl_pathc; i++) {
1470                opkg_message(conf, OPKG_DEBUG, "Removing control file %s from old_pkg %s\n",
1471                             globbuf.gl_pathv[i], old_pkg->name);
1472                if (!conf->noaction)
1473                     unlink(globbuf.gl_pathv[i]);
1474           }
1475           globfree(&globbuf);
1476      }
1477      return err;
1478 }
1479
1480 static int install_maintainer_scripts(opkg_conf_t *conf, pkg_t *pkg, pkg_t *old_pkg)
1481 {
1482      int ret;
1483      char *prefix;
1484
1485      if (old_pkg)
1486           remove_obsolete_maintainer_scripts(conf, pkg, old_pkg);
1487      sprintf_alloc(&prefix, "%s.", pkg->name);
1488      ret = pkg_extract_control_files_to_dir_with_prefix(pkg,
1489                                                         pkg->dest->info_dir,
1490                                                         prefix);
1491      free(prefix);
1492      return ret;
1493 }
1494
1495 static int remove_disappeared(opkg_conf_t *conf, pkg_t *pkg)
1496 {
1497      /* DPKG_INCOMPATIBILITY:
1498         This is a fairly sophisticated dpkg operation. Shall we
1499         skip it? */
1500
1501      /* Any packages all of whose files have been overwritten during the
1502         installation, and which aren't required for dependencies, are
1503         considered to have been removed. For each such package
1504         1. disappearer's-postrm disappear overwriter overwriter-version
1505         2. The package's maintainer scripts are removed
1506         3. It is noted in the status database as being in a sane state,
1507            namely not installed (any conffiles it may have are ignored,
1508            rather than being removed by dpkg). Note that disappearing
1509            packages do not have their prerm called, because dpkg doesn't
1510            know in advance that the package is going to vanish.
1511      */
1512      return 0;
1513 }
1514
1515 static int install_data_files(opkg_conf_t *conf, pkg_t *pkg)
1516 {
1517      int err;
1518
1519      /* opkg takes a slightly different approach to data file backups
1520         than dpkg. Rather than removing backups at this point, we
1521         actually do the data file installation now. See comments in
1522         check_data_file_clashes() for more details. */
1523
1524      opkg_message(conf, OPKG_INFO,
1525                   "    extracting data files to %s\n", pkg->dest->root_dir);
1526      err = pkg_extract_data_files_to_dir(pkg, pkg->dest->root_dir);
1527      if (err) {
1528           return err;
1529      }
1530
1531      /* XXX: BUG or FEATURE : We are actually loosing the Essential flag,
1532         so we can't save ourself from removing important packages
1533         At this point we (should) have extracted the .control file, so it
1534         would be a good idea to reload the data in it, and set the Essential
1535         state in *pkg. From now on the Essential is back in status file and
1536         we can protect again.
1537         We should operate this way:
1538         fopen the file ( pkg->dest->root_dir/pkg->name.control )
1539         check for "Essential" in it
1540         set the value in pkg->essential.
1541         This new routine could be useful also for every other flag
1542         Pigi: 16/03/2004 */
1543      set_flags_from_control(conf, pkg) ;
1544
1545      opkg_message(conf, OPKG_DEBUG, "    Calling pkg_write_filelist from %s\n", __FUNCTION__);
1546      err = pkg_write_filelist(conf, pkg);
1547      if (err)
1548           return err;
1549
1550      /* XXX: FEATURE: opkg should identify any files which existed
1551         before installation and which were overwritten, (see
1552         check_data_file_clashes()). What it must do is remove any such
1553         files from the filelist of the old package which provided the
1554         file. Otherwise, if the old package were removed at some point
1555         it would break the new package. Removing the new package will
1556         also break the old one, but this cannot be helped since the old
1557         package's file has already been deleted. This is the importance
1558         of check_data_file_clashes(), and only allowing opkg to install
1559         a clashing package with a user force. */
1560
1561      return 0;
1562 }
1563
1564 static int resolve_conffiles(opkg_conf_t *conf, pkg_t *pkg)
1565 {
1566      conffile_list_elt_t *iter;
1567      conffile_t *cf;
1568      char *cf_backup;
1569
1570     char *md5sum;
1571
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 (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(cf->name, cf_backup) ) {
1601                       rename(cf_backup, root_filename);
1602                   }
1603               }
1604               unlink(cf_backup);
1605               free(md5sum);
1606           }
1607
1608           free(cf_backup);
1609           free(root_filename);
1610      }
1611
1612      return 0;
1613 }
1614
1615 static int user_prefers_old_conffile(const char *file_name, const char *backup)
1616 {
1617      char *response;
1618      const char *short_file_name;
1619
1620      short_file_name = strrchr(file_name, '/');
1621      if (short_file_name) {
1622           short_file_name++;
1623      } else {
1624           short_file_name = file_name;
1625      }
1626
1627      while (1) {
1628           response = get_user_response("    Configuration file '%s'\n"
1629                                        "    ==> File on system created by you or by a script.\n"
1630                                        "    ==> File also in package provided by package maintainer.\n"
1631                                        "       What would you like to do about it ?  Your options are:\n"
1632                                        "        Y or I  : install the package maintainer's version\n"
1633                                        "        N or O  : keep your currently-installed version\n"
1634                                        "          D     : show the differences between the versions (if diff is installed)\n"
1635                                        "     The default action is to keep your current version.\n"
1636                                        "    *** %s (Y/I/N/O/D) [default=N] ? ", file_name, short_file_name);
1637           if (strcmp(response, "y") == 0
1638               || strcmp(response, "i") == 0
1639               || strcmp(response, "yes") == 0) {
1640                free(response);
1641                return 0;
1642           }
1643
1644           if (strcmp(response, "d") == 0) {
1645                char *cmd;
1646
1647                free(response);
1648                /* XXX: BUG rewrite to use exec or busybox's internal diff */
1649                sprintf_alloc(&cmd, "diff -u %s %s", backup, file_name);
1650                xsystem(cmd);
1651                free(cmd);
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 /* XXX: CLEANUP: I'd like to move all of the code for
1664    creating/cleaning pkg->tmp_unpack_dir directly into pkg.c. (Then,
1665    it would make sense to cleanup pkg->tmp_unpack_dir directly from
1666    pkg_deinit for example). */
1667 static int cleanup_temporary_files(opkg_conf_t *conf, pkg_t *pkg)
1668 {
1669      DIR *tmp_dir;
1670      struct dirent *dirent;
1671      char *tmp_file;
1672
1673 #ifdef OPKG_DEBUG_NO_TMP_CLEANUP
1674 #error
1675      opkg_message(conf, OPKG_DEBUG,
1676                   "%s: Not cleaning up %s since opkg compiled with OPKG_DEBUG_NO_TMP_CLEANUP\n",
1677                   __FUNCTION__, pkg->tmp_unpack_dir);
1678      return 0;
1679 #endif
1680
1681      if (pkg->tmp_unpack_dir && file_is_dir(pkg->tmp_unpack_dir)) {
1682           tmp_dir = opendir(pkg->tmp_unpack_dir);
1683           if (tmp_dir) {
1684                while (1) {
1685                     dirent = readdir(tmp_dir);
1686                     if (dirent == NULL) {
1687                          break;
1688                     }
1689                     sprintf_alloc(&tmp_file, "%s/%s",
1690                                   pkg->tmp_unpack_dir, dirent->d_name);
1691                     if (! file_is_dir(tmp_file)) {
1692                          unlink(tmp_file);
1693                     }
1694                     free(tmp_file);
1695                }
1696                closedir(tmp_dir);
1697                rmdir(pkg->tmp_unpack_dir);
1698                free(pkg->tmp_unpack_dir);
1699                pkg->tmp_unpack_dir = NULL;
1700           }
1701      }
1702
1703      opkg_message(conf, OPKG_INFO, "cleanup_temporary_files: pkg=%s local_filename=%s tmp_dir=%s\n",
1704                   pkg->name, pkg->local_filename, conf->tmp_dir);
1705      if (pkg->local_filename && strncmp(pkg->local_filename, conf->tmp_dir, strlen(conf->tmp_dir)) == 0) {
1706           unlink(pkg->local_filename);
1707           free(pkg->local_filename);
1708           pkg->local_filename = NULL;
1709      }
1710
1711      return 0;
1712 }
1713
1714 static char *backup_filename_alloc(const char *file_name)
1715 {
1716      char *backup;
1717
1718      sprintf_alloc(&backup, "%s%s", file_name, OPKG_BACKUP_SUFFIX);
1719
1720      return backup;
1721 }
1722
1723 int backup_make_backup(opkg_conf_t *conf, const char *file_name)
1724 {
1725      int err;
1726      char *backup;
1727
1728      backup = backup_filename_alloc(file_name);
1729      err = file_copy(file_name, backup);
1730      if (err) {
1731           opkg_message(conf, OPKG_ERROR,
1732                        "%s: Failed to copy %s to %s\n",
1733                        __FUNCTION__, file_name, backup);
1734      }
1735
1736      free(backup);
1737
1738      return err;
1739 }
1740
1741 static int backup_exists_for(const char *file_name)
1742 {
1743      int ret;
1744      char *backup;
1745
1746      backup = backup_filename_alloc(file_name);
1747
1748      ret = file_exists(backup);
1749
1750      free(backup);
1751
1752      return ret;
1753 }
1754
1755 static int backup_remove(const char *file_name)
1756 {
1757      char *backup;
1758
1759      backup = backup_filename_alloc(file_name);
1760      unlink(backup);
1761      free(backup);
1762
1763      return 0;
1764 }
1765