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


a90c6a9d51ce6bfdf63b9ec68ce861425242d022
[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 #include <fnmatch.h>
23
24 #include "opkg_conf.h"
25 #include "opkg_cmd.h"
26 #include "opkg_message.h"
27 #include "pkg.h"
28 #include "pkg_dest.h"
29 #include "pkg_parse.h"
30 #include "sprintf_alloc.h"
31 #include "pkg.h"
32 #include "file_util.h"
33 #include "str_util.h"
34 #include "libbb/libbb.h"
35 #include "opkg_utils.h"
36 #include "opkg_defines.h"
37 #include "opkg_download.h"
38 #include "opkg_install.h"
39 #include "opkg_upgrade.h"
40 #include "opkg_remove.h"
41 #include "opkg_configure.h"
42 #include "opkg_message.h"
43 #include "libopkg.h"
44 #include "xsystem.h"
45
46 static int opkg_update_cmd(opkg_conf_t *conf, int argc, char **argv);
47 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv);
48 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv);
49 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv);
50 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv);
51 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv);
52 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv);
53 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv);
54 static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv);
55 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv);
56 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv);
57 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv);
58 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv);
59 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv);
60 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv);
61 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv);
62 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv);
63 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv);
64 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv);
65 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv);
66 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv);
67 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv);
68 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv);
69 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv);
70 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv);
71 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv);
72 static int pkg_mark_provides(pkg_t *pkg);
73
74 /* XXX: CLEANUP: The usage strings should be incorporated into this
75 array for easier maintenance */
76 static opkg_cmd_t cmds[] = {
77 {"update", 0, (opkg_cmd_fun_t)opkg_update_cmd},
78 {"upgrade", 0, (opkg_cmd_fun_t)opkg_upgrade_cmd},
79 {"list", 0, (opkg_cmd_fun_t)opkg_list_cmd},
80 {"list_installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd},
81 {"list-installed", 0, (opkg_cmd_fun_t)opkg_list_installed_cmd},
82 {"list_upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd},
83 {"list-upgradable", 0, (opkg_cmd_fun_t)opkg_list_upgradable_cmd},
84 {"info", 0, (opkg_cmd_fun_t)opkg_info_cmd},
85 {"flag", 1, (opkg_cmd_fun_t)opkg_flag_cmd},
86 {"status", 0, (opkg_cmd_fun_t)opkg_status_cmd},
87 {"install_pending", 0, (opkg_cmd_fun_t)opkg_install_pending_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 DIR *dir;
330 int err = 0;
331
332 setenv ("PATH", ctx->oldpath, 1);
333 free (ctx->oldpath);
334
335 dir = opendir (ctx->statedir);
336 if (dir) {
337 struct dirent *de;
338 while (de = readdir (dir), de != NULL) {
339 char *path;
340
341 if (de->d_name[0] == '.')
342 continue;
343
344 sprintf_alloc (&path, "%s/%s", ctx->statedir, de->d_name);
345 if (access (path, X_OK) == 0) {
346 const char *argv[] = {"sh", "-c", path, NULL};
347 xsystem (argv);
348 }
349 free (path);
350 }
351 closedir(dir);
352 } else
353 perror (ctx->statedir);
354
355 rm_r(ctx->statedir);
356 free (ctx->statedir);
357 free (ctx);
358
359 return err;
360 }
361
362 /* For package pkg do the following: If it is already visited, return. If not,
363 add it in visited list and recurse to its deps. Finally, add it to ordered
364 list.
365 pkg_vec all contains all available packages in repos.
366 pkg_vec visited contains packages already visited by this function, and is
367 used to end recursion and avoid an infinite loop on graph cycles.
368 pkg_vec ordered will finally contain the ordered set of packages.
369 */
370 static int opkg_recurse_pkgs_in_order(opkg_conf_t *conf, pkg_t *pkg, pkg_vec_t *all,
371 pkg_vec_t *visited, pkg_vec_t *ordered)
372 {
373 int j,k,l,m;
374 int count;
375 pkg_t *dep;
376 compound_depend_t * compound_depend;
377 depend_t ** possible_satisfiers;
378 abstract_pkg_t *abpkg;
379 abstract_pkg_t **dependents;
380
381 /* If it's just an available package, that is, not installed and not even
382 unpacked, skip it */
383 /* XXX: This is probably an overkill, since a state_status != SS_UNPACKED
384 would do here. However, if there is an intermediate node (pkg) that is
385 configured and installed between two unpacked packages, the latter
386 won't be properly reordered, unless all installed/unpacked pkgs are
387 checked */
388 if (pkg->state_status == SS_NOT_INSTALLED)
389 return 0;
390
391 /* If the package has already been visited (by this function), skip it */
392 for(j = 0; j < visited->len; j++)
393 if ( ! strcmp(visited->pkgs[j]->name, pkg->name)) {
394 opkg_message(conf, OPKG_INFO,
395 " pkg: %s already visited\n", pkg->name);
396 return 0;
397 }
398
399 pkg_vec_insert(visited, pkg);
400
401 count = pkg->pre_depends_count + pkg->depends_count + \
402 pkg->recommends_count + pkg->suggests_count;
403
404 opkg_message(conf, OPKG_INFO,
405 " pkg: %s\n", pkg->name);
406
407 /* Iterate over all the dependencies of pkg. For each one, find a package
408 that is either installed or unpacked and satisfies this dependency.
409 (there should only be one such package per dependency installed or
410 unpacked). Then recurse to the dependency package */
411 for (j=0; j < count ; j++) {
412 compound_depend = &pkg->depends[j];
413 possible_satisfiers = compound_depend->possibilities;
414 for (k=0; k < compound_depend->possibility_count ; k++) {
415 abpkg = possible_satisfiers[k]->pkg;
416 dependents = abpkg->provided_by->pkgs;
417 l = 0;
418 if (dependents != NULL)
419 while (l < abpkg->provided_by->len && dependents[l] != NULL) {
420 opkg_message(conf, OPKG_INFO,
421 " Descending on pkg: %s\n",
422 dependents [l]->name);
423
424 /* find whether dependent l is installed or unpacked,
425 * and then find which package in the list satisfies it */
426 for(m = 0; m < all->len; m++) {
427 dep = all->pkgs[m];
428 if ( dep->state_status != SS_NOT_INSTALLED)
429 if ( ! strcmp(dep->name, dependents[l]->name)) {
430 opkg_recurse_pkgs_in_order(conf, dep, all,
431 visited, ordered);
432 /* Stop the outer loop */
433 l = abpkg->provided_by->len;
434 /* break from the inner loop */
435 break;
436 }
437 }
438 l++;
439 }
440 }
441 }
442
443 /* When all recursions from this node down, are over, and all
444 dependencies have been added in proper order in the ordered array, add
445 also the package pkg to ordered array */
446 pkg_vec_insert(ordered, pkg);
447
448 return 0;
449
450 }
451
452 static int opkg_configure_packages(opkg_conf_t *conf, char *pkg_name)
453 {
454 pkg_vec_t *all, *ordered, *visited;
455 int i;
456 pkg_t *pkg;
457 opkg_intercept_t ic;
458 int r, err = 0;
459
460 opkg_message(conf, OPKG_INFO,
461 "Configuring unpacked packages\n");
462 fflush( stdout );
463
464 all = pkg_vec_alloc();
465
466 pkg_hash_fetch_available(&conf->pkg_hash, all);
467
468 /* Reorder pkgs in order to be configured according to the Depends: tag
469 order */
470 opkg_message(conf, OPKG_INFO,
471 "Reordering packages before configuring them...\n");
472 ordered = pkg_vec_alloc();
473 visited = pkg_vec_alloc();
474 for(i = 0; i < all->len; i++) {
475 pkg = all->pkgs[i];
476 opkg_recurse_pkgs_in_order(conf, pkg, all, visited, ordered);
477 }
478
479 ic = opkg_prep_intercepts (conf);
480 if (ic == NULL) {
481 err = -1;
482 goto error;
483 }
484
485 for(i = 0; i < all->len; i++) {
486 pkg = all->pkgs[i];
487
488 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
489 continue;
490
491 if (pkg->state_status == SS_UNPACKED) {
492 opkg_message(conf, OPKG_NOTICE,
493 "Configuring %s\n", pkg->name);
494 fflush( stdout );
495 r = opkg_configure(conf, pkg);
496 if (r == 0) {
497 pkg->state_status = SS_INSTALLED;
498 pkg->parent->state_status = SS_INSTALLED;
499 pkg->state_flag &= ~SF_PREFER;
500 } else {
501 if (!err)
502 err = r;
503 }
504 }
505 }
506
507 r = opkg_finalize_intercepts (ic);
508 if (r && !err)
509 err = r;
510
511 error:
512 pkg_vec_free(all);
513 pkg_vec_free(ordered);
514 pkg_vec_free(visited);
515
516 return err;
517 }
518
519 static opkg_conf_t *global_conf;
520
521 static void sigint_handler(int sig)
522 {
523 signal(sig, SIG_DFL);
524 opkg_message(NULL, OPKG_NOTICE,
525 "opkg: interrupted. writing out status database\n");
526 write_status_files_if_changed(global_conf);
527 exit(128 + sig);
528 }
529
530 static int opkg_install_cmd(opkg_conf_t *conf, int argc, char **argv)
531 {
532 int i;
533 char *arg;
534 int err=0;
535
536 global_conf = conf;
537 signal(SIGINT, sigint_handler);
538
539 /*
540 * Now scan through package names and install
541 */
542 for (i=0; i < argc; i++) {
543 arg = argv[i];
544
545 opkg_message(conf, OPKG_DEBUG2, "Debug install_cmd: %s \n",arg );
546 err = opkg_prepare_url_for_install(conf, arg, &argv[i]);
547 if (err != EINVAL && err != 0)
548 return err;
549 }
550 pkg_info_preinstall_check(conf);
551
552 for (i=0; i < argc; i++) {
553 arg = argv[i];
554 err = opkg_install_by_name(conf, arg);
555 if (err == OPKG_PKG_HAS_NO_CANDIDATE) {
556 opkg_message(conf, OPKG_ERROR,
557 "Cannot find package %s.\n",
558 arg);
559 }
560 }
561
562 opkg_configure_packages(conf, NULL);
563
564 write_status_files_if_changed(conf);
565
566 return err;
567 }
568
569 static int opkg_upgrade_cmd(opkg_conf_t *conf, int argc, char **argv)
570 {
571 int i;
572 pkg_t *pkg;
573 int err;
574
575 global_conf = conf;
576 signal(SIGINT, sigint_handler);
577
578 if (argc) {
579 for (i=0; i < argc; i++) {
580 char *arg = argv[i];
581
582 err = opkg_prepare_url_for_install(conf, arg, &arg);
583 if (err != EINVAL && err != 0)
584 return err;
585 }
586 pkg_info_preinstall_check(conf);
587
588 for (i=0; i < argc; i++) {
589 char *arg = argv[i];
590 if (conf->restrict_to_default_dest) {
591 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
592 argv[i],
593 conf->default_dest);
594 if (pkg == NULL) {
595 opkg_message(conf, OPKG_NOTICE,
596 "Package %s not installed in %s\n",
597 argv[i], conf->default_dest->name);
598 continue;
599 }
600 } else {
601 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
602 argv[i]);
603 }
604 if (pkg)
605 opkg_upgrade_pkg(conf, pkg);
606 else {
607 opkg_install_by_name(conf, arg);
608 }
609 }
610 } else {
611 pkg_vec_t *installed = pkg_vec_alloc();
612
613 pkg_info_preinstall_check(conf);
614
615 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
616 for (i = 0; i < installed->len; i++) {
617 pkg = installed->pkgs[i];
618 opkg_upgrade_pkg(conf, pkg);
619 }
620 pkg_vec_free(installed);
621 }
622
623 opkg_configure_packages(conf, NULL);
624
625 write_status_files_if_changed(conf);
626
627 return 0;
628 }
629
630 static int opkg_download_cmd(opkg_conf_t *conf, int argc, char **argv)
631 {
632 int i, err;
633 char *arg;
634 pkg_t *pkg;
635
636 pkg_info_preinstall_check(conf);
637 for (i = 0; i < argc; i++) {
638 arg = argv[i];
639
640 pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, arg, &err);
641 if (pkg == NULL) {
642 opkg_message(conf, OPKG_ERROR,
643 "Cannot find package %s.\n"
644 "Check the spelling or perhaps run 'opkg update'\n",
645 arg);
646 continue;
647 }
648
649 err = opkg_download_pkg(conf, pkg, ".");
650
651 if (err) {
652 opkg_message(conf, OPKG_ERROR,
653 "Failed to download %s\n", pkg->name);
654 } else {
655 opkg_message(conf, OPKG_NOTICE,
656 "Downloaded %s as %s\n",
657 pkg->name, pkg->local_filename);
658 }
659 }
660
661 return 0;
662 }
663
664
665 static int opkg_list_cmd(opkg_conf_t *conf, int argc, char **argv)
666 {
667 int i;
668 pkg_vec_t *available;
669 pkg_t *pkg;
670 char *pkg_name = NULL;
671
672 if (argc > 0) {
673 pkg_name = argv[0];
674 }
675 available = pkg_vec_alloc();
676 pkg_hash_fetch_available(&conf->pkg_hash, available);
677 pkg_vec_sort(available, pkg_compare_names);
678 for (i=0; i < available->len; i++) {
679 pkg = available->pkgs[i];
680 /* if we have package name or pattern and pkg does not match, then skip it */
681 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
682 continue;
683 print_pkg(pkg);
684 }
685 pkg_vec_free(available);
686
687 return 0;
688 }
689
690
691 static int opkg_list_installed_cmd(opkg_conf_t *conf, int argc, char **argv)
692 {
693 int i ;
694 pkg_vec_t *available;
695 pkg_t *pkg;
696 char *pkg_name = NULL;
697
698 if (argc > 0) {
699 pkg_name = argv[0];
700 }
701 available = pkg_vec_alloc();
702 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
703 pkg_vec_sort(available, pkg_compare_names);
704 for (i=0; i < available->len; i++) {
705 pkg = available->pkgs[i];
706 /* if we have package name or pattern and pkg does not match, then skip it */
707 if (pkg_name && fnmatch(pkg_name, pkg->name, 0))
708 continue;
709 print_pkg(pkg);
710 }
711
712 pkg_vec_free(available);
713
714 return 0;
715 }
716
717 static int opkg_list_upgradable_cmd(opkg_conf_t *conf, int argc, char **argv)
718 {
719 struct active_list *head = prepare_upgrade_list(conf);
720 struct active_list *node=NULL;
721 pkg_t *_old_pkg, *_new_pkg;
722 char *old_v, *new_v;
723 for (node = active_list_next(head, head); node;node = active_list_next(head,node)) {
724 _old_pkg = list_entry(node, pkg_t, list);
725 _new_pkg = pkg_hash_fetch_best_installation_candidate_by_name(conf, _old_pkg->name, NULL);
726 old_v = pkg_version_str_alloc(_old_pkg);
727 new_v = pkg_version_str_alloc(_new_pkg);
728 printf("%s - %s - %s\n", _old_pkg->name, old_v, new_v);
729 free(old_v);
730 free(new_v);
731 }
732 active_list_head_delete(head);
733 return 0;
734 }
735
736 static int opkg_info_status_cmd(opkg_conf_t *conf, int argc, char **argv, int installed_only)
737 {
738 int i;
739 pkg_vec_t *available;
740 pkg_t *pkg;
741 char *pkg_name = NULL;
742
743 if (argc > 0) {
744 pkg_name = argv[0];
745 }
746
747 available = pkg_vec_alloc();
748 if (installed_only)
749 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
750 else
751 pkg_hash_fetch_available(&conf->pkg_hash, available);
752
753 for (i=0; i < available->len; i++) {
754 pkg = available->pkgs[i];
755 if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
756 continue;
757 }
758
759 pkg_formatted_info(stdout, pkg);
760
761 if (conf->verbosity >= OPKG_NOTICE) {
762 conffile_list_elt_t *iter;
763 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
764 conffile_t *cf = (conffile_t *)iter->data;
765 int modified = conffile_has_been_modified(conf, cf);
766 if (cf->value)
767 opkg_message(conf, OPKG_NOTICE,
768 "conffile=%s md5sum=%s modified=%d\n",
769 cf->name, cf->value, modified);
770 }
771 }
772 }
773 pkg_vec_free(available);
774
775 return 0;
776 }
777
778 static int opkg_info_cmd(opkg_conf_t *conf, int argc, char **argv)
779 {
780 return opkg_info_status_cmd(conf, argc, argv, 0);
781 }
782
783 static int opkg_status_cmd(opkg_conf_t *conf, int argc, char **argv)
784 {
785 return opkg_info_status_cmd(conf, argc, argv, 1);
786 }
787
788 static int opkg_configure_cmd(opkg_conf_t *conf, int argc, char **argv)
789 {
790
791 int err;
792 if (argc > 0) {
793 char *pkg_name = NULL;
794
795 pkg_name = argv[0];
796
797 err = opkg_configure_packages (conf, pkg_name);
798
799 } else {
800 err = opkg_configure_packages (conf, NULL);
801 }
802
803 write_status_files_if_changed(conf);
804
805 return err;
806 }
807
808 static int opkg_install_pending_cmd(opkg_conf_t *conf, int argc, char **argv)
809 {
810 int i, err;
811 char *globpattern;
812 glob_t globbuf;
813
814 sprintf_alloc(&globpattern, "%s/*" OPKG_PKG_EXTENSION, conf->pending_dir);
815 err = glob(globpattern, 0, NULL, &globbuf);
816 free(globpattern);
817 if (err) {
818 return 0;
819 }
820
821 opkg_message(conf, OPKG_NOTICE,
822 "The following packages in %s will now be installed.\n",
823 conf->pending_dir);
824 for (i = 0; i < globbuf.gl_pathc; i++) {
825 opkg_message(conf, OPKG_NOTICE,
826 "%s%s", i == 0 ? "" : " ", globbuf.gl_pathv[i]);
827 }
828 opkg_message(conf, OPKG_NOTICE, "\n");
829 for (i = 0; i < globbuf.gl_pathc; i++) {
830 err = opkg_install_from_file(conf, globbuf.gl_pathv[i]);
831 if (err == 0) {
832 err = unlink(globbuf.gl_pathv[i]);
833 if (err) {
834 opkg_message(conf, OPKG_ERROR,
835 "%s: ERROR: failed to unlink %s: %s\n",
836 __FUNCTION__, globbuf.gl_pathv[i], strerror(err));
837 return err;
838 }
839 }
840 }
841 globfree(&globbuf);
842
843 return err;
844 }
845
846 static int opkg_remove_cmd(opkg_conf_t *conf, int argc, char **argv)
847 {
848 int i,a,done;
849 pkg_t *pkg;
850 pkg_t *pkg_to_remove;
851 pkg_vec_t *available;
852 char *pkg_name = NULL;
853 global_conf = conf;
854 signal(SIGINT, sigint_handler);
855
856 // ENH: Add the "no pkg removed" just in case.
857
858 done = 0;
859
860 pkg_info_preinstall_check(conf);
861 if ( argc > 0 ) {
862 available = pkg_vec_alloc();
863 pkg_hash_fetch_all_installed(&conf->pkg_hash, available);
864 for (i=0; i < argc; i++) {
865 pkg_name = xcalloc(1, strlen(argv[i])+2);
866 strcpy(pkg_name,argv[i]);
867 for (a=0; a < available->len; a++) {
868 pkg = available->pkgs[a];
869 if (pkg_name && fnmatch(pkg_name, pkg->name, 0)) {
870 continue;
871 }
872 if (conf->restrict_to_default_dest) {
873 pkg_to_remove = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
874 pkg->name,
875 conf->default_dest);
876 } else {
877 pkg_to_remove = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, pkg->name );
878 }
879
880 if (pkg_to_remove == NULL) {
881 opkg_message(conf, OPKG_ERROR, "Package %s is not installed.\n", pkg->name);
882 continue;
883 }
884 if (pkg->state_status == SS_NOT_INSTALLED) { // Added the control, so every already removed package could be skipped
885 opkg_message(conf, OPKG_ERROR, "Package seems to be %s not installed (STATUS = NOT_INSTALLED).\n", pkg->name);
886 continue;
887 }
888 opkg_remove_pkg(conf, pkg_to_remove,0);
889 done = 1;
890 }
891 free (pkg_name);
892 }
893 pkg_vec_free(available);
894 } else {
895 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
896 int i;
897 int flagged_pkg_count = 0;
898 int removed;
899
900 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed_pkgs);
901
902 for (i = 0; i < installed_pkgs->len; i++) {
903 pkg_t *pkg = installed_pkgs->pkgs[i];
904 if (pkg->state_flag & SF_USER) {
905 flagged_pkg_count++;
906 } else {
907 if (!pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL))
908 opkg_message(conf, OPKG_NOTICE, "Non-user leaf package: %s\n", pkg->name);
909 }
910 }
911 if (!flagged_pkg_count) {
912 opkg_message(conf, OPKG_NOTICE, "No packages flagged as installed by user, \n"
913 "so refusing to uninstall unflagged non-leaf packages\n");
914 return 0;
915 }
916
917 /* find packages not flagged SF_USER (i.e., installed to
918 * satisfy a dependence) and not having any dependents, and
919 * remove them */
920 do {
921 removed = 0;
922 for (i = 0; i < installed_pkgs->len; i++) {
923 pkg_t *pkg = installed_pkgs->pkgs[i];
924 if (!(pkg->state_flag & SF_USER)
925 && !pkg_has_installed_dependents(conf, pkg->parent, pkg, NULL)) {
926 removed++;
927 opkg_message(conf, OPKG_NOTICE, "Removing non-user leaf package %s\n");
928 opkg_remove_pkg(conf, pkg,0);
929 done = 1;
930 }
931 }
932 } while (removed);
933 pkg_vec_free(installed_pkgs);
934 }
935
936 if ( done == 0 )
937 opkg_message(conf, OPKG_NOTICE, "No packages removed.\n");
938
939 write_status_files_if_changed(conf);
940 return 0;
941 }
942
943 static int opkg_purge_cmd(opkg_conf_t *conf, int argc, char **argv)
944 {
945 int i;
946 pkg_t *pkg;
947
948 global_conf = conf;
949 signal(SIGINT, sigint_handler);
950
951 pkg_info_preinstall_check(conf);
952
953 for (i=0; i < argc; i++) {
954 if (conf->restrict_to_default_dest) {
955 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
956 argv[i],
957 conf->default_dest);
958 } else {
959 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
960 }
961
962 if (pkg == NULL) {
963 opkg_message(conf, OPKG_ERROR,
964 "Package %s is not installed.\n", argv[i]);
965 continue;
966 }
967 opkg_purge_pkg(conf, pkg);
968 }
969
970 write_status_files_if_changed(conf);
971 return 0;
972 }
973
974 static int opkg_flag_cmd(opkg_conf_t *conf, int argc, char **argv)
975 {
976 int i;
977 pkg_t *pkg;
978 const char *flags = argv[0];
979
980 global_conf = conf;
981 signal(SIGINT, sigint_handler);
982
983 for (i=1; i < argc; i++) {
984 if (conf->restrict_to_default_dest) {
985 pkg = pkg_hash_fetch_installed_by_name_dest(&conf->pkg_hash,
986 argv[i],
987 conf->default_dest);
988 } else {
989 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash, argv[i]);
990 }
991
992 if (pkg == NULL) {
993 opkg_message(conf, OPKG_ERROR,
994 "Package %s is not installed.\n", argv[i]);
995 continue;
996 }
997 if (( strcmp(flags,"hold")==0)||( strcmp(flags,"noprune")==0)||
998 ( strcmp(flags,"user")==0)||( strcmp(flags,"ok")==0)) {
999 pkg->state_flag = pkg_state_flag_from_str(flags);
1000 }
1001 /* pb_ asked this feature 03292004 */
1002 /* Actually I will use only this two, but this is an open for various status */
1003 if (( strcmp(flags,"installed")==0)||( strcmp(flags,"unpacked")==0)){
1004 pkg->state_status = pkg_state_status_from_str(flags);
1005 }
1006 opkg_state_changed++;
1007 opkg_message(conf, OPKG_NOTICE,
1008 "Setting flags for package %s to %s\n",
1009 pkg->name, flags);
1010 }
1011
1012 write_status_files_if_changed(conf);
1013 return 0;
1014 }
1015
1016 static int opkg_files_cmd(opkg_conf_t *conf, int argc, char **argv)
1017 {
1018 pkg_t *pkg;
1019 str_list_t *files;
1020 str_list_elt_t *iter;
1021 char *pkg_version;
1022
1023 if (argc < 1) {
1024 return EINVAL;
1025 }
1026
1027 pkg = pkg_hash_fetch_installed_by_name(&conf->pkg_hash,
1028 argv[0]);
1029 if (pkg == NULL) {
1030 opkg_message(conf, OPKG_ERROR,
1031 "Package %s not installed.\n", argv[0]);
1032 return 0;
1033 }
1034
1035 files = pkg_get_installed_files(conf, pkg);
1036 pkg_version = pkg_version_str_alloc(pkg);
1037
1038 printf("Package %s (%s) is installed on %s and has the following files:\n",
1039 pkg->name, pkg_version, pkg->dest->name);
1040
1041 for (iter=str_list_first(files); iter; iter=str_list_next(files, iter))
1042 printf("%s\n", (char *)iter->data);
1043
1044 free(pkg_version);
1045 pkg_free_installed_files(pkg);
1046
1047 return 0;
1048 }
1049
1050 static int opkg_depends_cmd(opkg_conf_t *conf, int argc, char **argv)
1051 {
1052
1053 if (argc > 0) {
1054 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1055 const char *rel_str = "depends on";
1056 int i;
1057
1058 pkg_info_preinstall_check(conf);
1059
1060 if (conf->query_all)
1061 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1062 else
1063 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1064 for (i = 0; i < argc; i++) {
1065 const char *target = argv[i];
1066 int j;
1067
1068 opkg_message(conf, OPKG_NOTICE, "target=%s\n", target);
1069
1070 for (j = 0; j < available_pkgs->len; j++) {
1071 pkg_t *pkg = available_pkgs->pkgs[j];
1072 if (fnmatch(target, pkg->name, 0) == 0) {
1073 int k;
1074 int count = pkg->depends_count + pkg->pre_depends_count;
1075 opkg_message(conf, OPKG_NOTICE, "What %s (arch=%s) %s\n",
1076 target, pkg->architecture, rel_str);
1077 for (k = 0; k < count; k++) {
1078 compound_depend_t *cdepend = &pkg->depends[k];
1079 int l;
1080 for (l = 0; l < cdepend->possibility_count; l++) {
1081 depend_t *possibility = cdepend->possibilities[l];
1082 opkg_message(conf, OPKG_NOTICE, " %s", possibility->pkg->name);
1083 if (conf->verbosity >= OPKG_NOTICE) {
1084 if (possibility->version) {
1085 char *typestr = NULL;
1086 opkg_message(conf, OPKG_NOTICE, " %s", possibility->version);
1087 switch (possibility->constraint) {
1088 case NONE: typestr = "none"; break;
1089 case EARLIER: typestr = "<"; break;
1090 case EARLIER_EQUAL: typestr = "<="; break;
1091 case EQUAL: typestr = "="; break;
1092 case LATER_EQUAL: typestr = ">="; break;
1093 case LATER: typestr = ">"; break;
1094 }
1095 opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1096 }
1097 }
1098 opkg_message(conf, OPKG_NOTICE, "\n");
1099 }
1100 }
1101 }
1102 }
1103 }
1104 pkg_vec_free(available_pkgs);
1105 }
1106 return 0;
1107 }
1108
1109 enum what_field_type {
1110 WHATDEPENDS,
1111 WHATCONFLICTS,
1112 WHATPROVIDES,
1113 WHATREPLACES,
1114 WHATRECOMMENDS,
1115 WHATSUGGESTS
1116 };
1117
1118 static int opkg_what_depends_conflicts_cmd(opkg_conf_t *conf, enum depend_type what_field_type, int recursive, int argc, char **argv)
1119 {
1120
1121 if (argc > 0) {
1122 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1123 const char *rel_str = NULL;
1124 int i;
1125 int changed;
1126
1127 switch (what_field_type) {
1128 case DEPEND: rel_str = "depends on"; break;
1129 case CONFLICTS: rel_str = "conflicts with"; break;
1130 case SUGGEST: rel_str = "suggests"; break;
1131 case RECOMMEND: rel_str = "recommends"; break;
1132 default: return -1;
1133 }
1134
1135 if (conf->query_all)
1136 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1137 else
1138 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1139
1140 /* mark the root set */
1141 pkg_vec_clear_marks(available_pkgs);
1142 opkg_message(conf, OPKG_NOTICE, "Root set:\n");
1143 for (i = 0; i < argc; i++) {
1144 const char *dependee_pattern = argv[i];
1145 pkg_vec_mark_if_matches(available_pkgs, dependee_pattern);
1146 }
1147 for (i = 0; i < available_pkgs->len; i++) {
1148 pkg_t *pkg = available_pkgs->pkgs[i];
1149 if (pkg->state_flag & SF_MARKED) {
1150 /* mark the parent (abstract) package */
1151 pkg_mark_provides(pkg);
1152 opkg_message(conf, OPKG_NOTICE, " %s\n", pkg->name);
1153 }
1154 }
1155
1156 opkg_message(conf, OPKG_NOTICE, "What %s root set\n", rel_str);
1157 do {
1158 int j;
1159 changed = 0;
1160
1161 for (j = 0; j < available_pkgs->len; j++) {
1162 pkg_t *pkg = available_pkgs->pkgs[j];
1163 int k;
1164 int count = ((what_field_type == CONFLICTS)
1165 ? pkg->conflicts_count
1166 : pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count);
1167 /* skip this package if it is already marked */
1168 if (pkg->parent->state_flag & SF_MARKED) {
1169 continue;
1170 }
1171 for (k = 0; k < count; k++) {
1172 compound_depend_t *cdepend =
1173 (what_field_type == CONFLICTS) ? &pkg->conflicts[k] : &pkg->depends[k];
1174 int l;
1175 if (what_field_type != cdepend->type)
1176 continue;
1177 for (l = 0; l < cdepend->possibility_count; l++) {
1178 depend_t *possibility = cdepend->possibilities[l];
1179 if (possibility->pkg->state_flag & SF_MARKED) {
1180 /* mark the depending package so we won't visit it again */
1181 pkg->state_flag |= SF_MARKED;
1182 pkg_mark_provides(pkg);
1183 changed++;
1184
1185 if (conf->verbosity >= OPKG_NOTICE) {
1186 char *ver = pkg_version_str_alloc(pkg);
1187 opkg_message(conf, OPKG_NOTICE, " %s", pkg->name);
1188 opkg_message(conf, OPKG_NOTICE, " %s", ver);
1189 opkg_message(conf, OPKG_NOTICE, "\t%s %s", rel_str, possibility->pkg->name);
1190 if (possibility->version) {
1191 char *typestr = NULL;
1192 switch (possibility->constraint) {
1193 case NONE: typestr = "none"; break;
1194 case EARLIER: typestr = "<"; break;
1195 case EARLIER_EQUAL: typestr = "<="; break;
1196 case EQUAL: typestr = "="; break;
1197 case LATER_EQUAL: typestr = ">="; break;
1198 case LATER: typestr = ">"; break;
1199 }
1200 opkg_message(conf, OPKG_NOTICE, " (%s %s)", typestr, possibility->version);
1201 }
1202 free(ver);
1203 if (!pkg_dependence_satisfiable(conf, possibility))
1204 opkg_message(conf, OPKG_NOTICE, " unsatisfiable");
1205 }
1206 opkg_message(conf, OPKG_NOTICE, "\n");
1207 goto next_package;
1208 }
1209 }
1210 }
1211 next_package:
1212 ;
1213 }
1214 } while (changed && recursive);
1215 pkg_vec_free(available_pkgs);
1216 }
1217
1218 return 0;
1219 }
1220
1221 static int pkg_mark_provides(pkg_t *pkg)
1222 {
1223 int provides_count = pkg->provides_count;
1224 abstract_pkg_t **provides = pkg->provides;
1225 int i;
1226 pkg->parent->state_flag |= SF_MARKED;
1227 for (i = 0; i < provides_count; i++) {
1228 provides[i]->state_flag |= SF_MARKED;
1229 }
1230 return 0;
1231 }
1232
1233 static int opkg_whatdepends_recursively_cmd(opkg_conf_t *conf, int argc, char **argv)
1234 {
1235 return opkg_what_depends_conflicts_cmd(conf, DEPEND, 1, argc, argv);
1236 }
1237 static int opkg_whatdepends_cmd(opkg_conf_t *conf, int argc, char **argv)
1238 {
1239 return opkg_what_depends_conflicts_cmd(conf, DEPEND, 0, argc, argv);
1240 }
1241
1242 static int opkg_whatsuggests_cmd(opkg_conf_t *conf, int argc, char **argv)
1243 {
1244 return opkg_what_depends_conflicts_cmd(conf, SUGGEST, 0, argc, argv);
1245 }
1246
1247 static int opkg_whatrecommends_cmd(opkg_conf_t *conf, int argc, char **argv)
1248 {
1249 return opkg_what_depends_conflicts_cmd(conf, RECOMMEND, 0, argc, argv);
1250 }
1251
1252 static int opkg_whatconflicts_cmd(opkg_conf_t *conf, int argc, char **argv)
1253 {
1254 return opkg_what_depends_conflicts_cmd(conf, CONFLICTS, 0, argc, argv);
1255 }
1256
1257 static int opkg_what_provides_replaces_cmd(opkg_conf_t *conf, enum what_field_type what_field_type, int argc, char **argv)
1258 {
1259
1260 if (argc > 0) {
1261 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1262 const char *rel_str = (what_field_type == WHATPROVIDES ? "provides" : "replaces");
1263 int i;
1264
1265 pkg_info_preinstall_check(conf);
1266
1267 if (conf->query_all)
1268 pkg_hash_fetch_available(&conf->pkg_hash, available_pkgs);
1269 else
1270 pkg_hash_fetch_all_installed(&conf->pkg_hash, available_pkgs);
1271 for (i = 0; i < argc; i++) {
1272 const char *target = argv[i];
1273 int j;
1274
1275 opkg_message(conf, OPKG_ERROR, "What %s %s\n",
1276 rel_str, target);
1277 for (j = 0; j < available_pkgs->len; j++) {
1278 pkg_t *pkg = available_pkgs->pkgs[j];
1279 int k;
1280 int count = (what_field_type == WHATPROVIDES) ? pkg->provides_count : pkg->replaces_count;
1281 for (k = 0; k < count; k++) {
1282 abstract_pkg_t *apkg =
1283 ((what_field_type == WHATPROVIDES)
1284 ? pkg->provides[k]
1285 : pkg->replaces[k]);
1286 if (fnmatch(target, apkg->name, 0) == 0) {
1287 opkg_message(conf, OPKG_ERROR, " %s", pkg->name);
1288 if (strcmp(target, apkg->name) != 0)
1289 opkg_message(conf, OPKG_ERROR, "\t%s %s\n", rel_str, apkg->name);
1290 opkg_message(conf, OPKG_ERROR, "\n");
1291 }
1292 }
1293 }
1294 }
1295 pkg_vec_free(available_pkgs);
1296 }
1297 return 0;
1298 }
1299
1300 static int opkg_whatprovides_cmd(opkg_conf_t *conf, int argc, char **argv)
1301 {
1302 return opkg_what_provides_replaces_cmd(conf, WHATPROVIDES, argc, argv);
1303 }
1304
1305 static int opkg_whatreplaces_cmd(opkg_conf_t *conf, int argc, char **argv)
1306 {
1307 return opkg_what_provides_replaces_cmd(conf, WHATREPLACES, argc, argv);
1308 }
1309
1310 static int opkg_search_cmd(opkg_conf_t *conf, int argc, char **argv)
1311 {
1312 int i;
1313
1314 pkg_vec_t *installed;
1315 pkg_t *pkg;
1316 str_list_t *installed_files;
1317 str_list_elt_t *iter;
1318 char *installed_file;
1319
1320 if (argc < 1) {
1321 return EINVAL;
1322 }
1323
1324 installed = pkg_vec_alloc();
1325 pkg_hash_fetch_all_installed(&conf->pkg_hash, installed);
1326 pkg_vec_sort(installed, pkg_compare_names);
1327
1328 for (i=0; i < installed->len; i++) {
1329 pkg = installed->pkgs[i];
1330
1331 installed_files = pkg_get_installed_files(conf, pkg);
1332
1333 for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
1334 installed_file = (char *)iter->data;
1335 if (fnmatch(argv[0], installed_file, 0)==0)
1336 print_pkg(pkg);
1337 }
1338
1339 pkg_free_installed_files(pkg);
1340 }
1341
1342 pkg_vec_free(installed);
1343
1344 return 0;
1345 }
1346
1347 static int opkg_compare_versions_cmd(opkg_conf_t *conf, int argc, char **argv)
1348 {
1349 if (argc == 3) {
1350 /* this is a bit gross */
1351 struct pkg p1, p2;
1352 parse_version(&p1, argv[0]);
1353 parse_version(&p2, argv[2]);
1354 return pkg_version_satisfied(&p1, &p2, argv[1]);
1355 } else {
1356 opkg_message(conf, OPKG_ERROR,
1357 "opkg compare_versions <v1> <op> <v2>\n"
1358 "<op> is one of <= >= << >> =\n");
1359 return -1;
1360 }
1361 }
1362
1363 static int opkg_print_architecture_cmd(opkg_conf_t *conf, int argc, char **argv)
1364 {
1365 nv_pair_list_elt_t *l;
1366
1367 list_for_each_entry(l, &conf->arch_list.head, node) {
1368 nv_pair_t *nv = (nv_pair_t *)l->data;
1369 printf("arch %s %s\n", nv->name, nv->value);
1370 }
1371 return 0;
1372 }
LEDE fork of Opkg