projects / project / opkg-lede.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Fix problems in error list
[project/opkg-lede.git] / libopkg / opkg_cmd.c
1 /* opkg_cmd.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
19 #include "includes.h"
20 #include <dirent.h>
21 #include <glob.h>
22
23 #include "opkg_conf.h"
24 #include "opkg_cmd.h"
25 #include "opkg_message.h"
26 #include "pkg.h"
27 #include "pkg_dest.h"
28 #include "pkg_parse.h"
29 #include "sprintf_alloc.h"
30 #include "pkg.h"
31 #include "file_util.h"
32 #include "str_util.h"
33 #include "libbb/libbb.h"
34 #include "opkg_utils.h"
35 #include "opkg_defines.h"
36
37 #include <fnmatch.h>
38
39
40 #include "opkg_download.h"
41 #include "opkg_install.h"
42 #include "opkg_upgrade.h"
43 #include "opkg_remove.h"
44 #include "opkg_configure.h"
45 #include "opkg_message.h"
46
47 #include "libopkg.h"
48 static void *p_userdata = NULL;
49
50 static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv);
51 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv);
52 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv);
53 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv);
54 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv);
55 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv);
56 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv);
57 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv);
58 static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv);
59 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv);
60 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv);
61 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv);
62 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv);
63 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv);
64 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv);
65 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv);
66 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv);
67 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv);
68 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv);
69 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv);
70 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv);
71 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv);
72 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv);
73 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv);
74 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv);
75 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv);
76 static int pkg_mark_provides(pkg_t *pkg);
77
78 /* XXX: CLEANUP: The usage strings should be incorporated into this
79 array for easier maintenance */
80 static opkg_cmd_t cmds[] = {
81 {"update", 0, (opkg_cmd_fun_t)opkg_update_cmd},
82 {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd},
83 {"list", 0, (opkg_cmd_fun_t)opkg_list_cmd},
84 {"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd},
85 {"list_upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd},
86 {"info", 0, (opkg_cmd_fun_t)opkg_info_cmd},
87 {"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd},
88 {"status", 0, (opkg_cmd_fun_t)opkg_status_cmd},
89 {"install_pending", 0, (opkg_cmd_fun_t)opkg_install_pending_cmd},
90 {"install", 1, (opkg_cmd_fun_t)opkg_install_cmd},
91 {"remove", 1, (opkg_cmd_fun_t)opkg_remove_cmd},
92 {"purge", 1, (opkg_cmd_fun_t)opkg_purge_cmd},
93 {"configure", 0, (opkg_cmd_fun_t)opkg_configure_cmd},
94 {"files", 1, (opkg_cmd_fun_t)opkg_files_cmd},
95 {"search", 1, (opkg_cmd_fun_t)opkg_search_cmd},
96 {"download", 1, (opkg_cmd_fun_t)opkg_download_cmd},
97 {"compare_versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd},
98 {"compare-versions", 1, (opkg_cmd_fun_t)opkg_compare_versions_cmd},
99 {"print-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
100 {"print_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
101 {"print-installation-architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
102 {"print_installation_architecture", 0, (opkg_cmd_fun_t)opkg_print_architecture_cmd},
103 {"depends", 1, (opkg_cmd_fun_t)opkg_depends_cmd},
104 {"whatdepends", 1, (opkg_cmd_fun_t)opkg_whatdepends_cmd},
105 {"whatdependsrec", 1, (opkg_cmd_fun_t)opkg_whatdepends_recursively_cmd},
106 {"whatrecommends", 1, (opkg_cmd_fun_t)opkg_whatrecommends_cmd},
107 {"whatsuggests", 1, (opkg_cmd_fun_t)opkg_whatsuggests_cmd},
108 {"whatprovides", 1, (opkg_cmd_fun_t)opkg_whatprovides_cmd},
109 {"whatreplaces", 1, (opkg_cmd_fun_t)opkg_whatreplaces_cmd},
110 {"whatconflicts", 1, (opkg_cmd_fun_t)opkg_whatconflicts_cmd},
111 };
112
113 int opkg_state_changed;
114 static void write_status_files_if_changed(opkg_conf_t *conf)
115 {
116 if (opkg_state_changed && !conf->noaction) {
117 opkg_message(conf, OPKG_INFO,
118 " writing status file\n");
119 opkg_conf_write_status_files(conf);
120 pkg_write_changed_filelists(conf);
121 } else {
122 opkg_message(conf, OPKG_DEBUG, "Nothing to be done\n");
123 }
124 }
125
126
127 static int num_cmds = sizeof(cmds) / sizeof(opkg_cmd_t);
128
129 opkg_cmd_t *opkg_cmd_find(const char *name)
130 {
131 int i;
132 opkg_cmd_t *cmd;
133
134 for (i=0; i < num_cmds; i++) {
135 cmd = &cmds[i];
136 if (strcmp(name, cmd->name) == 0) {
137 return cmd;
138 }
139 }
140
141 return NULL;
142 }
143
144 void opkg_print_error_list (opkg_conf_t *conf)
145 {
146 struct errlist *err = error_list;
147
148 if (err) {
149 reverse_error_list(&err);
150
151 printf ("Collected errors:\n");
152 /* Here we print the errors collected and free the list */
153 while (err != NULL) {
154 printf (" * %s", err->errmsg);
155 err = err->next;
156
157 }
158
159 free_error_list(&error_list);
160 }
161
162 }
163
164 int opkg_cmd_exec(opkg_cmd_t *cmd, opkg_conf_t *conf, int argc, const char **argv, void *userdata)
165 {
166 int result;
167 p_userdata = userdata;
168
169
170 result = (cmd->fun)(conf, argc, argv);
171
172 if ( result != 0 && !error_list) {
173 opkg_message(conf, OPKG_NOTICE, "An error occurred, return value: %d.\n", result);
174 }
175
176 opkg_print_error_list (conf);
177
178 p_userdata = NULL;
179 return result;
180 }
181
182 static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv)
183 {
184 char *tmp;
185 int err;
186 int failures;
187 char *lists_dir;
188 pkg_src_list_elt_t *iter;
189 pkg_src_t *src;
190
191
192 sprintf_alloc(&lists_dir, "%s", conf->restrict_to_default_dest ? conf->default_dest->lists_dir : conf->lists_dir);
193
194 if (! file_is_dir(lists_dir)) {
195 if (file_exists(lists_dir)) {
196 opkg_message(conf, OPKG_ERROR,
197 "%s: ERROR: %s exists, but is not a directory\n",
198 __FUNCTION__, lists_dir);
199 free(lists_dir);
200 return EINVAL;
201 }
202 err = file_mkdir_hier(lists_dir, 0755);
203 if (err) {
204 opkg_message(conf, OPKG_ERROR,
205 "%s: ERROR: failed to make directory %s: %s\n",
206 __FUNCTION__, lists_dir, strerror(errno));
207 free(lists_dir);
208 return EINVAL;
209 }
210 }
211
212 failures = 0;
213
214
215 tmp = strdup ("/tmp/opkg.XXXXXX");
216
217 if (mkdtemp (tmp) == NULL) {
218 perror ("mkdtemp");
219 failures++;
220 }
221
222
223 for (iter = void_list_first(&conf->pkg_src_list); iter; iter = void_list_next(&conf->pkg_src_list, iter)) {
224 char *url, *list_file_name;
225
226 src = (pkg_src_t *)iter->data;
227
228 if (src->extra_data) /* debian style? */
229 sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
230 src->gzip ? "Packages.gz" : "Packages");
231 else
232 sprintf_alloc(&url, "%s/%s", src->value, src->gzip ? "Packages.gz" : "Packages");
233
234 sprintf_alloc(&list_file_name, "%s/%s", lists_dir, src->name);
235 if (src->gzip) {
236 char *tmp_file_name;
237 FILE *in, *out;
238
239 sprintf_alloc (&tmp_file_name, "%s/%s.gz", tmp, src->name);
240 err = opkg_download(conf, url, tmp_file_name, NULL, NULL);
241 if (err == 0) {
242 opkg_message (conf, OPKG_NOTICE, "Inflating %s\n", url);
243 in = fopen (tmp_file_name, "r");
244 out = fopen (list_file_name, "w");
245 if (in && out)
246 unzip (in, out);
247 else
248 err = 1;
249 if (in)
250 fclose (in);
251 if (out)
252 fclose (out);
253 unlink (tmp_file_name);
254 }
255 } else
256 err = opkg_download(conf, url, list_file_name, NULL, NULL);
257 if (err) {
258 failures++;
259 } else {
260 opkg_message(conf, OPKG_NOTICE,
261 "Updated list of available packages in %s\n",
262 list_file_name);
263 }
264 free(url);
265 #if defined(HAVE_GPGME) || defined(HAVE_OPENSSL)
266 if (conf->check_signature) {
267 /* download detached signitures to verify the package lists */
268 /* get the url for the sig file */
269 if (src->extra_data) /* debian style? */
270 sprintf_alloc(&url, "%s/%s/%s", src->value, src->extra_data,
271 "Packages.sig");
272 else
273 sprintf_alloc(&url, "%s/%s", src->value, "Packages.sig");
274
275 /* create temporary file for it */
276 char *tmp_file_name;
277
278 /* Put the signature in the right place */
279 sprintf_alloc (&tmp_file_name, "%s/%s.sig", lists_dir, src->name);
280
281 err = opkg_download(conf, url, tmp_file_name, NULL, NULL);
282 if (err) {
283 failures++;
284 opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
285 } else {
286 int err;
287 err = opkg_verify_file (conf, list_file_name, tmp_file_name);
288 if (err == 0)
289 opkg_message (conf, OPKG_NOTICE, "Signature check passed\n");
290 else
291 opkg_message (conf, OPKG_NOTICE, "Signature check failed\n");
292 }
293 /* We shouldn't unlink the signature ! */
294 // unlink (tmp_file_name);
295 free (tmp_file_name);
296 free (url);
297 }
298 #else
299 // Do nothing
300 #endif
301 free(list_file_name);
302 }
303 rmdir (tmp);
304 free (tmp);
305 free(lists_dir);
306
307 return failures;
308 }
309
310
311 struct opkg_intercept
312 {
313 char *oldpath;
314 char *statedir;
315 };
316
317 typedef struct opkg_intercept *opkg_intercept_t;
318
319 static opkg_intercept_t opkg_prep_intercepts(opkg_conf_t *conf)
320 {
321 opkg_intercept_t ctx;
322 char *oldpath;
323 char *newpath;
324 int gen;
325
326 ctx = calloc (1, sizeof (*ctx));
327 oldpath = getenv ("PATH");
328 if (oldpath) {
329 ctx->oldpath = strdup (oldpath);
330 } else {
331 ctx->oldpath = 0;
332 }
333
334
335 sprintf_alloc (&newpath, "%s/opkg/intercept:%s", DATADIR, ctx->oldpath);
336 setenv ("PATH", newpath, 1);
337 free (newpath);
338
339 gen = 0;
340 retry:
341 sprintf_alloc (&ctx->statedir, "/tmp/opkg-intercept-%d-%d", getpid (), gen);
342 if (mkdir (ctx->statedir, 0770) < 0) {
343 if (errno == EEXIST) {
344 free (ctx->statedir);
345 gen++;
346 goto retry;
347 }
348 perror (ctx->statedir);
349 return NULL;
350 }
351 setenv ("OPKG_INTERCEPT_DIR", ctx->statedir, 1);
352 return ctx;
353 }
354
355 static int opkg_finalize_intercepts(opkg_intercept_t ctx)
356 {
357 char *cmd;
358 DIR *dir;
359 int err = 0;
360
361 if (ctx->oldpath) {
362 setenv ("PATH", ctx->oldpath, 1);
363 free (ctx->oldpath);
364 } else {
365 unsetenv("PATH");
366 }
367
368 dir = opendir (ctx->statedir);
369 if (dir) {
370 struct dirent *de;
371 while (de = readdir (dir), de != NULL) {
372 char *path;
373
374 if (de->d_name[0] == '.')
375 continue;
376
377 sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
378 if (access (path, X_OK) == 0) {
379 if (system (path)) {
380 err = errno;
381 perror (de->d_name);
382 }
383 }
384 free (path);
385 }
386 closedir(dir);
387 } else
388 perror (ctx->statedir);
389
390 sprintf_alloc (&cmd, "rm -rf %s", ctx->statedir);
391 err = system (cmd);
392 free (cmd);
393
394 free (ctx->statedir);
395 free (ctx);
396
397 return err;
398 }
399
400 /* For package pkg do the following: If it is already visited, return. If not,
401 add it in visited list and recurse to its deps. Finally, add it to ordered
402 list.
403 pkg_vec all contains all available packages in repos.
404 pkg_vec visited contains packages already visited by this function, and is
405 used to end recursion and avoid an infinite loop on graph cycles.
406 pkg_vec ordered will finally contain the ordered set of packages.
407 */
408 static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *all,
409 pkg_vec_t *visited, pkg_vec_t *ordered)
410 {
411 int j,k,l,m;
412 int count;
413 pkg_t *dep;
414 compound_depend_t * compound_depend;
415 depend_t ** possible_satisfiers;
416 abstract_pkg_t *abpkg;
417 abstract_pkg_t **dependents;
418
419 /* If it's just an available package, that is, not installed and not even
420 unpacked, skip it */
421 /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
422 would do here. However, if there is an intermediate node (pkg) that is
423 configured and installed between two unpacked packages, the latter
424 won't be properly reordered, unless all installed/unpacked pkgs are
425 checked */
426 if (pkg->state_status == SS_NOT_INSTALLED)
427 return 0;
428
429 /* If the package has already been visited (by this function), skip it */
430 for(j = 0; j < visited->len; j++)
431 if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) {
432 opkg_message(conf, OPKG_INFO,
433 " pkg: %s already visited\n", pkg->name);
434 return 0;
435 }
436
437 pkg_vec_insert(visited, pkg);
438
439 count = pkg->pre_depends_count + pkg->depends_count + \
440 pkg->recommends_count + pkg->suggests_count;
441
442 opkg_message(conf, OPKG_INFO,
443 " pkg: %s\n", pkg->name);
444
445 /* Iterate over all the dependencies of pkg. For each one, find a package
446 that is either installed or unpacked and satisfies this dependency.
447 (there should only be one such package per dependency installed or
448 unpacked). Then recurse to the dependency package */
449 for (j=0; j < count ; j++) {
450 compound_depend = &pkg->depends[j];
451 possible_satisfiers = compound_depend->possibilities;
452 for (k=0; k < compound_depend->possibility_count ; k++) {
453 abpkg = possible_satisfiers[k]->pkg;
454 dependents = abpkg->provided_by->pkgs;
455 l = 0;
456 if (dependents != NULL)
457 while (dependents [l] != NULL && l < abpkg->provided_by->len) {
458 opkg_message(conf, OPKG_INFO,
459 " Descending on pkg: %s\n",
460 dependents [l]->name);
461
462 /* find whether dependent l is installed or unpacked,
463 * and then find which package in the list satisfies it */
464 for(m = 0; m < all->len; m++) {
465 dep = all->pkgs[m];
466 if ( dep->state_status != SS_NOT_INSTALLED)
467 if ( ! strcmp(dep->name, dependents[l]->name)) {
468 opkg_recurse_pkgs_in_order(conf, dep, all,
469 visited, ordered);
470 /* Stop the outer loop */
471 l = abpkg->provided_by->len;
472 /* break from the inner loop */
473 break;
474 }
475 }
476 l++;
477 }
478 }
479 }
480
481 /* When all recursions from this node down, are over, and all
482 dependencies have been added in proper order in the ordered array, add
483 also the package pkg to ordered array */
484 pkg_vec_insert(ordered, pkg);
485
486 return 0;
487
488 }
489
490 static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
491 {
492 pkg_vec_t *all, *ordered, *visited;
493 int i;
494 pkg_t *pkg;
495 opkg_intercept_t ic;
496 int r, err = 0;
497
498 opkg_message(conf, OPKG_INFO,
499 "Configuring unpacked packages\n");
500 fflush( stdout );
501
502 all = pkg_vec_alloc();
503
504 pkg_hash_fetch_available(&conf->pkg_hash, all);
505
506 /* Reorder pkgs in order to be configured according to the Depends: tag
507 order */
508 opkg_message(conf, OPKG_INFO,
509 "Reordering packages before configuring them...\n");
510 ordered = pkg_vec_alloc();
511 visited = pkg_vec_alloc();
512 for(i = 0; i < all->len; i++) {
513 pkg = all->pkgs[i];
514 opkg_recurse_pkgs_in_order(conf, pkg, all, visited, ordered);
515 }
516
517
518 ic = opkg_prep_intercepts (conf);
519
520 for(i = 0; i < all->len; i++) {
521 pkg = all->pkgs[i];
522
523 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
524 continue;
525
526 if (pkg->state_status == SS_UNPACKED) {
527 opkg_message(conf, OPKG_NOTICE,
528 "Configuring %s\n", pkg->name);
529 fflush( stdout );
530 r = opkg_configure(conf, pkg);
531 if (r == 0) {
532 pkg->state_status = SS_INSTALLED;
533 pkg->parent->state_status = SS_INSTALLED;
534 pkg->state_flag &= ~SF_PREFER;
535 } else {
536 if (!err)
537 err = r;
538 }
539 }
540 }
541
542 r = opkg_finalize_intercepts (ic);
543 if (r && !err)
544 err = r;
545
546 pkg_vec_free(all);
547 pkg_vec_free(ordered);
548 pkg_vec_free(visited);
549
550 return err;
551 }
552
553 static opkg_conf_t *global_conf;
554
555 static void sigint_handler(int sig)
556 {
557 signal(sig, SIG_DFL);
558 opkg_message(NULL, OPKG_NOTICE,
559 "opkg: interrupted. writing out status database\n");
560 write_status_files_if_changed(global_conf);
561 exit(128 + sig);
562 }
563
564 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv)
565 {
566 int i;
567 char *arg;
568 int err=0;
569
570 global_conf = conf;
571 signal(SIGINT, sigint_handler);
572
573 /*
574 * Now scan through package names and install
575 */
576 for (i=0; i < argc; i++) {
577 arg = argv[i];
578
579 opkg_message(conf, OPKG_DEBUG2, "Debug install_cmd: %s \n",arg );
580 err = opkg_prepare_url_for_install(conf, arg, &argv[i]);
581 if (err != EINVAL && err != 0)
582 return err;
583 }
584 pkg_info_preinstall_check(conf);
585
586 for (i=0; i < argc; i++) {
587 arg = argv[i];
588 err = opkg_install_by_name(conf, arg);
589 if (err == OPKG_PKG_HAS_NO_CANDIDATE) {
590 opkg_message(conf, OPKG_ERROR,
591 "Cannot find package %s.\n",
592 arg);
593 }
594 }
595
596 /* recheck to verify that all dependences are satisfied */
597 if (0) opkg_satisfy_all_dependences(conf);
598
599 opkg_configure_packages(conf, NULL);
600
601 write_status_files_if_changed(conf);
602
603 return err;
604 }
605
606 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv)
607 {
608 int i;
609 pkg_t *pkg;
610 int err;
611
612 global_conf = conf;
613 signal(SIGINT, sigint_handler);
614
615 if (argc) {
616 for (i=0; i < argc; i++) {
617 char *arg = argv[i];
618
619 err = opkg_prepare_url_for_install(conf, arg, &arg);
620 if (err != EINVAL && err != 0)
621 return err;
622 }
623 pkg_info_preinstall_check(conf);
624
625 for (i=0; i < argc; i++) {
626 char *arg = argv[i];
627 if (conf->restrict_to_default_dest) {
628 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
629 argv[i],
630 conf->default_dest);
631 if (pkg == NULL) {
632 opkg_message(conf, OPKG_NOTICE,
633 "Package %s not installed in %s\n",
634 argv[i], conf->default_dest->name);
635 continue;
636 }
637 } else {
638 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
639 argv[i]);
640 }
641 if (pkg)
642 opkg_upgrade_pkg(conf, pkg);
643 else {
644 opkg_install_by_name(conf, arg);
645 }
646 }
647 } else {
648 pkg_vec_t *installed = pkg_vec_alloc();
649
650 pkg_info_preinstall_check(conf);
651
652 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
653 for (i = 0; i < installed->len; i++) {
654 pkg = installed->pkgs[i];
655 opkg_upgrade_pkg(conf, pkg);
656 }
657 pkg_vec_free(installed);
658 }
659
660 /* recheck to verify that all dependences are satisfied */
661 if (0) opkg_satisfy_all_dependences(conf);
662
663 opkg_configure_packages(conf, NULL);
664
665 write_status_files_if_changed(conf);
666
667 return 0;
668 }
669
670 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv)
671 {
672 int i, err;
673 char *arg;
674 pkg_t *pkg;
675
676 pkg_info_preinstall_check(conf);
677 for (i = 0; i < argc; i++) {
678 arg = argv[i];
679
680 pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, arg, &err);
681 if (pkg == NULL) {
682 opkg_message(conf, OPKG_ERROR,
683 "Cannot find package %s.\n"
684 "Check the spelling or perhaps run 'opkg update'\n",
685 arg);
686 continue;
687 }
688
689 err = opkg_download_pkg(conf, pkg, ".");
690
691 if (err) {
692 opkg_message(conf, OPKG_ERROR,
693 "Failed to download %s\n", pkg->name);
694 } else {
695 opkg_message(conf, OPKG_NOTICE,
696 "Downloaded %s as %s\n",
697 pkg->name, pkg->local_filename);
698 }
699 }
700
701 return 0;
702 }
703
704
705 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv)
706 {
707 int i ;
708 pkg_vec_t *available;
709 pkg_t *pkg;
710 char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
711 char *newline;
712 char *pkg_name = NULL;
713 char *version_str;
714
715 if (argc > 0) {
716 pkg_name = argv[0];
717 }
718 available = pkg_vec_alloc();
719 pkg_hash_fetch_available(&conf->pkg_hash, available);
720 pkg_vec_sort(available, pkg_compare_names);
721 for (i=0; i < available->len; i++) {
722 pkg = available->pkgs[i];
723 /* if we have package name or pattern and pkg does not match, then skip it */
724 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
725 continue;
726 if (pkg->description) {
727 strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
728 } else {
729 desc_short[0] = '\0';
730 }
731 desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
732 newline = strchr(desc_short, '\n');
733 if (newline) {
734 *newline = '\0';
735 }
736 if (opkg_cb_list) {
737 version_str = pkg_version_str_alloc(pkg);
738 opkg_cb_list(pkg->name,desc_short,
739 version_str,
740 pkg->state_status,
741 p_userdata);
742 free(version_str);
743 }
744 }
745 pkg_vec_free(available);
746
747 return 0;
748 }
749
750
751 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv)
752 {
753 int i ;
754 pkg_vec_t *available;
755 pkg_t *pkg;
756 char desc_short[OPKG_LIST_DESCRIPTION_LENGTH];
757 char *newline;
758 char *pkg_name = NULL;
759 char *version_str;
760
761 if (argc > 0) {
762 pkg_name = argv[0];
763 }
764 available = pkg_vec_alloc();
765 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
766 pkg_vec_sort(available, pkg_compare_names);
767 for (i=0; i < available->len; i++) {
768 pkg = available->pkgs[i];
769 /* if we have package name or pattern and pkg does not match, then skip it */
770 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
771 continue;
772 if (pkg->description) {
773 strncpy(desc_short, pkg->description, OPKG_LIST_DESCRIPTION_LENGTH);
774 } else {
775 desc_short[0] = '\0';
776 }
777 desc_short[OPKG_LIST_DESCRIPTION_LENGTH - 1] = '\0';
778 newline = strchr(desc_short, '\n');
779 if (newline) {
780 *newline = '\0';
781 }
782 if (opkg_cb_list) {
783 version_str = pkg_version_str_alloc(pkg);
784 opkg_cb_list(pkg->name,desc_short,
785 version_str,
786 pkg->state_status,
787 p_userdata);
788 free(version_str);
789 }
790 }
791
792 pkg_vec_free(available);
793
794 return 0;
795 }
796
797 static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv)
798 {
799 struct active_list *head = prepare_upgrade_list(conf);
800 struct active_list *node=NULL;
801 pkg_t *_old_pkg, *_new_pkg;
802 char *old_v, *new_v;
803 for (node = active_list_next(head, head); node;node = active_list_next(head,node)) {
804 _old_pkg = list_entry(node, pkg_t, list);
805 _new_pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, _old_pkg->name, NULL);
806 old_v = pkg_version_str_alloc(_old_pkg);
807 new_v = pkg_version_str_alloc(_new_pkg);
808 if (opkg_cb_list)
809 opkg_cb_list(_old_pkg->name, new_v, old_v, _old_pkg->state_status, p_userdata);
810 free(old_v);
811 free(new_v);
812 }
813 active_list_head_delete(head);
814 return 0;
815 }
816
817 static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int installed_only)
818 {
819 int i;
820 pkg_vec_t *available;
821 pkg_t *pkg;
822 char *pkg_name = NULL;
823 char **pkg_fields = NULL;
824 int n_fields = 0;
825 char *buff = NULL;
826
827 if (argc > 0) {
828 pkg_name = argv[0];
829 }
830 if (argc > 1) {
831 pkg_fields = &argv[1];
832 n_fields = argc - 1;
833 }
834
835 available = pkg_vec_alloc();
836 if (installed_only)
837 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
838 else
839 pkg_hash_fetch_available(&conf->pkg_hash, available);
840 for (i=0; i < available->len; i++) {
841 pkg = available->pkgs[i];
842 if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
843 continue;
844 }
845
846 buff = pkg_formatted_info(pkg);
847 if ( buff ) {
848 if (opkg_cb_status) opkg_cb_status(pkg->name,
849 pkg->state_status,
850 buff,
851 p_userdata);
852 /*
853 We should not forget that actually the pointer is allocated.
854 We need to free it :) ( Thanks florian for seeing the error )
855 */
856 free(buff);
857 buff = NULL;
858 }
859 if (conf->verbosity > 1) {
860 conffile_list_elt_t *iter;
861 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
862 conffile_t *cf = (conffile_t *)iter->data;
863 int modified = conffile_has_been_modified(conf, cf);
864 opkg_message(conf, OPKG_NOTICE, "conffile=%s md5sum=%s modified=%d\n",
865 cf->name, cf->value, modified);
866 }
867 }
868 }
869 pkg_vec_free(available);
870
871 return 0;
872 }
873
874 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv)
875 {
876 return opkg_info_status_cmd(conf, argc, argv, 0);
877 }
878
879 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv)
880 {
881 return opkg_info_status_cmd(conf, argc, argv, 1);
882 }
883
884 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv)
885 {
886
887 int err;
888 if (argc > 0) {
889 char *pkg_name = NULL;
890
891 pkg_name = argv[0];
892
893 err = opkg_configure_packages (conf, pkg_name);
894
895 } else {
896 err = opkg_configure_packages (conf, NULL);
897 }
898
899 write_status_files_if_changed(conf);
900
901 return err;
902 }
903
904 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv)
905 {
906 int i, err;
907 char *globpattern;
908 glob_t globbuf;
909
910 sprintf_alloc(&globpattern, "%s/*" OPKG_PKG_EXTENSION, conf->pending_dir);
911 err = glob(globpattern, 0, NULL, &globbuf);
912 free(globpattern);
913 if (err) {
914 return 0;
915 }
916
917 opkg_message(conf, OPKG_NOTICE,
918 "The following packages in %s will now be installed.\n",
919 conf->pending_dir);
920 for (i = 0; i < globbuf.gl_pathc; i++) {
921 opkg_message(conf, OPKG_NOTICE,
922 "%s%s", i == 0 ? "" : " ", globbuf.gl_pathv[i]);
923 }
924 opkg_message(conf, OPKG_NOTICE, "\n");
925 for (i = 0; i < globbuf.gl_pathc; i++) {
926 err = opkg_install_from_file(conf, globbuf.gl_pathv[i]);
927 if (err == 0) {
928 err = unlink(globbuf.gl_pathv[i]);
929 if (err) {
930 opkg_message(conf, OPKG_ERROR,
931 "%s: ERROR: failed to unlink %s: %s\n",
932 __FUNCTION__, globbuf.gl_pathv[i], strerror(err));
933 return err;
934 }
935 }
936 }
937 globfree(&globbuf);
938
939 return err;
940 }
941
942 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv)
943 {
944 int i,a,done;
945 pkg_t *pkg;
946 pkg_t *pkg_to_remove;
947 pkg_vec_t *available;
948 char *pkg_name = NULL;
949 global_conf = conf;
950 signal(SIGINT, sigint_handler);
951
952 // ENH: Add the "no pkg removed" just in case.
953
954 done = 0;
955
956 pkg_info_preinstall_check(conf);
957 if ( argc > 0 ) {
958 available = pkg_vec_alloc();
959 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
960 for (i=0; i < argc; i++) {
961 pkg_name = calloc(1, strlen(argv[i])+2);
962 strcpy(pkg_name,argv[i]);
963 for (a=0; a < available->len; a++) {
964 pkg = available->pkgs[a];
965 if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
966 continue;
967 }
968 if (conf->restrict_to_default_dest) {
969 pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
970 pkg->name,
971 conf->default_dest);
972 } else {
973 pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
974 }
975
976 if (pkg == NULL) {
977 opkg_message(conf, OPKG_ERROR, "Package %s is not installed.\n", pkg->name);
978 continue;
979 }
980 if (pkg->state_status == SS_NOT_INSTALLED) { // Added the control, so every already removed package could be skipped
981 opkg_message(conf, OPKG_ERROR, "Package seems to be %s not installed (STATUS = NOT_INSTALLED).\n", pkg->name);
982 continue;
983 }
984 opkg_remove_pkg(conf, pkg_to_remove,0);
985 done = 1;
986 }
987 free (pkg_name);
988 }
989 pkg_vec_free(available);
990 } else {
991 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
992 int i;
993 int flagged_pkg_count = 0;
994 int removed;
995
996 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed_pkgs);
997
998 for (i = 0; i < installed_pkgs->len; i++) {
999 pkg_t *pkg = installed_pkgs->pkgs[i];
1000 if (pkg->state_flag & SF_USER) {
1001 flagged_pkg_count++;
1002 } else {
1003 if (!pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL))
1004 opkg_message(conf, OPKG_NOTICE, "Non-user leaf package: %s\n", pkg->name);
1005 }
1006 }
1007 if (!flagged_pkg_count) {
1008 opkg_message(conf, OPKG_NOTICE, "No packages flagged as installed by user, \n"
1009 "so refusing to uninstall unflagged non-leaf packages\n");
1010 return 0;
1011 }
1012
1013 /* find packages not flagged SF_USER (i.e., installed to
1014 * satisfy a dependence) and not having any dependents, and
1015 * remove them */
1016 do {
1017 removed = 0;
1018 for (i = 0; i < installed_pkgs->len; i++) {
1019 pkg_t *pkg = installed_pkgs->pkgs[i];
1020 if (!(pkg->state_flag & SF_USER)
1021 && !pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL)) {
1022 removed++;
1023 opkg_message(conf, OPKG_NOTICE, "Removing non-user leaf package %s\n");
1024 opkg_remove_pkg(conf, pkg,0);
1025 done = 1;
1026 }
1027 }
1028 } while (removed);
1029 pkg_vec_free(installed_pkgs);
1030 }
1031
1032 if ( done == 0 )
1033 opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
1034
1035 write_status_files_if_changed(conf);
1036 return 0;
1037 }
1038
1039 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv)
1040 {
1041 int i;
1042 pkg_t *pkg;
1043
1044 global_conf = conf;
1045 signal(SIGINT, sigint_handler);
1046
1047 pkg_info_preinstall_check(conf);
1048
1049 for (i=0; i < argc; i++) {
1050 if (conf->restrict_to_default_dest) {
1051 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1052 argv[i],
1053 conf->default_dest);
1054 } else {
1055 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
1056 }
1057
1058 if (pkg == NULL) {
1059 opkg_message(conf, OPKG_ERROR,
1060 "Package %s is not installed.\n", argv[i]);
1061 continue;
1062 }
1063 opkg_purge_pkg(conf, pkg);
1064 }
1065
1066 write_status_files_if_changed(conf);
1067 return 0;
1068 }
1069
1070 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv)
1071 {
1072 int i;
1073 pkg_t *pkg;
1074 const char *flags = argv[0];
1075
1076 global_conf = conf;
1077 signal(SIGINT, sigint_handler);
1078
1079 for (i=1; i < argc; i++) {
1080 if (conf->restrict_to_default_dest) {
1081 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
1082 argv[i],
1083 conf->default_dest);
1084 } else {
1085 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
1086 }
1087
1088 if (pkg == NULL) {
1089 opkg_message(conf, OPKG_ERROR,
1090 "Package %s is not installed.\n", argv[i]);
1091 continue;
1092 }
1093 if (( strcmp(flags,"hold")==0)||( strcmp(flags,"noprune")==0)||
1094 ( strcmp(flags,"user")==0)||( strcmp(flags,"ok")==0)) {
1095 pkg->state_flag = pkg_state_flag_from_str(flags);
1096 }
1097 /* pb_ asked this feature 03292004 */
1098 /* Actually I will use only this two, but this is an open for various status */
1099 if (( strcmp(flags,"installed")==0)||( strcmp(flags,"unpacked")==0)){
1100 pkg->state_status = pkg_state_status_from_str(flags);
1101 }
1102 opkg_state_changed++;
1103 opkg_message(conf, OPKG_NOTICE,
1104 "Setting flags for package %s to %s\n",
1105 pkg->name, flags);
1106 }
1107
1108 write_status_files_if_changed(conf);
1109 return 0;
1110 }
1111
1112 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
1113 {
1114 pkg_t *pkg;
1115 str_list_t *installed_files;
1116 str_list_elt_t *iter;
1117 char *pkg_version;
1118 size_t buff_len = 8192;
1119 size_t used_len;
1120 char *buff ;
1121
1122 buff = (char *)calloc(1, buff_len);
1123 if ( buff == NULL ) {
1124 fprintf( stderr,"%s: Unable to allocate memory \n",__FUNCTION__);
1125 return ENOMEM;
1126 }
1127
1128 if (argc < 1) {
1129 return EINVAL;
1130 }
1131
1132 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
1133 argv[0]);
1134 if (pkg == NULL) {
1135 opkg_message(conf, OPKG_ERROR,
1136 "Package %s not installed.\n", argv[0]);
1137 return 0;
1138 }
1139
1140 installed_files = pkg_get_installed_files(pkg);
1141 pkg_version = pkg_version_str_alloc(pkg);
1142
1143 if (buff) {
1144 try_again:
1145 used_len = snprintf(buff, buff_len, "Package %s (%s) is installed on %s and has the following files:\n",
1146 pkg->name, pkg_version, pkg->dest->name) + 1;
1147 if (used_len > buff_len) {
1148 buff_len *= 2;
1149 buff = realloc (buff, buff_len);
1150 goto try_again;
1151 }
1152 for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
1153 used_len += strlen (iter->data) + 1;
1154 while (buff_len <= used_len) {
1155 buff_len *= 2;
1156 buff = realloc (buff, buff_len);
1157 }
1158 strncat(buff, iter->data, buff_len);
1159 strncat(buff, "\n", buff_len);
1160 }
1161 if (opkg_cb_list) opkg_cb_list(pkg->name,
1162 buff,
1163 pkg_version_str_alloc(pkg),
1164 pkg->state_status,
1165 p_userdata);
1166 free(buff);
1167 }
1168
1169 free(pkg_version);
1170 pkg_free_installed_files(pkg);
1171
1172 return 0;
1173 }
1174
1175 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv)
1176 {
1177
1178 if (argc > 0) {
1179 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1180 const char *rel_str = "depends on";
1181 int i;
1182
1183 pkg_info_preinstall_check(conf);
1184
1185 if (conf->query_all)
1186 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1187 else
1188 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1189 for (i = 0; i < argc; i++) {
1190 const char *target = argv[i];
1191 int j;
1192
1193 opkg_message(conf, OPKG_ERROR, "target=%s\n", target);
1194
1195 for (j = 0; j < available_pkgs->len; j++) {
1196 pkg_t *pkg = available_pkgs->pkgs[j];
1197 if (fnmatch(target, pkg->name, 0) == 0) {
1198 int k;
1199 int count = pkg->depends_count + pkg->pre_depends_count;
1200 opkg_message(conf, OPKG_ERROR, "What %s (arch=%s) %s\n",
1201 target, pkg->architecture, rel_str);
1202 for (k = 0; k < count; k++) {
1203 compound_depend_t *cdepend = &pkg->depends[k];
1204 int l;
1205 for (l = 0; l < cdepend->possibility_count; l++) {
1206 depend_t *possibility = cdepend->possibilities[l];
1207 opkg_message(conf, OPKG_ERROR, " %s", possibility->pkg->name);
1208 if (conf->verbosity > 0) {
1209 // char *ver = abstract_pkg_version_str_alloc(possibility->pkg);
1210 opkg_message(conf, OPKG_NOTICE, " %s", possibility->version);
1211 if (possibility->version) {
1212 char *typestr = NULL;
1213 switch (possibility->constraint) {
1214 case NONE: typestr = "none"; break;
1215 case EARLIER: typestr = "<"; break;
1216 case EARLIER_EQUAL: typestr = "<="; break;
1217 case EQUAL: typestr = "="; break;
1218 case LATER_EQUAL: typestr = ">="; break;
1219 case LATER: typestr = ">"; break;
1220 }
1221 opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1222 }
1223 // free(ver);
1224 }
1225 opkg_message(conf, OPKG_ERROR, "\n");
1226 }
1227 }
1228 }
1229 }
1230 }
1231 pkg_vec_free(available_pkgs);
1232 }
1233 return 0;
1234 }
1235
1236 enum what_field_type {
1237 WHATDEPENDS,
1238 WHATCONFLICTS,
1239 WHATPROVIDES,
1240 WHATREPLACES,
1241 WHATRECOMMENDS,
1242 WHATSUGGESTS
1243 };
1244
1245 static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int recursive, int argc, char **argv)
1246 {
1247
1248 if (argc > 0) {
1249 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1250 const char *rel_str = NULL;
1251 int i;
1252 int changed;
1253
1254 switch (what_field_type) {
1255 case WHATDEPENDS: rel_str = "depends on"; break;
1256 case WHATCONFLICTS: rel_str = "conflicts with"; break;
1257 case WHATSUGGESTS: rel_str = "suggests"; break;
1258 case WHATRECOMMENDS: rel_str = "recommends"; break;
1259 case WHATPROVIDES: rel_str = "provides"; break;
1260 case WHATREPLACES: rel_str = "replaces"; break;
1261 }
1262
1263 if (conf->query_all)
1264 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1265 else
1266 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1267
1268 /* mark the root set */
1269 pkg_vec_clear_marks(available_pkgs);
1270 opkg_message(conf, OPKG_NOTICE, "Root set:\n");
1271 for (i = 0; i < argc; i++) {
1272 const char *dependee_pattern = argv[i];
1273 pkg_vec_mark_if_matches(available_pkgs, dependee_pattern);
1274 }
1275 for (i = 0; i < available_pkgs->len; i++) {
1276 pkg_t *pkg = available_pkgs->pkgs[i];
1277 if (pkg->state_flag & SF_MARKED) {
1278 /* mark the parent (abstract) package */
1279 pkg_mark_provides(pkg);
1280 opkg_message(conf, OPKG_NOTICE, " %s\n", pkg->name);
1281 }
1282 }
1283
1284 opkg_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str);
1285 do {
1286 int j;
1287 changed = 0;
1288
1289 for (j = 0; j < available_pkgs->len; j++) {
1290 pkg_t *pkg = available_pkgs->pkgs[j];
1291 int k;
1292 int count = ((what_field_type == WHATCONFLICTS)
1293 ? pkg->conflicts_count
1294 : pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count);
1295 /* skip this package if it is already marked */
1296 if (pkg->parent->state_flag & SF_MARKED) {
1297 continue;
1298 }
1299 for (k = 0; k < count; k++) {
1300 compound_depend_t *cdepend =
1301 (what_field_type == WHATCONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
1302 int l;
1303 for (l = 0; l < cdepend->possibility_count; l++) {
1304 depend_t *possibility = cdepend->possibilities[l];
1305 if (possibility->pkg->state_flag & SF_MARKED) {
1306 /* mark the depending package so we won't visit it again */
1307 pkg->state_flag |= SF_MARKED;
1308 pkg_mark_provides(pkg);
1309 changed++;
1310
1311 opkg_message(conf, OPKG_NOTICE, " %s", pkg->name);
1312 if (conf->verbosity > 0) {
1313 char *ver = pkg_version_str_alloc(pkg);
1314 opkg_message(conf, OPKG_NOTICE, " %s", ver);
1315 opkg_message(conf, OPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
1316 if (possibility->version) {
1317 char *typestr = NULL;
1318 switch (possibility->constraint) {
1319 case NONE: typestr = "none"; break;
1320 case EARLIER: typestr = "<"; break;
1321 case EARLIER_EQUAL: typestr = "<="; break;
1322 case EQUAL: typestr = "="; break;
1323 case LATER_EQUAL: typestr = ">="; break;
1324 case LATER: typestr = ">"; break;
1325 }
1326 opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1327 }
1328 free(ver);
1329 if (!pkg_dependence_satisfiable(conf, possibility))
1330 opkg_message(conf, OPKG_NOTICE, " unsatisfiable");
1331 }
1332 opkg_message(conf, OPKG_NOTICE, "\n");
1333 goto next_package;
1334 }
1335 }
1336 }
1337 next_package:
1338 ;
1339 }
1340 } while (changed && recursive);
1341 pkg_vec_free(available_pkgs);
1342 }
1343
1344 return 0;
1345 }
1346
1347 static int pkg_mark_provides(pkg_t *pkg)
1348 {
1349 int provides_count = pkg->provides_count;
1350 abstract_pkg_t **provides = pkg->provides;
1351 int i;
1352 pkg->parent->state_flag |= SF_MARKED;
1353 for (i = 0; i < provides_count; i++) {
1354 provides[i]->state_flag |= SF_MARKED;
1355 }
1356 return 0;
1357 }
1358
1359 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv)
1360 {
1361 return opkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 1, argc, argv);
1362 }
1363 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv)
1364 {
1365 return opkg_what_depends_conflicts_cmd(conf, WHATDEPENDS, 0, argc, argv);
1366 }
1367
1368 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv)
1369 {
1370 return opkg_what_depends_conflicts_cmd(conf, WHATSUGGESTS, 0, argc, argv);
1371 }
1372
1373 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv)
1374 {
1375 return opkg_what_depends_conflicts_cmd(conf, WHATRECOMMENDS, 0, argc, argv);
1376 }
1377
1378 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv)
1379 {
1380 return opkg_what_depends_conflicts_cmd(conf, WHATCONFLICTS, 0, argc, argv);
1381 }
1382
1383 static int opkg_what_provides_replaces_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int argc, char **argv)
1384 {
1385
1386 if (argc > 0) {
1387 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1388 const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
1389 int i;
1390
1391 pkg_info_preinstall_check(conf);
1392
1393 if (conf->query_all)
1394 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1395 else
1396 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1397 for (i = 0; i < argc; i++) {
1398 const char *target = argv[i];
1399 int j;
1400
1401 opkg_message(conf, OPKG_ERROR, "What %s %s\n",
1402 rel_str, target);
1403 for (j = 0; j < available_pkgs->len; j++) {
1404 pkg_t *pkg = available_pkgs->pkgs[j];
1405 int k;
1406 int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
1407 for (k = 0; k < count; k++) {
1408 abstract_pkg_t *apkg =
1409 ((what_field_type == WHATPROVIDES)
1410 ? pkg->provides[k]
1411 : pkg->replaces[k]);
1412 if (fnmatch(target, apkg->name, 0) == 0) {
1413 opkg_message(conf, OPKG_ERROR, " %s", pkg->name);
1414 if (strcmp(target, apkg->name) != 0)
1415 opkg_message(conf, OPKG_ERROR, "\t%s %s\n", rel_str, apkg->name);
1416 opkg_message(conf, OPKG_ERROR, "\n");
1417 }
1418 }
1419 }
1420 }
1421 pkg_vec_free(available_pkgs);
1422 }
1423 return 0;
1424 }
1425
1426 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv)
1427 {
1428 return opkg_what_provides_replaces_cmd(conf, WHATPROVIDES, argc, argv);
1429 }
1430
1431 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv)
1432 {
1433 return opkg_what_provides_replaces_cmd(conf, WHATREPLACES, argc, argv);
1434 }
1435
1436 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv)
1437 {
1438 int i;
1439
1440 pkg_vec_t *installed;
1441 pkg_t *pkg;
1442 str_list_t *installed_files;
1443 str_list_elt_t *iter;
1444 char *installed_file;
1445
1446 if (argc < 1) {
1447 return EINVAL;
1448 }
1449
1450 installed = pkg_vec_alloc();
1451 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
1452 pkg_vec_sort(installed, pkg_compare_names);
1453
1454 for (i=0; i < installed->len; i++) {
1455 pkg = installed->pkgs[i];
1456
1457 installed_files = pkg_get_installed_files(pkg);
1458
1459 for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
1460 installed_file = (char *)iter->data;
1461 if (fnmatch(argv[0], installed_file, 0)==0) {
1462 if (opkg_cb_list) opkg_cb_list(pkg->name,
1463 installed_file,
1464 pkg_version_str_alloc(pkg),
1465 pkg->state_status, p_userdata);
1466 }
1467 }
1468
1469 pkg_free_installed_files(pkg);
1470 }
1471
1472 pkg_vec_free(installed);
1473
1474 return 0;
1475 }
1476
1477 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv)
1478 {
1479 if (argc == 3) {
1480 /* this is a bit gross */
1481 struct pkg p1, p2;
1482 parseVersion(&p1, argv[0]);
1483 parseVersion(&p2, argv[2]);
1484 return pkg_version_satisfied(&p1, &p2, argv[1]);
1485 } else {
1486 opkg_message(conf, OPKG_ERROR,
1487 "opkg compare_versions <v1> <op> <v2>\n"
1488 "<op> is one of <= >= << >> =\n");
1489 return -1;
1490 }
1491 }
1492
1493 #ifndef HOST_CPU_STR
1494 #define HOST_CPU_STR__(X) #X
1495 #define HOST_CPU_STR_(X) HOST_CPU_STR__(X)
1496 #define HOST_CPU_STR HOST_CPU_STR_(HOST_CPU_FOO)
1497 #endif
1498
1499 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv)
1500 {
1501 nv_pair_list_elt_t *l;
1502
1503 list_for_each_entry(l, &conf->arch_list.head, node) {
1504 nv_pair_t *nv = (nv_pair_t *)l->data;
1505 printf("arch %s %s\n", nv->name, nv->value);
1506 }
1507 return 0;
1508 }
1509
1510
LEDE fork of Opkg