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_cmd.h"
  26
  27 #include "file_util.h"
  28 #include "sprintf_alloc.h"
  29 #include "str_util.h"
  30 #include "libbb/libbb.h"
  31
  32 /*
  33  * Returns number of the number of packages depending on the packages provided by this package.
  34  * Every package implicitly provides itself.
  35  */
  36 int pkg_has_installed_dependents(opkg_conf_t *conf, abstract_pkg_t *parent_apkg, pkg_t *pkg, abstract_pkg_t *** pdependents)
  37 {
  38      int nprovides = pkg->provides_count;
  39      abstract_pkg_t **provides = pkg->provides;
  40      int n_installed_dependents = 0;
  41      int i;
  42      for (i = 0; i <= nprovides; i++) {
  43           abstract_pkg_t *providee = provides[i];
  44           abstract_pkg_t **dependers = providee->depended_upon_by;
  45           abstract_pkg_t *dep_ab_pkg;
  46           if (dependers == NULL)
  47                continue;
  48           while ((dep_ab_pkg = *dependers++) != NULL) {
  49                if (dep_ab_pkg->state_status == SS_INSTALLED){
  50                     n_installed_dependents++;
  51                }
  52           }
  53
  54      }
  55      /* if caller requested the set of installed dependents */
  56      if (pdependents) {
  57           int p = 0;
  58           abstract_pkg_t **dependents = xcalloc((n_installed_dependents+1), sizeof(abstract_pkg_t *));
  59
  60           *pdependents = dependents;
  61           for (i = 0; i <= nprovides; i++) {
  62                abstract_pkg_t *providee = provides[i];
  63                abstract_pkg_t **dependers = providee->depended_upon_by;
  64                abstract_pkg_t *dep_ab_pkg;
  65                if (dependers == NULL)
  66                     continue;
  67                while ((dep_ab_pkg = *dependers++) != NULL) {
  68                     if (dep_ab_pkg->state_status == SS_INSTALLED && !(dep_ab_pkg->state_flag & SF_MARKED)) {
  69                          dependents[p++] = dep_ab_pkg;
  70                          dep_ab_pkg->state_flag |= SF_MARKED;
  71                     }
  72                }
  73           }
  74           dependents[p] = NULL;
  75           /* now clear the marks */
  76           for (i = 0; i < p; i++) {
  77                abstract_pkg_t *dep_ab_pkg = dependents[i];
  78                dep_ab_pkg->state_flag &= ~SF_MARKED;
  79           }
  80      }
  81      return n_installed_dependents;
  82 }
  83
  84 int opkg_remove_dependent_pkgs (opkg_conf_t *conf, pkg_t *pkg, abstract_pkg_t **dependents)
  85 {
  86     int i;
  87     int a;
  88     int count;
  89     pkg_vec_t *dependent_pkgs;
  90     abstract_pkg_t * ab_pkg;
  91
  92     if((ab_pkg = pkg->parent) == NULL){
  93         fprintf(stderr, "%s: unable to get dependent pkgs. pkg %s isn't in hash table\n",
  94                 __FUNCTION__, pkg->name);
  95         return 0;
  96     }
  97
  98     if (dependents == NULL)
  99             return 0;
 100
 101     // here i am using the dependencies_checked
 102     if (ab_pkg->dependencies_checked == 2) // variable to make out whether this package
 103         return 0;                          // has already been encountered in the process
 104                                            // of marking packages for removal - Karthik
 105     ab_pkg->dependencies_checked = 2;
 106
 107     i = 0;
 108     count = 1;
 109     dependent_pkgs = pkg_vec_alloc();
 110
 111     while (dependents [i] != NULL) {
 112         abstract_pkg_t *dep_ab_pkg = dependents[i];
 113
 114         if (dep_ab_pkg->dependencies_checked == 2){
 115             i++;
 116             continue;
 117         }
 118         if (dep_ab_pkg->state_status == SS_INSTALLED) {
 119             for (a = 0; a < dep_ab_pkg->pkgs->len; a++) {
 120                 pkg_t *dep_pkg = dep_ab_pkg->pkgs->pkgs[a];
 121                 if (dep_pkg->state_status == SS_INSTALLED) {
 122                     pkg_vec_insert(dependent_pkgs, dep_pkg);
 123                     count++;
 124                 }
 125             }
 126         }
 127         i++;
 128         /* 1 - to keep track of visited ab_pkgs when checking for possiblility of a broken removal of pkgs.
 129          * 2 - to keep track of pkgs whose deps have been checked alrdy  - Karthik */
 130     }
 131
 132     if (count == 1) {
 133         free(dependent_pkgs);
 134         return 0;
 135     }
 136
 137
 138     int err=0;
 139     for (i = 0; i < dependent_pkgs->len; i++) {
 140         err = opkg_remove_pkg(conf, dependent_pkgs->pkgs[i],0);
 141         if (err)
 142             break;
 143     }
 144     free(dependent_pkgs);
 145     return err;
 146 }
 147
 148 static int user_prefers_removing_dependents(opkg_conf_t *conf, abstract_pkg_t *abpkg, pkg_t *pkg, abstract_pkg_t **dependents)
 149 {
 150     abstract_pkg_t *dep_ab_pkg;
 151     opkg_message(conf, OPKG_ERROR, "Package %s is depended upon by packages:\n", pkg->name);
 152     while ((dep_ab_pkg = *dependents++) != NULL) {
 153          if (dep_ab_pkg->state_status == SS_INSTALLED)
 154               opkg_message(conf, OPKG_ERROR, "\t%s\n", dep_ab_pkg->name);
 155     }
 156     opkg_message(conf, OPKG_ERROR, "These might cease to work if package %s is removed.\n\n", pkg->name);
 157     opkg_message(conf, OPKG_ERROR, "");
 158     opkg_message(conf, OPKG_ERROR, "You can force removal of this package with -force-depends.\n");
 159     opkg_message(conf, OPKG_ERROR, "You can force removal of this package and its dependents\n");
 160     opkg_message(conf, OPKG_ERROR, "with -force-removal-of-dependent-packages or -recursive\n");
 161     opkg_message(conf, OPKG_ERROR, "or by setting option force_removal_of_dependent_packages\n");
 162     opkg_message(conf, OPKG_ERROR, "in opkg.conf.\n");
 163     return 0;
 164 }
 165
 166 static int remove_autoinstalled (opkg_conf_t *conf, pkg_t *pkg)
 167 {
 168   /*
 169    * find and remove packages that were autoinstalled and are orphaned by the removal of pkg
 170    */
 171
 172   char *buffer, *d_str;
 173   int i;
 174
 175   for (i = 0; i < pkg->depends_count; ++i)
 176   {
 177     int x = 0;
 178     pkg_t *p;
 179     d_str = pkg->depends_str[i];
 180     buffer = xcalloc(1, strlen (d_str) + 1);
 181
 182     while (d_str[x] != '\0' && d_str[x] != ' ')
 183     {
 184       buffer[x] = d_str[x];
 185       ++x;
 186     }
 187     buffer[x] = '\0';
 188     buffer = xrealloc (buffer, strlen (buffer) + 1);
 189     p = pkg_hash_fetch_installed_by_name (&conf->pkg_hash, buffer);
 190
 191     /* if the package is not installed, this could have been a circular
 192      * depenancy and the package has already been removed */
 193     if (!p)
 194       return -1;
 195
 196     if (p->auto_installed)
 197     {
 198       int deps;
 199       abstract_pkg_t **dependents;
 200
 201       deps = pkg_has_installed_dependents(conf, NULL, p, &dependents);
 202       if (deps == 0)
 203       {
 204          opkg_message (conf, OPKG_INFO,
 205                        "%s was autoinstalled but is now orphaned\n", buffer);
 206          opkg_remove_pkg(conf, p,0);
 207       }
 208         else
 209            opkg_message (conf, OPKG_INFO, "%s was autoinstalled and is still required by "
 210                          "%d installed packages\n", buffer, deps);
 211     }
 212     free (buffer);
 213   }
 214
 215   return 0;
 216 }
 217
 218 int opkg_remove_pkg(opkg_conf_t *conf, pkg_t *pkg,int message)
 219 {
 220 /* Actually, when "message == 1" I have been called from an upgrade, and not from a normal remove
 221    thus I wan't check for essential, as I'm upgrading.
 222    I hope it won't break anything :)
 223 */
 224      int err;
 225      abstract_pkg_t *parent_pkg = NULL;
 226
 227      if (pkg->essential && !message) {
 228           if (conf->force_removal_of_essential_packages) {
 229                fprintf(stderr, "WARNING: Removing essential package %s under your coercion.\n"
 230                        "\tIf your system breaks, you get to keep both pieces\n",
 231                        pkg->name);
 232           } else {
 233                fprintf(stderr, "ERROR: Refusing to remove essential package %s.\n"
 234                        "\tRemoving an essential package may lead to an unusable system, but if\n"
 235                        "\tyou enjoy that kind of pain, you can force opkg to proceed against\n"
 236                        "\tits will with the option: -force-removal-of-essential-packages\n",
 237                        pkg->name);
 238                return OPKG_PKG_IS_ESSENTIAL;
 239           }
 240      }
 241
 242      if ((parent_pkg = pkg->parent) == NULL)
 243           return 0;
 244
 245      /* only attempt to remove dependent installed packages if
 246       * force_depends is not specified or the package is being
 247       * replaced.
 248       */
 249      if (!conf->force_depends
 250          && !(pkg->state_flag & SF_REPLACE)) {
 251           abstract_pkg_t **dependents;
 252           int has_installed_dependents =
 253                pkg_has_installed_dependents(conf, parent_pkg, pkg, &dependents);
 254
 255           if (has_installed_dependents) {
 256                /*
 257                 * if this package is depended up by others, then either we should
 258                 * not remove it or we should remove it and all of its dependents
 259                 */
 260
 261                if (!conf->force_removal_of_dependent_packages
 262                    && !user_prefers_removing_dependents(conf, parent_pkg, pkg, dependents)) {
 263                     free(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                if (err) {
 270                  free(dependents);
 271                  return err;
 272                }
 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 = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
 342           file_name = (char *)iter->data;
 343
 344           if (file_is_dir(file_name)) {
 345                str_list_append(&installed_dirs, 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 = str_list_first(&installed_dirs); iter; iter = str_list_next(&installed_dirs, iter)) {
 373                     file_name = (char *)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 = str_list_first(&installed_dirs); iter; iter = str_list_next(&installed_dirs, iter)) {
 391           file_name = (char *)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      while (!void_list_empty(&installed_dirs)) {
 403         iter = str_list_pop(&installed_dirs);
 404         free(iter->data);
 405         free(iter);
 406      }
 407      str_list_deinit(&installed_dirs);
 408
 409      return 0;
 410 }
 411
 412 int remove_maintainer_scripts_except_postrm(opkg_conf_t *conf, pkg_t *pkg)
 413 {
 414     int i, err;
 415     char *globpattern;
 416     glob_t globbuf;
 417
 418     if (conf->noaction) return 0;
 419
 420     sprintf_alloc(&globpattern, "%s/%s.*",
 421                   pkg->dest->info_dir, pkg->name);
 422     err = glob(globpattern, 0, NULL, &globbuf);
 423     free(globpattern);
 424     if (err) {
 425         return 0;
 426     }
 427
 428     for (i = 0; i < globbuf.gl_pathc; i++) {
 429         if (str_ends_with(globbuf.gl_pathv[i], ".postrm")) {
 430             continue;
 431         }
 432         opkg_message(conf, OPKG_INFO, "  deleting %s\n", globbuf.gl_pathv[i]);
 433         unlink(globbuf.gl_pathv[i]);
 434     }
 435     globfree(&globbuf);
 436
 437     return 0;
 438 }
 439
 440 int remove_postrm(opkg_conf_t *conf, pkg_t *pkg)
 441 {
 442     char *postrm_file_name;
 443
 444     if (conf->noaction) return 0;
 445
 446     sprintf_alloc(&postrm_file_name, "%s/%s.postrm",
 447                   pkg->dest->info_dir, pkg->name);
 448     unlink(postrm_file_name);
 449     free(postrm_file_name);
 450
 451     return 0;
 452 }