projects / project / opkg-lede.git / blob
? search:


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