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