libopkg/opkg_remove.c

   1 /* opkg_remove.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 "opkg_message.h"
  20
  21 #include <glob.h>
  22
  23 #include "opkg_remove.h"
  24 #include "opkg_error.h"
  25 #include "opkg_state.h"
  26
  27 #include "file_util.h"
  28 #include "sprintf_alloc.h"
  29 #include "str_util.h"
  30
  31 /*
  32  * Returns number of the number of packages depending on the packages provided by this package.
  33  * Every package implicitly provides itself.
  34  */
  35 int pkg_has_installed_dependents(opkg_conf_t *conf, abstract_pkg_t *parent_apkg, pkg_t *pkg, abstract_pkg_t *** pdependents)
  36 {
  37      int nprovides = pkg->provides_count;
  38      abstract_pkg_t **provides = pkg->provides;
  39      int n_installed_dependents = 0;
  40      int i;
  41      for (i = 0; i <= nprovides; i++) {
  42           abstract_pkg_t *providee = provides[i];
  43           abstract_pkg_t **dependers = providee->depended_upon_by;
  44           abstract_pkg_t *dep_ab_pkg;
  45           if (dependers == NULL)
  46                continue;
  47           while ((dep_ab_pkg = *dependers++) != NULL) {
  48                if (dep_ab_pkg->state_status == SS_INSTALLED){
  49                     n_installed_dependents++;
  50                }
  51           }
  52
  53      }
  54      /* if caller requested the set of installed dependents */
  55      if (pdependents) {
  56           int p = 0;
  57           abstract_pkg_t **dependents = (abstract_pkg_t **)malloc((n_installed_dependents+1)*sizeof(abstract_pkg_t *));
  58
  59           if ( dependents == NULL ){
  60               fprintf(stderr,"%s Unable to allocate memory. REPORT THIS BUG IN BUGZILLA PLEASE\n", __FUNCTION__);
  61               return -1;
  62           }
  63
  64           *pdependents = dependents;
  65           for (i = 0; i <= nprovides; i++) {
  66                abstract_pkg_t *providee = provides[i];
  67                abstract_pkg_t **dependers = providee->depended_upon_by;
  68                abstract_pkg_t *dep_ab_pkg;
  69                if (dependers == NULL)
  70                     continue;
  71                while ((dep_ab_pkg = *dependers++) != NULL) {
  72                     if (dep_ab_pkg->state_status == SS_INSTALLED && !(dep_ab_pkg->state_flag & SF_MARKED)) {
  73                          dependents[p++] = dep_ab_pkg;
  74                          dep_ab_pkg->state_flag |= SF_MARKED;
  75                     }
  76                }
  77           }
  78           dependents[p] = NULL;
  79           /* now clear the marks */
  80           for (i = 0; i < p; i++) {
  81                abstract_pkg_t *dep_ab_pkg = dependents[i];
  82                dep_ab_pkg->state_flag &= ~SF_MARKED;
  83           }
  84      }
  85      return n_installed_dependents;
  86 }
  87
  88 int opkg_remove_dependent_pkgs (opkg_conf_t *conf, pkg_t *pkg, abstract_pkg_t **dependents)
  89 {
  90     int i;
  91     int a;
  92     int count;
  93     pkg_vec_t *dependent_pkgs = pkg_vec_alloc();
  94     abstract_pkg_t * ab_pkg;
  95
  96     if((ab_pkg = pkg->parent) == NULL){
  97         fprintf(stderr, "%s: unable to get dependent pkgs. pkg %s isn't in hash table\n",
  98                 __FUNCTION__, pkg->name);
  99         return 0;
 100     }
 101
 102     if (dependents == NULL)
 103             return 0;
 104
 105     // here i am using the dependencies_checked
 106     if (ab_pkg->dependencies_checked == 2) // variable to make out whether this package
 107         return 0;                          // has already been encountered in the process
 108                                            // of marking packages for removal - Karthik
 109     ab_pkg->dependencies_checked = 2;
 110
 111     i = 0;
 112     count = 1;
 113     while (dependents [i] != NULL) {
 114         abstract_pkg_t *dep_ab_pkg = dependents[i];
 115
 116         if (dep_ab_pkg->dependencies_checked == 2){
 117             i++;
 118             continue;
 119         }
 120         if (dep_ab_pkg->state_status == SS_INSTALLED) {
 121             for (a = 0; a < dep_ab_pkg->pkgs->len; a++) {
 122                 pkg_t *dep_pkg = dep_ab_pkg->pkgs->pkgs[a];
 123                 if (dep_pkg->state_status == SS_INSTALLED) {
 124                     pkg_vec_insert(dependent_pkgs, dep_pkg);
 125                     count++;
 126                 }
 127             }
 128         }
 129         i++;
 130         /* 1 - to keep track of visited ab_pkgs when checking for possiblility of a broken removal of pkgs.
 131          * 2 - to keep track of pkgs whose deps have been checked alrdy  - Karthik */
 132     }
 133
 134     if (count == 1)
 135             return 0;
 136
 137
 138     for (i = 0; i < dependent_pkgs->len; i++) {
 139         int err = opkg_remove_pkg(conf, dependent_pkgs->pkgs[i],0);
 140         if (err)
 141             return err;
 142     }
 143     return 0;
 144 }
 145
 146 static int user_prefers_removing_dependents(opkg_conf_t *conf, abstract_pkg_t *abpkg, pkg_t *pkg, abstract_pkg_t **dependents)
 147 {
 148     abstract_pkg_t *dep_ab_pkg;
 149     opkg_message(conf, OPKG_ERROR, "Package %s is depended upon by packages:\n", pkg->name);
 150     while ((dep_ab_pkg = *dependents++) != NULL) {
 151          if (dep_ab_pkg->state_status == SS_INSTALLED)
 152               opkg_message(conf, OPKG_ERROR, "\t%s\n", dep_ab_pkg->name);
 153     }
 154     opkg_message(conf, OPKG_ERROR, "These might cease to work if package %s is removed.\n\n", pkg->name);
 155     opkg_message(conf, OPKG_ERROR, "");
 156     opkg_message(conf, OPKG_ERROR, "You can force removal of this package with -force-depends.\n");
 157     opkg_message(conf, OPKG_ERROR, "You can force removal of this package and its dependents\n");
 158     opkg_message(conf, OPKG_ERROR, "with -force-removal-of-dependent-packages or -recursive\n");
 159     opkg_message(conf, OPKG_ERROR, "or by setting option force_removal_of_dependent_packages\n");
 160     opkg_message(conf, OPKG_ERROR, "in opkg.conf.\n");
 161     return 0;
 162 }
 163
 164 static int remove_autoinstalled (opkg_conf_t *conf, pkg_t *pkg)
 165 {
 166   /*
 167    * find and remove packages that were autoinstalled and are orphaned by the removal of pkg
 168    */
 169
 170   char *buffer, *d_str;
 171   int i;
 172
 173   for (i = 0; i < pkg->depends_count; ++i)
 174   {
 175     int x = 0;
 176     pkg_t *p;
 177     d_str = pkg->depends_str[i];
 178     buffer = malloc (strlen (d_str) + 1);
 179     if (!buffer)
 180     {
 181       fprintf(stderr,"%s Unable to allocate memory.\n", __FUNCTION__);
 182       return -1;
 183     }
 184
 185     while (d_str[x] != '\0' && d_str[x] != ' ')
 186     {
 187       buffer[x] = d_str[x];
 188       ++x;
 189     }
 190     buffer[x] = '\0';
 191     buffer = realloc (buffer, strlen (buffer) + 1);
 192     p = pkg_hash_fetch_installed_by_name (&conf->pkg_hash, buffer);
 193
 194     /* if the package is not installed, this could have been a circular
 195      * depenancy and the package has already been removed */
 196     if (!p)
 197       return -1;
 198
 199     if (p->auto_installed)
 200     {
 201       int deps;
 202       abstract_pkg_t **dependents;
 203
 204       deps = pkg_has_installed_dependents(conf, NULL, p, &dependents);
 205       if (deps == 0)
 206       {
 207          opkg_message (conf, OPKG_INFO,
 208                        "%s was autoinstalled but is now orphaned\n", buffer);
 209          opkg_remove_pkg(conf, p,0);
 210       }
 211         else
 212            opkg_message (conf, OPKG_INFO, "%s was autoinstalled and is still required by "
 213                          "%d installed packages\n", buffer, deps);
 214     }
 215     free (buffer);
 216   }
 217
 218   return 0;
 219 }
 220
 221 int opkg_remove_pkg(opkg_conf_t *conf, pkg_t *pkg,int message)
 222 {
 223 /* Actually, when "message == 1" I have been called from an upgrade, and not from a normal remove
 224    thus I wan't check for essential, as I'm upgrading.
 225    I hope it won't break anything :)
 226 */
 227      int err;
 228      abstract_pkg_t *parent_pkg = NULL;
 229
 230      if (pkg->essential && !message) {
 231           if (conf->force_removal_of_essential_packages) {
 232                fprintf(stderr, "WARNING: Removing essential package %s under your coercion.\n"
 233                        "\tIf your system breaks, you get to keep both pieces\n",
 234                        pkg->name);
 235           } else {
 236                fprintf(stderr, "ERROR: Refusing to remove essential package %s.\n"
 237                        "\tRemoving an essential package may lead to an unusable system, but if\n"
 238                        "\tyou enjoy that kind of pain, you can force opkg to proceed against\n"
 239                        "\tits will with the option: -force-removal-of-essential-packages\n",
 240                        pkg->name);
 241                return OPKG_PKG_IS_ESSENTIAL;
 242           }
 243      }
 244
 245      if ((parent_pkg = pkg->parent) == NULL)
 246           return 0;
 247
 248      /* only attempt to remove dependent installed packages if
 249       * force_depends is not specified or the package is being
 250       * replaced.
 251       */
 252      if (!conf->force_depends
 253          && !(pkg->state_flag & SF_REPLACE)) {
 254           abstract_pkg_t **dependents;
 255           int has_installed_dependents =
 256                pkg_has_installed_dependents(conf, parent_pkg, pkg, &dependents);
 257
 258           if (has_installed_dependents) {
 259                /*
 260                 * if this package is depended up by others, then either we should
 261                 * not remove it or we should remove it and all of its dependents
 262                 */
 263
 264                if (!conf->force_removal_of_dependent_packages
 265                    && !user_prefers_removing_dependents(conf, parent_pkg, pkg, dependents)) {
 266                     return OPKG_PKG_HAS_DEPENDENTS;
 267                }
 268
 269                /* remove packages depending on this package - Karthik */
 270                err = opkg_remove_dependent_pkgs (conf, pkg, dependents);
 271                free(dependents);
 272                if (err) return err;
 273           }
 274           if (dependents)
 275               free(dependents);
 276      }
 277
 278      if ( message==0 ){
 279          opkg_message (conf, OPKG_NOTICE,
 280                        "Removing package %s from %s...\n", pkg->name, pkg->dest->name);
 281          fflush(stdout);
 282      }
 283      pkg->state_flag |= SF_FILELIST_CHANGED;
 284
 285      pkg->state_want = SW_DEINSTALL;
 286      opkg_state_changed++;
 287
 288      pkg_run_script(conf, pkg, "prerm", "remove");
 289
 290      /* DPKG_INCOMPATIBILITY: dpkg is slightly different here. It
 291         maintains an empty filelist rather than deleting it. That seems
 292         like a big pain, and I don't see that that should make a big
 293         difference, but for anyone who wants tighter compatibility,
 294         feel free to fix this. */
 295      remove_data_files_and_list(conf, pkg);
 296
 297      pkg_run_script(conf, pkg, "postrm", "remove");
 298
 299      remove_maintainer_scripts_except_postrm(conf, pkg);
 300
 301      /* Aman Gupta - Since opkg is made for handheld devices with limited
 302       * space, it doesn't make sense to leave extra configurations, files,
 303       * and maintainer scripts left around. So, we make remove like purge,
 304       * and take out all the crap :) */
 305
 306      remove_postrm(conf, pkg);
 307      pkg->state_status = SS_NOT_INSTALLED;
 308
 309      if (parent_pkg)
 310           parent_pkg->state_status = SS_NOT_INSTALLED;
 311
 312
 313      /* remove autoinstalled packages that are orphaned by the removal of this one */
 314      if (conf->autoremove)
 315        remove_autoinstalled (conf, pkg);
 316
 317
 318
 319      return 0;
 320 }
 321
 322 int opkg_purge_pkg(opkg_conf_t *conf, pkg_t *pkg)
 323 {
 324     opkg_remove_pkg(conf, pkg,0);
 325     return 0;
 326 }
 327
 328 int remove_data_files_and_list(opkg_conf_t *conf, pkg_t *pkg)
 329 {
 330      str_list_t installed_dirs;
 331      str_list_t *installed_files;
 332      str_list_elt_t *iter;
 333      char *file_name;
 334      conffile_t *conffile;
 335      int removed_a_dir;
 336      pkg_t *owner;
 337
 338      str_list_init(&installed_dirs);
 339      installed_files = pkg_get_installed_files(pkg);
 340
 341      for (iter = installed_files->head; iter; iter = iter->next) {
 342           file_name = iter->data;
 343
 344           if (file_is_dir(file_name)) {
 345                str_list_append(&installed_dirs, strdup(file_name));
 346                continue;
 347           }
 348
 349           conffile = pkg_get_conffile(pkg, file_name);
 350           if (conffile) {
 351                /* XXX: QUESTION: Is this right? I figure we only need to
 352                   save the conffile if it has been modified. Is that what
 353                   dpkg does? Or does dpkg preserve all conffiles? If so,
 354                   this seems like a better thing to do to conserve
 355                   space. */
 356                if (conffile_has_been_modified(conf, conffile)) {
 357                     opkg_message (conf, OPKG_NOTICE,
 358                                   "  not deleting modified conffile %s\n", file_name);
 359                     fflush(stdout);
 360                     continue;
 361                }
 362           }
 363
 364           opkg_message(conf, OPKG_INFO, "  deleting %s (noaction=%d)\n", file_name, conf->noaction);
 365           if (!conf->noaction)
 366                unlink(file_name);
 367      }
 368
 369      if (!conf->noaction) {
 370           do {
 371                removed_a_dir = 0;
 372                for (iter = installed_dirs.head; iter; iter = iter->next) {
 373                     file_name = iter->data;
 374
 375                     if (rmdir(file_name) == 0) {
 376                          opkg_message(conf, OPKG_INFO, "  deleting %s\n", file_name);
 377                          removed_a_dir = 1;
 378                          str_list_remove(&installed_dirs, &iter);
 379                     }
 380                }
 381           } while (removed_a_dir);
 382      }
 383
 384      pkg_free_installed_files(pkg);
 385      /* We have to remove the file list now, so that
 386         find_pkg_owning_file does not always just report this package */
 387      pkg_remove_installed_files_list(conf, pkg);
 388
 389      /* Don't print warning for dirs that are provided by other packages */
 390      for (iter = installed_dirs.head; iter; iter = iter->next) {
 391           file_name = iter->data;
 392
 393           owner = file_hash_get_file_owner(conf, file_name);
 394           if (owner) {
 395                free(iter->data);
 396                iter->data = NULL;
 397                str_list_remove(&installed_dirs, &iter);
 398           }
 399      }
 400
 401      /* cleanup */
 402      for (iter = installed_dirs.head; iter; iter = iter->next) {
 403           free(iter->data);
 404           iter->data = NULL;
 405      }
 406      str_list_deinit(&installed_dirs);
 407
 408      return 0;
 409 }
 410
 411 int remove_maintainer_scripts_except_postrm(opkg_conf_t *conf, pkg_t *pkg)
 412 {
 413     int i, err;
 414     char *globpattern;
 415     glob_t globbuf;
 416
 417     if (conf->noaction) return 0;
 418
 419     sprintf_alloc(&globpattern, "%s/%s.*",
 420                   pkg->dest->info_dir, pkg->name);
 421     err = glob(globpattern, 0, NULL, &globbuf);
 422     free(globpattern);
 423     if (err) {
 424         return 0;
 425     }
 426
 427     for (i = 0; i < globbuf.gl_pathc; i++) {
 428         if (str_ends_with(globbuf.gl_pathv[i], ".postrm")) {
 429             continue;
 430         }
 431         opkg_message(conf, OPKG_INFO, "  deleting %s\n", globbuf.gl_pathv[i]);
 432         unlink(globbuf.gl_pathv[i]);
 433     }
 434     globfree(&globbuf);
 435
 436     return 0;
 437 }
 438
 439 int remove_postrm(opkg_conf_t *conf, pkg_t *pkg)
 440 {
 441     char *postrm_file_name;
 442
 443     if (conf->noaction) return 0;
 444
 445     sprintf_alloc(&postrm_file_name, "%s/%s.postrm",
 446                   pkg->dest->info_dir, pkg->name);
 447     unlink(postrm_file_name);
 448     free(postrm_file_name);
 449
 450     return 0;
 451 }