libopkg/opkg_remove.c

   1 /* opkg_remove.c - the itsy 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 "opkg.h"
  19 #include "opkg_message.h"
  20
  21 #include <glob.h>
  22
  23 #include "opkg_remove.h"
  24
  25 #include "file_util.h"
  26 #include "sprintf_alloc.h"
  27 #include "str_util.h"
  28
  29 #include "opkg_cmd.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         printf ("%s was autoinstalled but is now orphaned\n", buffer);
 208          opkg_remove_pkg(conf, p,0);
 209       }
 210         else
 211            printf ("%s was autoinstalled and is still required by %d installed packages\n", buffer, deps);
 212     }
 213     free (buffer);
 214   }
 215
 216   return 0;
 217 }
 218
 219 int opkg_remove_pkg(opkg_conf_t *conf, pkg_t *pkg,int message)
 220 {
 221 /* Actually, when "message == 1" I have been called from an upgrade, and not from a normal remove
 222    thus I wan't check for essential, as I'm upgrading.
 223    I hope it won't break anything :)
 224 */
 225      int err;
 226      abstract_pkg_t *parent_pkg = NULL;
 227
 228      if (pkg->essential && !message) {
 229           if (conf->force_removal_of_essential_packages) {
 230                fprintf(stderr, "WARNING: Removing essential package %s under your coercion.\n"
 231                        "\tIf your system breaks, you get to keep both pieces\n",
 232                        pkg->name);
 233           } else {
 234                fprintf(stderr, "ERROR: Refusing to remove essential package %s.\n"
 235                        "\tRemoving an essential package may lead to an unusable system, but if\n"
 236                        "\tyou enjoy that kind of pain, you can force opkg to proceed against\n"
 237                        "\tits will with the option: -force-removal-of-essential-packages\n",
 238                        pkg->name);
 239                return OPKG_PKG_IS_ESSENTIAL;
 240           }
 241      }
 242
 243      if ((parent_pkg = pkg->parent) == NULL)
 244           return 0;
 245
 246      /* only attempt to remove dependent installed packages if
 247       * force_depends is not specified or the package is being
 248       * replaced.
 249       */
 250      if (!conf->force_depends
 251          && !(pkg->state_flag & SF_REPLACE)) {
 252           abstract_pkg_t **dependents;
 253           int has_installed_dependents =
 254                pkg_has_installed_dependents(conf, parent_pkg, pkg, &dependents);
 255
 256           if (has_installed_dependents) {
 257                /*
 258                 * if this package is depended up by others, then either we should
 259                 * not remove it or we should remove it and all of its dependents
 260                 */
 261
 262                if (!conf->force_removal_of_dependent_packages
 263                    && !user_prefers_removing_dependents(conf, parent_pkg, pkg, dependents)) {
 264                     return OPKG_PKG_HAS_DEPENDENTS;
 265                }
 266
 267                /* remove packages depending on this package - Karthik */
 268                err = opkg_remove_dependent_pkgs (conf, pkg, dependents);
 269                free(dependents);
 270                if (err) return err;
 271           }
 272      }
 273
 274      if ( message==0 ){
 275          printf("Removing package %s from %s...\n", pkg->name, pkg->dest->name);
 276          fflush(stdout);
 277      }
 278      pkg->state_flag |= SF_FILELIST_CHANGED;
 279
 280      pkg->state_want = SW_DEINSTALL;
 281      opkg_state_changed++;
 282
 283      pkg_run_script(conf, pkg, "prerm", "remove");
 284
 285      /* DPKG_INCOMPATIBILITY: dpkg is slightly different here. It
 286         maintains an empty filelist rather than deleting it. That seems
 287         like a big pain, and I don't see that that should make a big
 288         difference, but for anyone who wants tighter compatibility,
 289         feel free to fix this. */
 290      remove_data_files_and_list(conf, pkg);
 291
 292      pkg_run_script(conf, pkg, "postrm", "remove");
 293
 294      remove_maintainer_scripts_except_postrm(conf, pkg);
 295
 296      /* Aman Gupta - Since opkg is made for handheld devices with limited
 297       * space, it doesn't make sense to leave extra configurations, files,
 298       * and maintainer scripts left around. So, we make remove like purge,
 299       * and take out all the crap :) */
 300
 301      remove_postrm(conf, pkg);
 302      pkg->state_status = SS_NOT_INSTALLED;
 303
 304      if (parent_pkg)
 305           parent_pkg->state_status = SS_NOT_INSTALLED;
 306
 307
 308      /* remove autoinstalled packages that are orphaned by the removal of this one */
 309      if (conf->autoremove)
 310        remove_autoinstalled (conf, pkg);
 311
 312
 313
 314      return 0;
 315 }
 316
 317 int opkg_purge_pkg(opkg_conf_t *conf, pkg_t *pkg)
 318 {
 319     opkg_remove_pkg(conf, pkg,0);
 320     return 0;
 321 }
 322
 323 int remove_data_files_and_list(opkg_conf_t *conf, pkg_t *pkg)
 324 {
 325      str_list_t installed_dirs;
 326      str_list_t *installed_files;
 327      str_list_elt_t *iter;
 328      char *file_name;
 329      conffile_t *conffile;
 330      int removed_a_dir;
 331      pkg_t *owner;
 332
 333      str_list_init(&installed_dirs);
 334      installed_files = pkg_get_installed_files(pkg);
 335
 336      for (iter = installed_files->head; iter; iter = iter->next) {
 337           file_name = iter->data;
 338
 339           if (file_is_dir(file_name)) {
 340                str_list_append(&installed_dirs, strdup(file_name));
 341                continue;
 342           }
 343
 344           conffile = pkg_get_conffile(pkg, file_name);
 345           if (conffile) {
 346                /* XXX: QUESTION: Is this right? I figure we only need to
 347                   save the conffile if it has been modified. Is that what
 348                   dpkg does? Or does dpkg preserve all conffiles? If so,
 349                   this seems like a better thing to do to conserve
 350                   space. */
 351                if (conffile_has_been_modified(conf, conffile)) {
 352                     printf("  not deleting modified conffile %s\n", file_name);
 353                     fflush(stdout);
 354                     continue;
 355                }
 356           }
 357
 358           opkg_message(conf, OPKG_INFO, "  deleting %s (noaction=%d)\n", file_name, conf->noaction);
 359           if (!conf->noaction)
 360                unlink(file_name);
 361      }
 362
 363      if (!conf->noaction) {
 364           do {
 365                removed_a_dir = 0;
 366                for (iter = installed_dirs.head; iter; iter = iter->next) {
 367                     file_name = iter->data;
 368
 369                     if (rmdir(file_name) == 0) {
 370                          opkg_message(conf, OPKG_INFO, "  deleting %s\n", file_name);
 371                          removed_a_dir = 1;
 372                          str_list_remove(&installed_dirs, &iter);
 373                     }
 374                }
 375           } while (removed_a_dir);
 376      }
 377
 378      pkg_free_installed_files(pkg);
 379      /* We have to remove the file list now, so that
 380         find_pkg_owning_file does not always just report this package */
 381      pkg_remove_installed_files_list(conf, pkg);
 382
 383      /* Don't print warning for dirs that are provided by other packages */
 384      for (iter = installed_dirs.head; iter; iter = iter->next) {
 385           file_name = iter->data;
 386
 387           owner = file_hash_get_file_owner(conf, file_name);
 388           if (owner) {
 389                free(iter->data);
 390                iter->data = NULL;
 391                str_list_remove(&installed_dirs, &iter);
 392           }
 393      }
 394
 395      /* cleanup */
 396      for (iter = installed_dirs.head; iter; iter = iter->next) {
 397           free(iter->data);
 398           iter->data = NULL;
 399      }
 400      str_list_deinit(&installed_dirs);
 401
 402      return 0;
 403 }
 404
 405 int remove_maintainer_scripts_except_postrm(opkg_conf_t *conf, pkg_t *pkg)
 406 {
 407     int i, err;
 408     char *globpattern;
 409     glob_t globbuf;
 410
 411     if (conf->noaction) return 0;
 412
 413     sprintf_alloc(&globpattern, "%s/%s.*",
 414                   pkg->dest->info_dir, pkg->name);
 415     err = glob(globpattern, 0, NULL, &globbuf);
 416     free(globpattern);
 417     if (err) {
 418         return 0;
 419     }
 420
 421     for (i = 0; i < globbuf.gl_pathc; i++) {
 422         if (str_ends_with(globbuf.gl_pathv[i], ".postrm")) {
 423             continue;
 424         }
 425         opkg_message(conf, OPKG_INFO, "  deleting %s\n", globbuf.gl_pathv[i]);
 426         unlink(globbuf.gl_pathv[i]);
 427     }
 428     globfree(&globbuf);
 429
 430     return 0;
 431 }
 432
 433 int remove_postrm(opkg_conf_t *conf, pkg_t *pkg)
 434 {
 435     char *postrm_file_name;
 436
 437     if (conf->noaction) return 0;
 438
 439     sprintf_alloc(&postrm_file_name, "%s/%s.postrm",
 440                   pkg->dest->info_dir, pkg->name);
 441     unlink(postrm_file_name);
 442     free(postrm_file_name);
 443
 444     return 0;
 445 }