1 /* pkg.c - the opkg package management system
5 Copyright (C) 2001 University of Southern California
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.
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.
27 #include "pkg_parse.h"
28 #include "pkg_extract.h"
29 #include "opkg_message.h"
30 #include "opkg_utils.h"
32 #include "libbb/libbb.h"
33 #include "sprintf_alloc.h"
34 #include "file_util.h"
37 #include "opkg_conf.h"
39 typedef struct enum_map enum_map_t;
46 static const enum_map_t pkg_state_want_map[] = {
47 { SW_UNKNOWN, "unknown"},
48 { SW_INSTALL, "install"},
49 { SW_DEINSTALL, "deinstall"},
53 static const enum_map_t pkg_state_flag_map[] = {
55 { SF_REINSTREQ, "reinstreq"},
57 { SF_REPLACE, "replace"},
58 { SF_NOPRUNE, "noprune"},
59 { SF_PREFER, "prefer"},
60 { SF_OBSOLETE, "obsolete"},
64 static const enum_map_t pkg_state_status_map[] = {
65 { SS_NOT_INSTALLED, "not-installed" },
66 { SS_UNPACKED, "unpacked" },
67 { SS_HALF_CONFIGURED, "half-configured" },
68 { SS_INSTALLED, "installed" },
69 { SS_HALF_INSTALLED, "half-installed" },
70 { SS_CONFIG_FILES, "config-files" },
71 { SS_POST_INST_FAILED, "post-inst-failed" },
72 { SS_REMOVAL_FAILED, "removal-failed" }
75 static int verrevcmp(const char *val, const char *ref);
82 pkg = xcalloc(1, sizeof(pkg_t));
88 int pkg_init(pkg_t *pkg)
96 pkg->architecture = NULL;
97 pkg->maintainer = NULL;
99 pkg->description = NULL;
100 pkg->state_want = SW_UNKNOWN;
101 pkg->state_flag = SF_OK;
102 pkg->state_status = SS_NOT_INSTALLED;
103 pkg->depends_str = NULL;
104 pkg->provides_str = NULL;
105 pkg->depends_count = 0;
107 pkg->suggests_str = NULL;
108 pkg->recommends_str = NULL;
109 pkg->suggests_count = 0;
110 pkg->recommends_count = 0;
112 active_list_init(&pkg->list);
114 /* Abhaya: added init for conflicts fields */
115 pkg->conflicts = NULL;
116 pkg->conflicts_count = 0;
118 /* added for replaces. Jamey 7/23/2002 */
119 pkg->replaces = NULL;
120 pkg->replaces_count = 0;
122 pkg->pre_depends_count = 0;
123 pkg->pre_depends_str = NULL;
124 pkg->provides_count = 0;
125 pkg->provides = NULL;
126 pkg->filename = NULL;
127 pkg->local_filename = NULL;
128 pkg->tmp_unpack_dir = NULL;
130 #if defined HAVE_SHA256
131 pkg->sha256sum = NULL;
134 pkg->installed_size = NULL;
135 pkg->priority = NULL;
137 conffile_list_init(&pkg->conffiles);
138 pkg->installed_files = NULL;
139 pkg->installed_files_ref_cnt = 0;
141 pkg->provided_by_hand = 0;
146 void compound_depend_deinit (compound_depend_t *depends)
149 for (i = 0; i < depends->possibility_count; i++)
152 d = depends->possibilities[i];
156 free (depends->possibilities);
159 void pkg_deinit(pkg_t *pkg)
172 /* revision shares storage with version, so don't free */
173 pkg->revision = NULL;
175 /* owned by opkg_conf_t */
177 /* owned by opkg_conf_t */
180 if (pkg->architecture)
181 free(pkg->architecture);
182 pkg->architecture = NULL;
185 free(pkg->maintainer);
186 pkg->maintainer = NULL;
192 if (pkg->description)
193 free(pkg->description);
194 pkg->description = NULL;
196 pkg->state_want = SW_UNKNOWN;
197 pkg->state_flag = SF_OK;
198 pkg->state_status = SS_NOT_INSTALLED;
200 active_list_clear(&pkg->list);
203 free (pkg->replaces);
204 pkg->replaces = NULL;
206 for (i = 0; i < pkg->depends_count; i++)
207 free (pkg->depends_str[i]);
208 free(pkg->depends_str);
209 pkg->depends_str = NULL;
211 for (i = 0; i < pkg->provides_count-1; i++)
212 free (pkg->provides_str[i]);
213 free(pkg->provides_str);
214 pkg->provides_str = NULL;
216 for (i = 0; i < pkg->conflicts_count; i++)
217 free (pkg->conflicts_str[i]);
218 free(pkg->conflicts_str);
219 pkg->conflicts_str = NULL;
221 for (i = 0; i < pkg->replaces_count; i++)
222 free (pkg->replaces_str[i]);
223 free(pkg->replaces_str);
224 pkg->replaces_str = NULL;
226 for (i = 0; i < pkg->recommends_count; i++)
227 free (pkg->recommends_str[i]);
228 free(pkg->recommends_str);
229 pkg->recommends_str = NULL;
231 for (i = 0; i < pkg->suggests_count; i++)
232 free (pkg->suggests_str[i]);
233 free(pkg->suggests_str);
234 pkg->suggests_str = NULL;
237 int count = pkg->pre_depends_count
239 + pkg->recommends_count
240 + pkg->suggests_count;
242 for (i=0; i<count; i++)
243 compound_depend_deinit (&pkg->depends[i]);
247 if (pkg->conflicts) {
248 for (i=0; i<pkg->conflicts_count; i++)
249 compound_depend_deinit (&pkg->conflicts[i]);
250 free (pkg->conflicts);
254 free (pkg->provides);
256 pkg->pre_depends_count = 0;
257 if (pkg->pre_depends_str)
258 free(pkg->pre_depends_str);
259 pkg->pre_depends_str = NULL;
261 pkg->provides_count = 0;
265 pkg->filename = NULL;
267 if (pkg->local_filename)
268 free(pkg->local_filename);
269 pkg->local_filename = NULL;
271 /* CLEANUP: It'd be nice to pullin the cleanup function from
272 opkg_install.c here. See comment in
273 opkg_install.c:cleanup_temporary_files */
274 if (pkg->tmp_unpack_dir)
275 free(pkg->tmp_unpack_dir);
276 pkg->tmp_unpack_dir = NULL;
282 #if defined HAVE_SHA256
284 free(pkg->sha256sum);
285 pkg->sha256sum = NULL;
292 if (pkg->installed_size)
293 free(pkg->installed_size);
294 pkg->installed_size = NULL;
298 pkg->priority = NULL;
304 conffile_list_deinit(&pkg->conffiles);
306 /* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
307 since if they are calling deinit, they should know. Maybe do an
308 assertion here instead? */
309 pkg->installed_files_ref_cnt = 1;
310 pkg_free_installed_files(pkg);
318 int pkg_init_from_file(pkg_t *pkg, const char *filename)
324 if (err) { return err; }
326 pkg->local_filename = xstrdup(filename);
328 control_file = tmpfile();
329 err = pkg_extract_control_file_to_stream(pkg, control_file);
330 if (err) { return err; }
332 rewind(control_file);
333 pkg_parse_from_stream(pkg, control_file, PFM_ALL);
335 fclose(control_file);
340 /* Merge any new information in newpkg into oldpkg */
341 /* XXX: CLEANUP: This function shouldn't actually modify anything in
342 newpkg, but should leave it usable. This rework is so that
343 pkg_hash_insert doesn't clobber the pkg that you pass into it. */
345 * uh, i thought that i had originally written this so that it took
346 * two pkgs and returned a new one? we can do that again... -sma
348 int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
350 if (oldpkg == newpkg) {
355 oldpkg->src = newpkg->src;
357 oldpkg->dest = newpkg->dest;
358 if (!oldpkg->architecture)
359 oldpkg->architecture = xstrdup(newpkg->architecture);
360 if (!oldpkg->arch_priority)
361 oldpkg->arch_priority = newpkg->arch_priority;
362 if (!oldpkg->section)
363 oldpkg->section = xstrdup(newpkg->section);
364 if(!oldpkg->maintainer)
365 oldpkg->maintainer = xstrdup(newpkg->maintainer);
366 if(!oldpkg->description)
367 oldpkg->description = xstrdup(newpkg->description);
369 /* merge the state_flags from the new package */
370 oldpkg->state_want = newpkg->state_want;
371 oldpkg->state_status = newpkg->state_status;
372 oldpkg->state_flag = newpkg->state_flag;
374 if (oldpkg->state_want == SW_UNKNOWN)
375 oldpkg->state_want = newpkg->state_want;
376 if (oldpkg->state_status == SS_NOT_INSTALLED)
377 oldpkg->state_status = newpkg->state_status;
378 oldpkg->state_flag |= newpkg->state_flag;
381 if (!oldpkg->depends_str && !oldpkg->pre_depends_str && !oldpkg->recommends_str && !oldpkg->suggests_str) {
382 oldpkg->depends_str = newpkg->depends_str;
383 newpkg->depends_str = NULL;
384 oldpkg->depends_count = newpkg->depends_count;
385 newpkg->depends_count = 0;
387 oldpkg->depends = newpkg->depends;
388 newpkg->depends = NULL;
390 oldpkg->pre_depends_str = newpkg->pre_depends_str;
391 newpkg->pre_depends_str = NULL;
392 oldpkg->pre_depends_count = newpkg->pre_depends_count;
393 newpkg->pre_depends_count = 0;
395 oldpkg->recommends_str = newpkg->recommends_str;
396 newpkg->recommends_str = NULL;
397 oldpkg->recommends_count = newpkg->recommends_count;
398 newpkg->recommends_count = 0;
400 oldpkg->suggests_str = newpkg->suggests_str;
401 newpkg->suggests_str = NULL;
402 oldpkg->suggests_count = newpkg->suggests_count;
403 newpkg->suggests_count = 0;
406 if (!oldpkg->provides_str) {
407 oldpkg->provides_str = newpkg->provides_str;
408 newpkg->provides_str = NULL;
409 oldpkg->provides_count = newpkg->provides_count;
410 newpkg->provides_count = 0;
412 if (!oldpkg->provides) {
413 oldpkg->provides = newpkg->provides;
414 newpkg->provides = NULL;
418 if (!oldpkg->conflicts_str) {
419 oldpkg->conflicts_str = newpkg->conflicts_str;
420 newpkg->conflicts_str = NULL;
421 oldpkg->conflicts_count = newpkg->conflicts_count;
422 newpkg->conflicts_count = 0;
424 oldpkg->conflicts = newpkg->conflicts;
425 newpkg->conflicts = NULL;
428 if (!oldpkg->replaces_str) {
429 oldpkg->replaces_str = newpkg->replaces_str;
430 newpkg->replaces_str = NULL;
431 oldpkg->replaces_count = newpkg->replaces_count;
432 newpkg->replaces_count = 0;
434 oldpkg->replaces = newpkg->replaces;
435 newpkg->replaces = NULL;
438 if (!oldpkg->filename)
439 oldpkg->filename = xstrdup(newpkg->filename);
440 if (!oldpkg->local_filename)
441 oldpkg->local_filename = xstrdup(newpkg->local_filename);
442 if (!oldpkg->tmp_unpack_dir)
443 oldpkg->tmp_unpack_dir = xstrdup(newpkg->tmp_unpack_dir);
445 oldpkg->md5sum = xstrdup(newpkg->md5sum);
446 #if defined HAVE_SHA256
447 if (!oldpkg->sha256sum)
448 oldpkg->sha256sum = xstrdup(newpkg->sha256sum);
451 oldpkg->size = xstrdup(newpkg->size);
452 if (!oldpkg->installed_size)
453 oldpkg->installed_size = xstrdup(newpkg->installed_size);
454 if (!oldpkg->priority)
455 oldpkg->priority = xstrdup(newpkg->priority);
457 oldpkg->source = xstrdup(newpkg->source);
458 if (nv_pair_list_empty(&oldpkg->conffiles)){
459 list_splice_init(&newpkg->conffiles.head, &oldpkg->conffiles.head);
460 conffile_list_init(&newpkg->conffiles);
462 if (!oldpkg->installed_files){
463 oldpkg->installed_files = newpkg->installed_files;
464 oldpkg->installed_files_ref_cnt = newpkg->installed_files_ref_cnt;
465 newpkg->installed_files = NULL;
467 if (!oldpkg->essential)
468 oldpkg->essential = newpkg->essential;
473 abstract_pkg_t *abstract_pkg_new(void)
475 abstract_pkg_t * ab_pkg;
477 ab_pkg = xcalloc(1, sizeof(abstract_pkg_t));
479 if (ab_pkg == NULL) {
480 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
484 if ( abstract_pkg_init(ab_pkg) < 0 )
490 int abstract_pkg_init(abstract_pkg_t *ab_pkg)
492 ab_pkg->provided_by = abstract_pkg_vec_alloc();
493 if (ab_pkg->provided_by==NULL){
496 ab_pkg->dependencies_checked = 0;
497 ab_pkg->state_status = SS_NOT_INSTALLED;
502 void set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){
506 sprintf_alloc(&file_name,"%s/%s.control", pkg->dest->info_dir, pkg->name);
508 fp = fopen(file_name, "r");
510 opkg_message(conf, OPKG_ERROR, "fopen(%s): %s\n",
511 file_name, strerror(errno));
517 if (pkg_parse_from_stream(pkg, fp, PFM_ESSENTIAL)) {
518 opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name);
526 void pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field)
530 if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
531 goto UNKNOWN_FMT_FIELD;
538 if (strcasecmp(field, "Architecture") == 0) {
539 if (pkg->architecture) {
540 fprintf(fp, "Architecture: %s\n", pkg->architecture);
542 } else if (strcasecmp(field, "Auto-Installed") == 0) {
543 if (pkg->auto_installed)
544 fprintf(fp, "Auto-Installed: yes\n");
546 goto UNKNOWN_FMT_FIELD;
551 if (strcasecmp(field, "Conffiles") == 0) {
552 conffile_list_elt_t *iter;
554 if (nv_pair_list_empty(&pkg->conffiles))
557 fprintf(fp, "Conffiles:\n");
558 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
559 if (((conffile_t *)iter->data)->name && ((conffile_t *)iter->data)->value) {
560 fprintf(fp, "%s %s\n",
561 ((conffile_t *)iter->data)->name,
562 ((conffile_t *)iter->data)->value);
565 } else if (strcasecmp(field, "Conflicts") == 0) {
566 if (pkg->conflicts_count) {
567 fprintf(fp, "Conflicts:");
568 for(i = 0; i < pkg->conflicts_count; i++) {
569 fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->conflicts_str[i]);
574 goto UNKNOWN_FMT_FIELD;
579 if (strcasecmp(field, "Depends") == 0) {
580 if (pkg->depends_count) {
581 fprintf(fp, "Depends:");
582 for(i = 0; i < pkg->depends_count; i++) {
583 fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->depends_str[i]);
587 } else if (strcasecmp(field, "Description") == 0) {
588 if (pkg->description) {
589 fprintf(fp, "Description: %s\n", pkg->description);
592 goto UNKNOWN_FMT_FIELD;
597 if (pkg->essential) {
598 fprintf(fp, "Essential: yes\n");
604 fprintf(fp, "Filename: %s\n", pkg->filename);
609 if (strcasecmp(field, "Installed-Size") == 0) {
610 fprintf(fp, "Installed-Size: %s\n", pkg->installed_size);
611 } else if (strcasecmp(field, "Installed-Time") == 0 && pkg->installed_time) {
612 fprintf(fp, "Installed-Time: %lu\n", pkg->installed_time);
617 if (strcasecmp(field, "Maintainer") == 0) {
618 if (pkg->maintainer) {
619 fprintf(fp, "maintainer: %s\n", pkg->maintainer);
621 } else if (strcasecmp(field, "MD5sum") == 0) {
623 fprintf(fp, "MD5Sum: %s\n", pkg->md5sum);
626 goto UNKNOWN_FMT_FIELD;
631 if (strcasecmp(field, "Package") == 0) {
632 fprintf(fp, "Package: %s\n", pkg->name);
633 } else if (strcasecmp(field, "Priority") == 0) {
634 fprintf(fp, "Priority: %s\n", pkg->priority);
635 } else if (strcasecmp(field, "Provides") == 0) {
636 if (pkg->provides_count) {
637 fprintf(fp, "Provides:");
638 for(i = 0; i < pkg->provides_count-1; i++) {
639 fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->provides_str[i]);
644 goto UNKNOWN_FMT_FIELD;
649 if (strcasecmp (field, "Replaces") == 0) {
650 if (pkg->replaces_count) {
651 fprintf(fp, "Replaces:");
652 for (i = 0; i < pkg->replaces_count; i++) {
653 fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->replaces_str[i]);
657 } else if (strcasecmp (field, "Recommends") == 0) {
658 if (pkg->recommends_count) {
659 fprintf(fp, "Recommends:");
660 for(i = 0; i < pkg->recommends_count; i++) {
661 fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->recommends_str[i]);
666 goto UNKNOWN_FMT_FIELD;
671 if (strcasecmp(field, "Section") == 0) {
673 fprintf(fp, "Section: %s\n", pkg->section);
675 #if defined HAVE_SHA256
676 } else if (strcasecmp(field, "SHA256sum") == 0) {
677 if (pkg->sha256sum) {
678 fprintf(fp, "SHA256sum: %s\n", pkg->sha256sum);
681 } else if (strcasecmp(field, "Size") == 0) {
683 fprintf(fp, "Size: %s\n", pkg->size);
685 } else if (strcasecmp(field, "Source") == 0) {
687 fprintf(fp, "Source: %s\n", pkg->source);
689 } else if (strcasecmp(field, "Status") == 0) {
690 char *pflag = pkg_state_flag_to_str(pkg->state_flag);
691 char *pstat = pkg_state_status_to_str(pkg->state_status);
692 char *pwant = pkg_state_want_to_str(pkg->state_want);
694 if (pflag == NULL || pstat == NULL || pwant == NULL)
697 fprintf(fp, "Status: %s %s %s\n", pwant, pflag, pstat);
702 } else if (strcasecmp(field, "Suggests") == 0) {
703 if (pkg->suggests_count) {
704 fprintf(fp, "Suggests:");
705 for(i = 0; i < pkg->suggests_count; i++) {
706 fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->suggests_str[i]);
711 goto UNKNOWN_FMT_FIELD;
716 if (strcasecmp(field, "Tags") == 0) {
718 fprintf(fp, "Tags: %s\n", pkg->tags);
725 char *version = pkg_version_str_alloc(pkg);
728 fprintf(fp, "Version: %s\n", version);
733 goto UNKNOWN_FMT_FIELD;
739 fprintf(stderr, "%s: ERROR: Unknown field name: %s\n", __FUNCTION__, field);
742 void pkg_formatted_info(FILE *fp, pkg_t *pkg)
744 pkg_formatted_field(fp, pkg, "Package");
745 pkg_formatted_field(fp, pkg, "Version");
746 pkg_formatted_field(fp, pkg, "Depends");
747 pkg_formatted_field(fp, pkg, "Recommends");
748 pkg_formatted_field(fp, pkg, "Suggests");
749 pkg_formatted_field(fp, pkg, "Provides");
750 pkg_formatted_field(fp, pkg, "Replaces");
751 pkg_formatted_field(fp, pkg, "Conflicts");
752 pkg_formatted_field(fp, pkg, "Status");
753 pkg_formatted_field(fp, pkg, "Section");
754 pkg_formatted_field(fp, pkg, "Essential");
755 pkg_formatted_field(fp, pkg, "Architecture");
756 pkg_formatted_field(fp, pkg, "Maintainer");
757 pkg_formatted_field(fp, pkg, "MD5sum");
758 pkg_formatted_field(fp, pkg, "Size");
759 pkg_formatted_field(fp, pkg, "Filename");
760 pkg_formatted_field(fp, pkg, "Conffiles");
761 pkg_formatted_field(fp, pkg, "Source");
762 pkg_formatted_field(fp, pkg, "Description");
763 pkg_formatted_field(fp, pkg, "Installed-Time");
764 pkg_formatted_field(fp, pkg, "Tags");
768 void pkg_print_status(pkg_t * pkg, FILE * file)
774 /* XXX: QUESTION: Do we actually want more fields here? The
775 original idea was to save space by installing only what was
776 needed for actual computation, (package, version, status,
777 essential, conffiles). The assumption is that all other fields
778 can be found in th available file.
780 But, someone proposed the idea to make it possible to
781 reconstruct a .opk from an installed package, (ie. for beaming
782 from one handheld to another). So, maybe we actually want a few
783 more fields here, (depends, suggests, etc.), so that that would
784 be guaranteed to work even in the absence of more information
785 from the available file.
787 28-MAR-03: kergoth and I discussed this yesterday. We think
788 the essential info needs to be here for all installed packages
789 because they may not appear in the Packages files on various
790 feeds. Furthermore, one should be able to install from URL or
791 local storage without requiring a Packages file from any feed.
794 pkg_formatted_field(file, pkg, "Package");
795 pkg_formatted_field(file, pkg, "Version");
796 pkg_formatted_field(file, pkg, "Depends");
797 pkg_formatted_field(file, pkg, "Recommends");
798 pkg_formatted_field(file, pkg, "Suggests");
799 pkg_formatted_field(file, pkg, "Provides");
800 pkg_formatted_field(file, pkg, "Replaces");
801 pkg_formatted_field(file, pkg, "Conflicts");
802 pkg_formatted_field(file, pkg, "Status");
803 pkg_formatted_field(file, pkg, "Essential");
804 pkg_formatted_field(file, pkg, "Architecture");
805 pkg_formatted_field(file, pkg, "Conffiles");
806 pkg_formatted_field(file, pkg, "Installed-Time");
807 pkg_formatted_field(file, pkg, "Auto-Installed");
812 * libdpkg - Debian packaging suite library routines
813 * vercmp.c - comparison of version numbers
815 * Copyright (C) 1995 Ian Jackson <iwj10@cus.cam.ac.uk>
817 int pkg_compare_versions(const pkg_t *pkg, const pkg_t *ref_pkg)
821 if (pkg->epoch > ref_pkg->epoch) {
825 if (pkg->epoch < ref_pkg->epoch) {
829 r = verrevcmp(pkg->version, ref_pkg->version);
834 r = verrevcmp(pkg->revision, ref_pkg->revision);
842 /* assume ascii; warning: evaluates x multiple times! */
843 #define order(x) ((x) == '~' ? -1 \
846 : isalpha((x)) ? (x) \
849 static int verrevcmp(const char *val, const char *ref) {
853 while (*val || *ref) {
856 while ( (*val && !isdigit(*val)) || (*ref && !isdigit(*ref)) ) {
857 int vc= order(*val), rc= order(*ref);
858 if (vc != rc) return vc - rc;
862 while ( *val == '0' ) val++;
863 while ( *ref == '0' ) ref++;
864 while (isdigit(*val) && isdigit(*ref)) {
865 if (!first_diff) first_diff= *val - *ref;
868 if (isdigit(*val)) return 1;
869 if (isdigit(*ref)) return -1;
870 if (first_diff) return first_diff;
875 int pkg_version_satisfied(pkg_t *it, pkg_t *ref, const char *op)
879 r = pkg_compare_versions(it, ref);
881 if (strcmp(op, "<=") == 0 || strcmp(op, "<") == 0) {
885 if (strcmp(op, ">=") == 0 || strcmp(op, ">") == 0) {
889 if (strcmp(op, "<<") == 0) {
893 if (strcmp(op, ">>") == 0) {
897 if (strcmp(op, "=") == 0) {
901 fprintf(stderr, "unknown operator: %s", op);
905 int pkg_name_version_and_architecture_compare(const void *p1, const void *p2)
907 const pkg_t *a = *(const pkg_t**) p1;
908 const pkg_t *b = *(const pkg_t**) p2;
911 if (!a->name || !b->name) {
912 fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->name=%p b=%p b->name=%p\n",
913 a, a->name, b, b->name);
917 namecmp = strcmp(a->name, b->name);
920 vercmp = pkg_compare_versions(a, b);
923 if (!a->arch_priority || !b->arch_priority) {
924 fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->arch_priority=%i b=%p b->arch_priority=%i\n",
925 a, a->arch_priority, b, b->arch_priority);
928 if (a->arch_priority > b->arch_priority)
930 if (a->arch_priority < b->arch_priority)
935 int abstract_pkg_name_compare(const void *p1, const void *p2)
937 const abstract_pkg_t *a = *(const abstract_pkg_t **)p1;
938 const abstract_pkg_t *b = *(const abstract_pkg_t **)p2;
939 if (!a->name || !b->name) {
940 fprintf(stderr, "abstract_pkg_name_compare: a=%p a->name=%p b=%p b->name=%p\n",
941 a, a->name, b, b->name);
944 return strcmp(a->name, b->name);
948 char *pkg_version_str_alloc(pkg_t *pkg)
950 char *complete_version;
955 sprintf_alloc(&epoch_str, "%d:", pkg->epoch);
957 epoch_str = xstrdup("");
960 if (pkg->revision && strlen(pkg->revision)) {
961 sprintf_alloc(&revision_str, "-%s", pkg->revision);
963 revision_str = xstrdup("");
967 sprintf_alloc(&complete_version, "%s%s%s",
968 epoch_str, pkg->version, revision_str);
973 return complete_version;
976 str_list_t *pkg_get_installed_files(pkg_t *pkg)
979 char *list_file_name = NULL;
980 FILE *list_file = NULL;
982 char *installed_file_name;
985 pkg->installed_files_ref_cnt++;
987 if (pkg->installed_files) {
988 return pkg->installed_files;
991 pkg->installed_files = str_list_alloc();
993 /* For uninstalled packages, get the file list directly from the package.
994 For installed packages, look at the package.list file in the database.
996 if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) {
997 if (pkg->local_filename == NULL) {
998 return pkg->installed_files;
1000 /* XXX: CLEANUP: Maybe rewrite this to avoid using a temporary
1001 file. In other words, change deb_extract so that it can
1002 simply return the file list as a char *[] rather than
1003 insisting on writing in to a FILE * as it does now. */
1004 list_file = tmpfile();
1005 err = pkg_extract_data_file_names_to_stream(pkg, list_file);
1008 fprintf(stderr, "%s: Error extracting file list from %s: %s\n",
1009 __FUNCTION__, pkg->local_filename, strerror(err));
1010 return pkg->installed_files;
1014 sprintf_alloc(&list_file_name, "%s/%s.list",
1015 pkg->dest->info_dir, pkg->name);
1016 if (! file_exists(list_file_name)) {
1017 free(list_file_name);
1018 return pkg->installed_files;
1021 list_file = fopen(list_file_name, "r");
1022 if (list_file == NULL) {
1023 fprintf(stderr, "WARNING: Cannot open %s: %s\n",
1024 list_file_name, strerror(errno));
1025 free(list_file_name);
1026 return pkg->installed_files;
1028 free(list_file_name);
1031 rootdirlen = strlen( pkg->dest->root_dir );
1035 line = file_read_line_alloc(list_file);
1042 /* Take pains to avoid uglies like "/./" in the middle of file_name. */
1043 if( strncmp( pkg->dest->root_dir,
1046 if (*file_name == '.') {
1049 if (*file_name == '/') {
1053 /* Freed in pkg_free_installed_files */
1054 sprintf_alloc(&installed_file_name, "%s%s", pkg->dest->root_dir, file_name);
1056 // already contains root_dir as header -> ABSOLUTE
1057 sprintf_alloc(&installed_file_name, "%s", file_name);
1059 str_list_append(pkg->installed_files, installed_file_name);
1060 free(installed_file_name);
1066 return pkg->installed_files;
1069 /* XXX: CLEANUP: This function and it's counterpart,
1070 (pkg_get_installed_files), do not match our init/deinit naming
1071 convention. Nor the alloc/free convention. But, then again, neither
1072 of these conventions currrently fit the way these two functions
1074 int pkg_free_installed_files(pkg_t *pkg)
1076 pkg->installed_files_ref_cnt--;
1078 if (pkg->installed_files_ref_cnt > 0)
1081 if (pkg->installed_files) {
1082 str_list_purge(pkg->installed_files);
1085 pkg->installed_files = NULL;
1090 int pkg_remove_installed_files_list(opkg_conf_t *conf, pkg_t *pkg)
1093 char *list_file_name;
1095 //I don't think pkg_free_installed_files should be called here. Jamey
1096 //pkg_free_installed_files(pkg);
1098 sprintf_alloc(&list_file_name, "%s/%s.list",
1099 pkg->dest->info_dir, pkg->name);
1100 if (!conf->noaction) {
1101 err = unlink(list_file_name);
1102 free(list_file_name);
1111 conffile_t *pkg_get_conffile(pkg_t *pkg, const char *file_name)
1113 conffile_list_elt_t *iter;
1114 conffile_t *conffile;
1120 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
1121 conffile = (conffile_t *)iter->data;
1123 if (strcmp(conffile->name, file_name) == 0) {
1131 int pkg_run_script(opkg_conf_t *conf, pkg_t *pkg,
1132 const char *script, const char *args)
1141 /* XXX: CLEANUP: There must be a better way to handle maintainer
1142 scripts when running with offline_root mode and/or a dest other
1143 than '/'. I've been playing around with some clever chroot
1144 tricks and I might come up with something workable. */
1146 * Attempt to provide a restricted environment for offline operation
1147 * Need the following set as a minimum:
1148 * OPKG_OFFLINE_ROOT = absolute path to root dir
1149 * D = absolute path to root dir (for OE generated postinst)
1150 * PATH = something safe (a restricted set of utilities)
1153 if (conf->offline_root) {
1154 if (conf->offline_root_path) {
1155 setenv("PATH", conf->offline_root_path, 1);
1157 opkg_message(conf, OPKG_NOTICE,
1158 "(offline root mode: not running %s.%s)\n", pkg->name, script);
1161 setenv("OPKG_OFFLINE_ROOT", conf->offline_root, 1);
1162 setenv("D", conf->offline_root, 1);
1165 /* XXX: FEATURE: When conf->offline_root is set, we should run the
1166 maintainer script within a chroot environment. */
1168 /* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages
1169 have scripts in pkg->tmp_unpack_dir. */
1170 if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) {
1171 if (pkg->dest == NULL) {
1172 fprintf(stderr, "%s: ERROR: installed package %s has a NULL dest\n",
1173 __FUNCTION__, pkg->name);
1176 sprintf_alloc(&path, "%s/%s.%s", pkg->dest->info_dir, pkg->name, script);
1178 if (pkg->tmp_unpack_dir == NULL) {
1179 fprintf(stderr, "%s: ERROR: uninstalled package %s has a NULL tmp_unpack_dir\n",
1180 __FUNCTION__, pkg->name);
1183 sprintf_alloc(&path, "%s/%s", pkg->tmp_unpack_dir, script);
1186 opkg_message(conf, OPKG_INFO, "Running script %s\n", path);
1189 pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir, 1);
1191 if (! file_exists(path)) {
1196 sprintf_alloc(&cmd, "%s %s", path, args);
1203 fprintf(stderr, "%s script returned status %d\n", script, err);
1210 char *pkg_state_want_to_str(pkg_state_want_t sw)
1214 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1215 if (pkg_state_want_map[i].value == sw) {
1216 return xstrdup(pkg_state_want_map[i].str);
1220 fprintf(stderr, "%s: ERROR: Illegal value for state_want: %d\n",
1222 return xstrdup("<STATE_WANT_UNKNOWN>");
1225 pkg_state_want_t pkg_state_want_from_str(char *str)
1229 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1230 if (strcmp(str, pkg_state_want_map[i].str) == 0) {
1231 return pkg_state_want_map[i].value;
1235 fprintf(stderr, "%s: ERROR: Illegal value for state_want string: %s\n",
1240 char *pkg_state_flag_to_str(pkg_state_flag_t sf)
1243 int len = 3; /* ok\000 is minimum */
1246 /* clear the temporary flags before converting to string */
1247 sf &= SF_NONVOLATILE_FLAGS;
1250 return xstrdup("ok");
1253 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1254 if (sf & pkg_state_flag_map[i].value) {
1255 len += strlen(pkg_state_flag_map[i].str) + 1;
1260 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1261 if (sf & pkg_state_flag_map[i].value) {
1262 strcat(str, pkg_state_flag_map[i].str);
1267 str[len-1] = 0; /* squash last comma */
1272 pkg_state_flag_t pkg_state_flag_from_str(const char *str)
1277 if (strcmp(str, "ok") == 0) {
1280 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1281 const char *sfname = pkg_state_flag_map[i].str;
1282 int sfname_len = strlen(sfname);
1283 if (strncmp(str, sfname, sfname_len) == 0) {
1284 sf |= pkg_state_flag_map[i].value;
1286 if (str[0] == ',') {
1297 char *pkg_state_status_to_str(pkg_state_status_t ss)
1301 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1302 if (pkg_state_status_map[i].value == ss) {
1303 return xstrdup(pkg_state_status_map[i].str);
1307 fprintf(stderr, "%s: ERROR: Illegal value for state_status: %d\n",
1309 return xstrdup("<STATE_STATUS_UNKNOWN>");
1312 pkg_state_status_t pkg_state_status_from_str(const char *str)
1316 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1317 if (strcmp(str, pkg_state_status_map[i].str) == 0) {
1318 return pkg_state_status_map[i].value;
1322 fprintf(stderr, "%s: ERROR: Illegal value for state_status string: %s\n",
1324 return SS_NOT_INSTALLED;
1327 int pkg_arch_supported(opkg_conf_t *conf, pkg_t *pkg)
1329 nv_pair_list_elt_t *l;
1331 if (!pkg->architecture)
1334 list_for_each_entry(l , &conf->arch_list.head, node) {
1335 nv_pair_t *nv = (nv_pair_t *)l->data;
1336 if (strcmp(nv->name, pkg->architecture) == 0) {
1337 opkg_message(conf, OPKG_DEBUG, "arch %s (priority %s) supported for pkg %s\n", nv->name, nv->value, pkg->name);
1342 opkg_message(conf, OPKG_DEBUG, "arch %s unsupported for pkg %s\n", pkg->architecture, pkg->name);
1346 int pkg_get_arch_priority(opkg_conf_t *conf, const char *archname)
1348 nv_pair_list_elt_t *l;
1350 list_for_each_entry(l , &conf->arch_list.head, node) {
1351 nv_pair_t *nv = (nv_pair_t *)l->data;
1352 if (strcmp(nv->name, archname) == 0) {
1353 int priority = strtol(nv->value, NULL, 0);
1360 int pkg_info_preinstall_check(opkg_conf_t *conf)
1363 hash_table_t *pkg_hash = &conf->pkg_hash;
1364 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1365 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1367 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: updating arch priority for each package\n");
1368 pkg_hash_fetch_available(pkg_hash, available_pkgs);
1369 /* update arch_priority for each package */
1370 for (i = 0; i < available_pkgs->len; i++) {
1371 pkg_t *pkg = available_pkgs->pkgs[i];
1372 int arch_priority = 1;
1375 // opkg_message(conf, OPKG_DEBUG2, " package %s version=%s arch=%p:", pkg->name, pkg->version, pkg->architecture);
1376 if (pkg->architecture)
1377 arch_priority = pkg_get_arch_priority(conf, pkg->architecture);
1379 opkg_message(conf, OPKG_ERROR, "pkg_info_preinstall_check: no architecture for package %s\n", pkg->name);
1380 // opkg_message(conf, OPKG_DEBUG2, "%s arch_priority=%d\n", pkg->architecture, arch_priority);
1381 pkg->arch_priority = arch_priority;
1384 for (i = 0; i < available_pkgs->len; i++) {
1385 pkg_t *pkg = available_pkgs->pkgs[i];
1386 if (!pkg->arch_priority && (pkg->state_flag || (pkg->state_want != SW_UNKNOWN))) {
1387 /* clear flags and want for any uninstallable package */
1388 opkg_message(conf, OPKG_DEBUG, "Clearing state_want and state_flag for pkg=%s (arch_priority=%d flag=%d want=%d)\n",
1389 pkg->name, pkg->arch_priority, pkg->state_flag, pkg->state_want);
1390 pkg->state_want = SW_UNKNOWN;
1391 pkg->state_flag = 0;
1394 pkg_vec_free(available_pkgs);
1396 /* update the file owner data structure */
1397 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: update file owner list\n");
1398 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1399 for (i = 0; i < installed_pkgs->len; i++) {
1400 pkg_t *pkg = installed_pkgs->pkgs[i];
1401 str_list_t *installed_files = pkg_get_installed_files(pkg); /* this causes installed_files to be cached */
1402 str_list_elt_t *iter, *niter;
1403 if (installed_files == NULL) {
1404 opkg_message(conf, OPKG_ERROR, "No installed files for pkg %s\n", pkg->name);
1407 for (iter = str_list_first(installed_files), niter = str_list_next(installed_files, iter);
1409 iter = niter, niter = str_list_next(installed_files, iter)) {
1410 char *installed_file = (char *) iter->data;
1411 // opkg_message(conf, OPKG_DEBUG2, "pkg %s: file=%s\n", pkg->name, installed_file);
1412 file_hash_set_file_owner(conf, installed_file, pkg);
1414 pkg_free_installed_files(pkg);
1416 pkg_vec_free(installed_pkgs);
1421 struct pkg_write_filelist_data {
1427 void pkg_write_filelist_helper(const char *key, void *entry_, void *data_)
1429 struct pkg_write_filelist_data *data = data_;
1430 pkg_t *entry = entry_;
1431 if (entry == data->pkg) {
1432 fprintf(data->stream, "%s\n", key);
1436 int pkg_write_filelist(opkg_conf_t *conf, pkg_t *pkg)
1438 struct pkg_write_filelist_data data;
1439 char *list_file_name = NULL;
1443 opkg_message(conf, OPKG_ERROR, "Null pkg\n");
1446 opkg_message(conf, OPKG_INFO,
1447 " creating %s.list file\n", pkg->name);
1448 sprintf_alloc(&list_file_name, "%s/%s.list", pkg->dest->info_dir, pkg->name);
1449 if (!list_file_name) {
1450 opkg_message(conf, OPKG_ERROR, "Failed to alloc list_file_name\n");
1453 opkg_message(conf, OPKG_INFO,
1454 " creating %s file for pkg %s\n", list_file_name, pkg->name);
1455 data.stream = fopen(list_file_name, "w");
1457 opkg_message(conf, OPKG_ERROR, "Could not open %s for writing: %s\n",
1458 list_file_name, strerror(errno));
1463 hash_table_foreach(&conf->file_hash, pkg_write_filelist_helper, &data);
1464 fclose(data.stream);
1465 free(list_file_name);
1467 pkg->state_flag &= ~SF_FILELIST_CHANGED;
1472 int pkg_write_changed_filelists(opkg_conf_t *conf)
1474 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1475 hash_table_t *pkg_hash = &conf->pkg_hash;
1481 opkg_message(conf, OPKG_INFO, "%s: saving changed filelists\n", __FUNCTION__);
1482 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1483 for (i = 0; i < installed_pkgs->len; i++) {
1484 pkg_t *pkg = installed_pkgs->pkgs[i];
1485 if (pkg->state_flag & SF_FILELIST_CHANGED) {
1486 opkg_message(conf, OPKG_DEBUG, "Calling pkg_write_filelist for pkg=%s from %s\n", pkg->name, __FUNCTION__);
1487 err = pkg_write_filelist(conf, pkg);
1489 opkg_message(conf, OPKG_NOTICE, "pkg_write_filelist pkg=%s returned %d\n", pkg->name, err);
1492 pkg_vec_free (installed_pkgs);