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


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