libopkg/opkg_install.c

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