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      }
 275
 276      if ( message==0 ){
 277          opkg_message (conf, OPKG_NOTICE,
 278                        "Removing package %s from %s...\n", pkg->name, pkg->dest->name);
 279          fflush(stdout);
 280      }
 281      pkg->state_flag |= SF_FILELIST_CHANGED;
 282
 283      pkg->state_want = SW_DEINSTALL;
 284      opkg_state_changed++;
 285
 286      pkg_run_script(conf, pkg, "prerm", "remove");
 287
 288      /* DPKG_INCOMPATIBILITY: dpkg is slightly different here. It
 289         maintains an empty filelist rather than deleting it. That seems
 290         like a big pain, and I don't see that that should make a big
 291         difference, but for anyone who wants tighter compatibility,
 292         feel free to fix this. */
 293      remove_data_files_and_list(conf, pkg);
 294
 295      pkg_run_script(conf, pkg, "postrm", "remove");
 296
 297      remove_maintainer_scripts_except_postrm(conf, pkg);
 298
 299      /* Aman Gupta - Since opkg is made for handheld devices with limited
 300       * space, it doesn't make sense to leave extra configurations, files,
 301       * and maintainer scripts left around. So, we make remove like purge,
 302       * and take out all the crap :) */
 303
 304      remove_postrm(conf, pkg);
 305      pkg->state_status = SS_NOT_INSTALLED;
 306
 307      if (parent_pkg)
 308           parent_pkg->state_status = SS_NOT_INSTALLED;
 309
 310
 311      /* remove autoinstalled packages that are orphaned by the removal of this one */
 312      if (conf->autoremove)
 313        remove_autoinstalled (conf, pkg);
 314
 315
 316
 317      return 0;
 318 }
 319
 320 int opkg_purge_pkg(opkg_conf_t *conf, pkg_t *pkg)
 321 {
 322     opkg_remove_pkg(conf, pkg,0);
 323     return 0;
 324 }
 325
 326 int remove_data_files_and_list(opkg_conf_t *conf, pkg_t *pkg)
 327 {
 328      str_list_t installed_dirs;
 329      str_list_t *installed_files;
 330      str_list_elt_t *iter;
 331      char *file_name;
 332      conffile_t *conffile;
 333      int removed_a_dir;
 334      pkg_t *owner;
 335
 336      str_list_init(&installed_dirs);
 337      installed_files = pkg_get_installed_files(pkg);
 338
 339      for (iter = installed_files->head; iter; iter = iter->next) {
 340           file_name = iter->data;
 341
 342           if (file_is_dir(file_name)) {
 343                str_list_append(&installed_dirs, strdup(file_name));
 344                continue;
 345           }
 346
 347           conffile = pkg_get_conffile(pkg, file_name);
 348           if (conffile) {
 349                /* XXX: QUESTION: Is this right? I figure we only need to
 350                   save the conffile if it has been modified. Is that what
 351                   dpkg does? Or does dpkg preserve all conffiles? If so,
 352                   this seems like a better thing to do to conserve
 353                   space. */
 354                if (conffile_has_been_modified(conf, conffile)) {
 355                     opkg_message (conf, OPKG_NOTICE,
 356                                   "  not deleting modified conffile %s\n", file_name);
 357                     fflush(stdout);
 358                     continue;
 359                }
 360           }
 361
 362           opkg_message(conf, OPKG_INFO, "  deleting %s (noaction=%d)\n", file_name, conf->noaction);
 363           if (!conf->noaction)
 364                unlink(file_name);
 365      }
 366
 367      if (!conf->noaction) {
 368           do {
 369                removed_a_dir = 0;
 370                for (iter = installed_dirs.head; iter; iter = iter->next) {
 371                     file_name = iter->data;
 372
 373                     if (rmdir(file_name) == 0) {
 374                          opkg_message(conf, OPKG_INFO, "  deleting %s\n", file_name);
 375                          removed_a_dir = 1;
 376                          str_list_remove(&installed_dirs, &iter);
 377                     }
 378                }
 379           } while (removed_a_dir);
 380      }
 381
 382      pkg_free_installed_files(pkg);
 383      /* We have to remove the file list now, so that
 384         find_pkg_owning_file does not always just report this package */
 385      pkg_remove_installed_files_list(conf, pkg);
 386
 387      /* Don't print warning for dirs that are provided by other packages */
 388      for (iter = installed_dirs.head; iter; iter = iter->next) {
 389           file_name = iter->data;
 390
 391           owner = file_hash_get_file_owner(conf, file_name);
 392           if (owner) {
 393                free(iter->data);
 394                iter->data = NULL;
 395                str_list_remove(&installed_dirs, &iter);
 396           }
 397      }
 398
 399      /* cleanup */
 400      for (iter = installed_dirs.head; iter; iter = iter->next) {
 401           free(iter->data);
 402           iter->data = NULL;
 403      }
 404      str_list_deinit(&installed_dirs);
 405
 406      return 0;
 407 }
 408
 409 int remove_maintainer_scripts_except_postrm(opkg_conf_t *conf, pkg_t *pkg)
 410 {
 411     int i, err;
 412     char *globpattern;
 413     glob_t globbuf;
 414
 415     if (conf->noaction) return 0;
 416
 417     sprintf_alloc(&globpattern, "%s/%s.*",
 418                   pkg->dest->info_dir, pkg->name);
 419     err = glob(globpattern, 0, NULL, &globbuf);
 420     free(globpattern);
 421     if (err) {
 422         return 0;
 423     }
 424
 425     for (i = 0; i < globbuf.gl_pathc; i++) {
 426         if (str_ends_with(globbuf.gl_pathv[i], ".postrm")) {
 427             continue;
 428         }
 429         opkg_message(conf, OPKG_INFO, "  deleting %s\n", globbuf.gl_pathv[i]);
 430         unlink(globbuf.gl_pathv[i]);
 431     }
 432     globfree(&globbuf);
 433
 434     return 0;
 435 }
 436
 437 int remove_postrm(opkg_conf_t *conf, pkg_t *pkg)
 438 {
 439     char *postrm_file_name;
 440
 441     if (conf->noaction) return 0;
 442
 443     sprintf_alloc(&postrm_file_name, "%s/%s.postrm",
 444                   pkg->dest->info_dir, pkg->name);
 445     unlink(postrm_file_name);
 446     free(postrm_file_name);
 447
 448     return 0;
 449 }