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      int rootdirlen = 0;
 338
 339      str_list_init(&installed_dirs);
 340      installed_files = pkg_get_installed_files(conf, pkg);
 341
 342      /* don't include trailing slash */
 343      if (conf->offline_root)
 344           rootdirlen = strlen(conf->offline_root);
 345
 346      for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
 347           file_name = (char *)iter->data;
 348
 349           if (file_is_dir(file_name)) {
 350                str_list_append(&installed_dirs, file_name);
 351                continue;
 352           }
 353
 354           conffile = pkg_get_conffile(pkg, file_name+rootdirlen);
 355           if (conffile) {
 356                /* XXX: QUESTION: Is this right? I figure we only need to
 357                   save the conffile if it has been modified. Is that what
 358                   dpkg does? Or does dpkg preserve all conffiles? If so,
 359                   this seems like a better thing to do to conserve
 360                   space. */
 361                if (conffile_has_been_modified(conf, conffile)) {
 362                     opkg_message (conf, OPKG_NOTICE,
 363                                   "  not deleting modified conffile %s\n", file_name);
 364                     fflush(stdout);
 365                     continue;
 366                }
 367           }
 368
 369           opkg_message(conf, OPKG_INFO, "  deleting %s (noaction=%d)\n", file_name, conf->noaction);
 370           if (!conf->noaction)
 371                unlink(file_name);
 372      }
 373
 374      if (!conf->noaction) {
 375           do {
 376                removed_a_dir = 0;
 377                for (iter = str_list_first(&installed_dirs); iter; iter = str_list_next(&installed_dirs, iter)) {
 378                     file_name = (char *)iter->data;
 379
 380                     if (rmdir(file_name) == 0) {
 381                          opkg_message(conf, OPKG_INFO, "  deleting %s\n", file_name);
 382                          removed_a_dir = 1;
 383                          str_list_remove(&installed_dirs, &iter);
 384                     }
 385                }
 386           } while (removed_a_dir);
 387      }
 388
 389      pkg_free_installed_files(pkg);
 390      /* We have to remove the file list now, so that
 391         find_pkg_owning_file does not always just report this package */
 392      pkg_remove_installed_files_list(conf, pkg);
 393
 394      /* Don't print warning for dirs that are provided by other packages */
 395      for (iter = str_list_first(&installed_dirs); iter; iter = str_list_next(&installed_dirs, iter)) {
 396           file_name = (char *)iter->data;
 397
 398           owner = file_hash_get_file_owner(conf, file_name);
 399           if (owner) {
 400                free(iter->data);
 401                iter->data = NULL;
 402                str_list_remove(&installed_dirs, &iter);
 403           }
 404      }
 405
 406      /* cleanup */
 407      while (!void_list_empty(&installed_dirs)) {
 408         iter = str_list_pop(&installed_dirs);
 409         free(iter->data);
 410         free(iter);
 411      }
 412      str_list_deinit(&installed_dirs);
 413
 414      return 0;
 415 }
 416
 417 int remove_maintainer_scripts_except_postrm(opkg_conf_t *conf, pkg_t *pkg)
 418 {
 419     int i, err;
 420     char *globpattern;
 421     glob_t globbuf;
 422
 423     if (conf->noaction) return 0;
 424
 425     sprintf_alloc(&globpattern, "%s/%s.*",
 426                   pkg->dest->info_dir, pkg->name);
 427     err = glob(globpattern, 0, NULL, &globbuf);
 428     free(globpattern);
 429     if (err) {
 430         return 0;
 431     }
 432
 433     for (i = 0; i < globbuf.gl_pathc; i++) {
 434         if (str_ends_with(globbuf.gl_pathv[i], ".postrm")) {
 435             continue;
 436         }
 437         opkg_message(conf, OPKG_INFO, "  deleting %s\n", globbuf.gl_pathv[i]);
 438         unlink(globbuf.gl_pathv[i]);
 439     }
 440     globfree(&globbuf);
 441
 442     return 0;
 443 }
 444
 445 int remove_postrm(opkg_conf_t *conf, pkg_t *pkg)
 446 {
 447     char *postrm_file_name;
 448
 449     if (conf->noaction) return 0;
 450
 451     sprintf_alloc(&postrm_file_name, "%s/%s.postrm",
 452                   pkg->dest->info_dir, pkg->name);
 453     unlink(postrm_file_name);
 454     free(postrm_file_name);
 455
 456     return 0;
 457 }