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