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