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