s/malloc/xmalloc/ s/calloc/xcalloc/ s/realloc/realloc/
[project/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 "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 }