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
->recommends_count
; i
++)
212 free (pkg
->recommends_str
[i
]);
213 free(pkg
->recommends_str
);
214 pkg
->recommends_str
= NULL
;
216 for (i
= 0; i
< pkg
->suggests_count
; i
++)
217 free (pkg
->suggests_str
[i
]);
218 free(pkg
->suggests_str
);
219 pkg
->suggests_str
= NULL
;
222 int count
= pkg
->pre_depends_count
224 + pkg
->recommends_count
225 + pkg
->suggests_count
;
227 for (i
=0; i
<count
; i
++)
228 compound_depend_deinit (&pkg
->depends
[i
]);
232 if (pkg
->conflicts
) {
233 for (i
=0; i
<pkg
->conflicts_count
; i
++)
234 compound_depend_deinit (&pkg
->conflicts
[i
]);
235 free (pkg
->conflicts
);
239 free (pkg
->provides
);
241 pkg
->pre_depends_count
= 0;
242 if (pkg
->pre_depends_str
)
243 free(pkg
->pre_depends_str
);
244 pkg
->pre_depends_str
= NULL
;
246 pkg
->provides_count
= 0;
250 pkg
->filename
= NULL
;
252 if (pkg
->local_filename
)
253 free(pkg
->local_filename
);
254 pkg
->local_filename
= NULL
;
256 /* CLEANUP: It'd be nice to pullin the cleanup function from
257 opkg_install.c here. See comment in
258 opkg_install.c:cleanup_temporary_files */
259 if (pkg
->tmp_unpack_dir
)
260 free(pkg
->tmp_unpack_dir
);
261 pkg
->tmp_unpack_dir
= NULL
;
267 #if defined HAVE_SHA256
269 free(pkg
->sha256sum
);
270 pkg
->sha256sum
= NULL
;
277 if (pkg
->installed_size
)
278 free(pkg
->installed_size
);
279 pkg
->installed_size
= NULL
;
283 pkg
->priority
= NULL
;
289 conffile_list_deinit(&pkg
->conffiles
);
291 /* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
292 since if they are calling deinit, they should know. Maybe do an
293 assertion here instead? */
294 pkg
->installed_files_ref_cnt
= 1;
295 pkg_free_installed_files(pkg
);
304 pkg_init_from_file(opkg_conf_t
*conf
, pkg_t
*pkg
, const char *filename
)
312 pkg
->local_filename
= xstrdup(filename
);
314 sprintf_alloc(&control_path
, "%s/%s.control.XXXXXX",
317 fd
= mkstemp(control_path
);
319 perror_msg("%s: mkstemp(%s)", __FUNCTION__
, control_path
);
324 control_file
= fdopen(fd
, "r+");
325 if (control_file
== NULL
) {
326 perror_msg("%s: fdopen", __FUNCTION__
, control_path
);
332 err
= pkg_extract_control_file_to_stream(pkg
, control_file
);
336 rewind(control_file
);
337 pkg_parse_from_stream(pkg
, control_file
, PFM_ALL
);
340 fclose(control_file
);
342 unlink(control_path
);
349 /* Merge any new information in newpkg into oldpkg */
350 /* XXX: CLEANUP: This function shouldn't actually modify anything in
351 newpkg, but should leave it usable. This rework is so that
352 pkg_hash_insert doesn't clobber the pkg that you pass into it. */
354 * uh, i thought that i had originally written this so that it took
355 * two pkgs and returned a new one? we can do that again... -sma
357 int pkg_merge(pkg_t
*oldpkg
, pkg_t
*newpkg
, int set_status
)
359 if (oldpkg
== newpkg
) {
363 if (!oldpkg
->auto_installed
)
364 oldpkg
->auto_installed
= newpkg
->auto_installed
;
367 oldpkg
->src
= newpkg
->src
;
369 oldpkg
->dest
= newpkg
->dest
;
370 if (!oldpkg
->architecture
)
371 oldpkg
->architecture
= xstrdup(newpkg
->architecture
);
372 if (!oldpkg
->arch_priority
)
373 oldpkg
->arch_priority
= newpkg
->arch_priority
;
374 if (!oldpkg
->section
)
375 oldpkg
->section
= xstrdup(newpkg
->section
);
376 if(!oldpkg
->maintainer
)
377 oldpkg
->maintainer
= xstrdup(newpkg
->maintainer
);
378 if(!oldpkg
->description
)
379 oldpkg
->description
= xstrdup(newpkg
->description
);
381 /* merge the state_flags from the new package */
382 oldpkg
->state_want
= newpkg
->state_want
;
383 oldpkg
->state_status
= newpkg
->state_status
;
384 oldpkg
->state_flag
= newpkg
->state_flag
;
386 if (oldpkg
->state_want
== SW_UNKNOWN
)
387 oldpkg
->state_want
= newpkg
->state_want
;
388 if (oldpkg
->state_status
== SS_NOT_INSTALLED
)
389 oldpkg
->state_status
= newpkg
->state_status
;
390 oldpkg
->state_flag
|= newpkg
->state_flag
;
393 if (!oldpkg
->depends_str
&& !oldpkg
->pre_depends_str
&& !oldpkg
->recommends_str
&& !oldpkg
->suggests_str
) {
394 oldpkg
->depends_str
= newpkg
->depends_str
;
395 newpkg
->depends_str
= NULL
;
396 oldpkg
->depends_count
= newpkg
->depends_count
;
397 newpkg
->depends_count
= 0;
399 oldpkg
->depends
= newpkg
->depends
;
400 newpkg
->depends
= NULL
;
402 oldpkg
->pre_depends_str
= newpkg
->pre_depends_str
;
403 newpkg
->pre_depends_str
= NULL
;
404 oldpkg
->pre_depends_count
= newpkg
->pre_depends_count
;
405 newpkg
->pre_depends_count
= 0;
407 oldpkg
->recommends_str
= newpkg
->recommends_str
;
408 newpkg
->recommends_str
= NULL
;
409 oldpkg
->recommends_count
= newpkg
->recommends_count
;
410 newpkg
->recommends_count
= 0;
412 oldpkg
->suggests_str
= newpkg
->suggests_str
;
413 newpkg
->suggests_str
= NULL
;
414 oldpkg
->suggests_count
= newpkg
->suggests_count
;
415 newpkg
->suggests_count
= 0;
418 if (oldpkg
->provides_count
<= 1) {
419 oldpkg
->provides_count
= newpkg
->provides_count
;
420 newpkg
->provides_count
= 0;
422 if (!oldpkg
->provides
) {
423 oldpkg
->provides
= newpkg
->provides
;
424 newpkg
->provides
= NULL
;
428 if (!oldpkg
->conflicts_count
) {
429 oldpkg
->conflicts_count
= newpkg
->conflicts_count
;
430 newpkg
->conflicts_count
= 0;
432 oldpkg
->conflicts
= newpkg
->conflicts
;
433 newpkg
->conflicts
= NULL
;
436 if (!oldpkg
->replaces_count
) {
437 oldpkg
->replaces_count
= newpkg
->replaces_count
;
438 newpkg
->replaces_count
= 0;
440 oldpkg
->replaces
= newpkg
->replaces
;
441 newpkg
->replaces
= NULL
;
444 if (!oldpkg
->filename
)
445 oldpkg
->filename
= xstrdup(newpkg
->filename
);
446 if (!oldpkg
->local_filename
)
447 oldpkg
->local_filename
= xstrdup(newpkg
->local_filename
);
448 if (!oldpkg
->tmp_unpack_dir
)
449 oldpkg
->tmp_unpack_dir
= xstrdup(newpkg
->tmp_unpack_dir
);
451 oldpkg
->md5sum
= xstrdup(newpkg
->md5sum
);
452 #if defined HAVE_SHA256
453 if (!oldpkg
->sha256sum
)
454 oldpkg
->sha256sum
= xstrdup(newpkg
->sha256sum
);
457 oldpkg
->size
= xstrdup(newpkg
->size
);
458 if (!oldpkg
->installed_size
)
459 oldpkg
->installed_size
= xstrdup(newpkg
->installed_size
);
460 if (!oldpkg
->priority
)
461 oldpkg
->priority
= xstrdup(newpkg
->priority
);
463 oldpkg
->source
= xstrdup(newpkg
->source
);
464 if (nv_pair_list_empty(&oldpkg
->conffiles
)){
465 list_splice_init(&newpkg
->conffiles
.head
, &oldpkg
->conffiles
.head
);
466 conffile_list_init(&newpkg
->conffiles
);
468 if (!oldpkg
->installed_files
){
469 oldpkg
->installed_files
= newpkg
->installed_files
;
470 oldpkg
->installed_files_ref_cnt
= newpkg
->installed_files_ref_cnt
;
471 newpkg
->installed_files
= NULL
;
473 if (!oldpkg
->essential
)
474 oldpkg
->essential
= newpkg
->essential
;
479 abstract_pkg_t
*abstract_pkg_new(void)
481 abstract_pkg_t
* ab_pkg
;
483 ab_pkg
= xcalloc(1, sizeof(abstract_pkg_t
));
485 if (ab_pkg
== NULL
) {
486 fprintf(stderr
, "%s: out of memory\n", __FUNCTION__
);
490 if ( abstract_pkg_init(ab_pkg
) < 0 )
496 int abstract_pkg_init(abstract_pkg_t
*ab_pkg
)
498 ab_pkg
->provided_by
= abstract_pkg_vec_alloc();
499 if (ab_pkg
->provided_by
==NULL
){
502 ab_pkg
->dependencies_checked
= 0;
503 ab_pkg
->state_status
= SS_NOT_INSTALLED
;
508 void set_flags_from_control(opkg_conf_t
*conf
, pkg_t
*pkg
){
512 sprintf_alloc(&file_name
,"%s/%s.control", pkg
->dest
->info_dir
, pkg
->name
);
514 fp
= fopen(file_name
, "r");
516 opkg_message(conf
, OPKG_ERROR
, "fopen(%s): %s\n",
517 file_name
, strerror(errno
));
524 if (pkg_parse_from_stream(pkg
, fp
, PFM_ESSENTIAL
)) {
525 opkg_message(conf
, OPKG_DEBUG
, "unable to read control file for %s. May be empty\n", pkg
->name
);
533 void pkg_formatted_field(FILE *fp
, pkg_t
*pkg
, const char *field
)
537 if (strlen(field
) < PKG_MINIMUM_FIELD_NAME_LEN
) {
538 goto UNKNOWN_FMT_FIELD
;
545 if (strcasecmp(field
, "Architecture") == 0) {
546 if (pkg
->architecture
) {
547 fprintf(fp
, "Architecture: %s\n", pkg
->architecture
);
549 } else if (strcasecmp(field
, "Auto-Installed") == 0) {
550 if (pkg
->auto_installed
)
551 fprintf(fp
, "Auto-Installed: yes\n");
553 goto UNKNOWN_FMT_FIELD
;
558 if (strcasecmp(field
, "Conffiles") == 0) {
559 conffile_list_elt_t
*iter
;
561 if (nv_pair_list_empty(&pkg
->conffiles
))
564 fprintf(fp
, "Conffiles:\n");
565 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
; iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
566 if (((conffile_t
*)iter
->data
)->name
&& ((conffile_t
*)iter
->data
)->value
) {
567 fprintf(fp
, " %s %s\n",
568 ((conffile_t
*)iter
->data
)->name
,
569 ((conffile_t
*)iter
->data
)->value
);
572 } else if (strcasecmp(field
, "Conflicts") == 0) {
574 if (pkg
->conflicts_count
) {
575 fprintf(fp
, "Conflicts:");
576 for(i
= 0; i
< pkg
->conflicts_count
; i
++) {
577 cdep
= pkg
->conflicts
[i
].possibilities
[0];
578 fprintf(fp
, "%s %s", i
== 0 ? "" : ",",
581 fprintf(fp
, " (%s%s)",
582 constraint_to_str(cdep
->constraint
),
589 goto UNKNOWN_FMT_FIELD
;
594 if (strcasecmp(field
, "Depends") == 0) {
595 if (pkg
->depends_count
) {
596 fprintf(fp
, "Depends:");
597 for(i
= 0; i
< pkg
->depends_count
; i
++) {
598 char *str
= pkg_depend_str(pkg
, i
);
599 fprintf(fp
, "%s %s", i
== 0 ? "" : ",", str
);
604 } else if (strcasecmp(field
, "Description") == 0) {
605 if (pkg
->description
) {
606 fprintf(fp
, "Description: %s\n", pkg
->description
);
609 goto UNKNOWN_FMT_FIELD
;
614 if (pkg
->essential
) {
615 fprintf(fp
, "Essential: yes\n");
621 fprintf(fp
, "Filename: %s\n", pkg
->filename
);
626 if (strcasecmp(field
, "Installed-Size") == 0) {
627 fprintf(fp
, "Installed-Size: %s\n", pkg
->installed_size
);
628 } else if (strcasecmp(field
, "Installed-Time") == 0 && pkg
->installed_time
) {
629 fprintf(fp
, "Installed-Time: %lu\n", pkg
->installed_time
);
634 if (strcasecmp(field
, "Maintainer") == 0) {
635 if (pkg
->maintainer
) {
636 fprintf(fp
, "maintainer: %s\n", pkg
->maintainer
);
638 } else if (strcasecmp(field
, "MD5sum") == 0) {
640 fprintf(fp
, "MD5Sum: %s\n", pkg
->md5sum
);
643 goto UNKNOWN_FMT_FIELD
;
648 if (strcasecmp(field
, "Package") == 0) {
649 fprintf(fp
, "Package: %s\n", pkg
->name
);
650 } else if (strcasecmp(field
, "Priority") == 0) {
651 fprintf(fp
, "Priority: %s\n", pkg
->priority
);
652 } else if (strcasecmp(field
, "Provides") == 0) {
653 if (pkg
->provides_count
) {
654 fprintf(fp
, "Provides:");
655 for(i
= 1; i
< pkg
->provides_count
; i
++) {
656 fprintf(fp
, "%s %s", i
== 1 ? "" : ",",
657 pkg
->provides
[i
]->name
);
662 goto UNKNOWN_FMT_FIELD
;
667 if (strcasecmp (field
, "Replaces") == 0) {
668 if (pkg
->replaces_count
) {
669 fprintf(fp
, "Replaces:");
670 for (i
= 0; i
< pkg
->replaces_count
; i
++) {
671 fprintf(fp
, "%s %s", i
== 0 ? "" : ",",
672 pkg
->replaces
[i
]->name
);
676 } else if (strcasecmp (field
, "Recommends") == 0) {
677 if (pkg
->recommends_count
) {
678 fprintf(fp
, "Recommends:");
679 for(i
= 0; i
< pkg
->recommends_count
; i
++) {
680 fprintf(fp
, "%s %s", i
== 0 ? "" : ",", pkg
->recommends_str
[i
]);
685 goto UNKNOWN_FMT_FIELD
;
690 if (strcasecmp(field
, "Section") == 0) {
692 fprintf(fp
, "Section: %s\n", pkg
->section
);
694 #if defined HAVE_SHA256
695 } else if (strcasecmp(field
, "SHA256sum") == 0) {
696 if (pkg
->sha256sum
) {
697 fprintf(fp
, "SHA256sum: %s\n", pkg
->sha256sum
);
700 } else if (strcasecmp(field
, "Size") == 0) {
702 fprintf(fp
, "Size: %s\n", pkg
->size
);
704 } else if (strcasecmp(field
, "Source") == 0) {
706 fprintf(fp
, "Source: %s\n", pkg
->source
);
708 } else if (strcasecmp(field
, "Status") == 0) {
709 char *pflag
= pkg_state_flag_to_str(pkg
->state_flag
);
710 char *pstat
= pkg_state_status_to_str(pkg
->state_status
);
711 char *pwant
= pkg_state_want_to_str(pkg
->state_want
);
713 if (pflag
== NULL
|| pstat
== NULL
|| pwant
== NULL
)
716 fprintf(fp
, "Status: %s %s %s\n", pwant
, pflag
, pstat
);
721 } else if (strcasecmp(field
, "Suggests") == 0) {
722 if (pkg
->suggests_count
) {
723 fprintf(fp
, "Suggests:");
724 for(i
= 0; i
< pkg
->suggests_count
; i
++) {
725 fprintf(fp
, "%s %s", i
== 0 ? "" : ",", pkg
->suggests_str
[i
]);
730 goto UNKNOWN_FMT_FIELD
;
735 if (strcasecmp(field
, "Tags") == 0) {
737 fprintf(fp
, "Tags: %s\n", pkg
->tags
);
744 char *version
= pkg_version_str_alloc(pkg
);
747 fprintf(fp
, "Version: %s\n", version
);
752 goto UNKNOWN_FMT_FIELD
;
758 fprintf(stderr
, "%s: ERROR: Unknown field name: %s\n", __FUNCTION__
, field
);
761 void pkg_formatted_info(FILE *fp
, pkg_t
*pkg
)
763 pkg_formatted_field(fp
, pkg
, "Package");
764 pkg_formatted_field(fp
, pkg
, "Version");
765 pkg_formatted_field(fp
, pkg
, "Depends");
766 pkg_formatted_field(fp
, pkg
, "Recommends");
767 pkg_formatted_field(fp
, pkg
, "Suggests");
768 pkg_formatted_field(fp
, pkg
, "Provides");
769 pkg_formatted_field(fp
, pkg
, "Replaces");
770 pkg_formatted_field(fp
, pkg
, "Conflicts");
771 pkg_formatted_field(fp
, pkg
, "Status");
772 pkg_formatted_field(fp
, pkg
, "Section");
773 pkg_formatted_field(fp
, pkg
, "Essential");
774 pkg_formatted_field(fp
, pkg
, "Architecture");
775 pkg_formatted_field(fp
, pkg
, "Maintainer");
776 pkg_formatted_field(fp
, pkg
, "MD5sum");
777 pkg_formatted_field(fp
, pkg
, "Size");
778 pkg_formatted_field(fp
, pkg
, "Filename");
779 pkg_formatted_field(fp
, pkg
, "Conffiles");
780 pkg_formatted_field(fp
, pkg
, "Source");
781 pkg_formatted_field(fp
, pkg
, "Description");
782 pkg_formatted_field(fp
, pkg
, "Installed-Time");
783 pkg_formatted_field(fp
, pkg
, "Tags");
787 void pkg_print_status(pkg_t
* pkg
, FILE * file
)
793 /* XXX: QUESTION: Do we actually want more fields here? The
794 original idea was to save space by installing only what was
795 needed for actual computation, (package, version, status,
796 essential, conffiles). The assumption is that all other fields
797 can be found in th available file.
799 But, someone proposed the idea to make it possible to
800 reconstruct a .opk from an installed package, (ie. for beaming
801 from one handheld to another). So, maybe we actually want a few
802 more fields here, (depends, suggests, etc.), so that that would
803 be guaranteed to work even in the absence of more information
804 from the available file.
806 28-MAR-03: kergoth and I discussed this yesterday. We think
807 the essential info needs to be here for all installed packages
808 because they may not appear in the Packages files on various
809 feeds. Furthermore, one should be able to install from URL or
810 local storage without requiring a Packages file from any feed.
813 pkg_formatted_field(file
, pkg
, "Package");
814 pkg_formatted_field(file
, pkg
, "Version");
815 pkg_formatted_field(file
, pkg
, "Depends");
816 pkg_formatted_field(file
, pkg
, "Recommends");
817 pkg_formatted_field(file
, pkg
, "Suggests");
818 pkg_formatted_field(file
, pkg
, "Provides");
819 pkg_formatted_field(file
, pkg
, "Replaces");
820 pkg_formatted_field(file
, pkg
, "Conflicts");
821 pkg_formatted_field(file
, pkg
, "Status");
822 pkg_formatted_field(file
, pkg
, "Essential");
823 pkg_formatted_field(file
, pkg
, "Architecture");
824 pkg_formatted_field(file
, pkg
, "Conffiles");
825 pkg_formatted_field(file
, pkg
, "Installed-Time");
826 pkg_formatted_field(file
, pkg
, "Auto-Installed");
831 * libdpkg - Debian packaging suite library routines
832 * vercmp.c - comparison of version numbers
834 * Copyright (C) 1995 Ian Jackson <iwj10@cus.cam.ac.uk>
836 int pkg_compare_versions(const pkg_t
*pkg
, const pkg_t
*ref_pkg
)
840 if (pkg
->epoch
> ref_pkg
->epoch
) {
844 if (pkg
->epoch
< ref_pkg
->epoch
) {
848 r
= verrevcmp(pkg
->version
, ref_pkg
->version
);
853 r
= verrevcmp(pkg
->revision
, ref_pkg
->revision
);
861 /* assume ascii; warning: evaluates x multiple times! */
862 #define order(x) ((x) == '~' ? -1 \
865 : isalpha((x)) ? (x) \
868 static int verrevcmp(const char *val
, const char *ref
) {
872 while (*val
|| *ref
) {
875 while ( (*val
&& !isdigit(*val
)) || (*ref
&& !isdigit(*ref
)) ) {
876 int vc
= order(*val
), rc
= order(*ref
);
877 if (vc
!= rc
) return vc
- rc
;
881 while ( *val
== '0' ) val
++;
882 while ( *ref
== '0' ) ref
++;
883 while (isdigit(*val
) && isdigit(*ref
)) {
884 if (!first_diff
) first_diff
= *val
- *ref
;
887 if (isdigit(*val
)) return 1;
888 if (isdigit(*ref
)) return -1;
889 if (first_diff
) return first_diff
;
894 int pkg_version_satisfied(pkg_t
*it
, pkg_t
*ref
, const char *op
)
898 r
= pkg_compare_versions(it
, ref
);
900 if (strcmp(op
, "<=") == 0 || strcmp(op
, "<") == 0) {
904 if (strcmp(op
, ">=") == 0 || strcmp(op
, ">") == 0) {
908 if (strcmp(op
, "<<") == 0) {
912 if (strcmp(op
, ">>") == 0) {
916 if (strcmp(op
, "=") == 0) {
920 fprintf(stderr
, "unknown operator: %s", op
);
924 int pkg_name_version_and_architecture_compare(const void *p1
, const void *p2
)
926 const pkg_t
*a
= *(const pkg_t
**) p1
;
927 const pkg_t
*b
= *(const pkg_t
**) p2
;
930 if (!a
->name
|| !b
->name
) {
931 fprintf(stderr
, "pkg_name_version_and_architecture_compare: a=%p a->name=%p b=%p b->name=%p\n",
932 a
, a
->name
, b
, b
->name
);
936 namecmp
= strcmp(a
->name
, b
->name
);
939 vercmp
= pkg_compare_versions(a
, b
);
942 if (!a
->arch_priority
|| !b
->arch_priority
) {
943 fprintf(stderr
, "pkg_name_version_and_architecture_compare: a=%p a->arch_priority=%i b=%p b->arch_priority=%i\n",
944 a
, a
->arch_priority
, b
, b
->arch_priority
);
947 if (a
->arch_priority
> b
->arch_priority
)
949 if (a
->arch_priority
< b
->arch_priority
)
954 int abstract_pkg_name_compare(const void *p1
, const void *p2
)
956 const abstract_pkg_t
*a
= *(const abstract_pkg_t
**)p1
;
957 const abstract_pkg_t
*b
= *(const abstract_pkg_t
**)p2
;
958 if (!a
->name
|| !b
->name
) {
959 fprintf(stderr
, "abstract_pkg_name_compare: a=%p a->name=%p b=%p b->name=%p\n",
960 a
, a
->name
, b
, b
->name
);
963 return strcmp(a
->name
, b
->name
);
968 pkg_version_str_alloc(pkg_t
*pkg
)
974 sprintf_alloc(&version
, "%d:%s-%s",
975 pkg
->epoch
, pkg
->version
, pkg
->revision
);
977 sprintf_alloc(&version
, "%d:%s",
978 pkg
->epoch
, pkg
->version
);
981 sprintf_alloc(&version
, "%s-%s",
982 pkg
->version
, pkg
->revision
);
984 version
= xstrdup(pkg
->version
);
991 * XXX: this should be broken into two functions
993 str_list_t
*pkg_get_installed_files(opkg_conf_t
*conf
, pkg_t
*pkg
)
996 char *list_file_name
= NULL
;
997 FILE *list_file
= NULL
;
999 char *installed_file_name
;
1002 pkg
->installed_files_ref_cnt
++;
1004 if (pkg
->installed_files
) {
1005 return pkg
->installed_files
;
1008 pkg
->installed_files
= str_list_alloc();
1010 /* For uninstalled packages, get the file list directly from the package.
1011 For installed packages, look at the package.list file in the database.
1013 if (pkg
->state_status
== SS_NOT_INSTALLED
|| pkg
->dest
== NULL
) {
1014 if (pkg
->local_filename
== NULL
) {
1015 return pkg
->installed_files
;
1017 /* XXX: CLEANUP: Maybe rewrite this to avoid using a temporary
1018 file. In other words, change deb_extract so that it can
1019 simply return the file list as a char *[] rather than
1020 insisting on writing in to a FILE * as it does now. */
1021 sprintf_alloc(&list_file_name
, "%s/%s.list.XXXXXX",
1022 conf
->tmp_dir
, pkg
->name
);
1023 fd
= mkstemp(list_file_name
);
1025 opkg_message(conf
, OPKG_ERROR
, "%s: mkstemp(%s): %s",
1026 __FUNCTION__
, list_file_name
, strerror(errno
));
1027 free(list_file_name
);
1028 return pkg
->installed_files
;
1030 list_file
= fdopen(fd
, "r+");
1031 if (list_file
== NULL
) {
1032 opkg_message(conf
, OPKG_ERROR
, "%s: fdopen: %s",
1033 __FUNCTION__
, strerror(errno
));
1035 unlink(list_file_name
);
1036 free(list_file_name
);
1037 return pkg
->installed_files
;
1039 err
= pkg_extract_data_file_names_to_stream(pkg
, list_file
);
1041 opkg_message(conf
, OPKG_ERROR
, "%s: Error extracting file list "
1042 "from %s: %s\n", __FUNCTION__
,
1043 pkg
->local_filename
, strerror(err
));
1045 unlink(list_file_name
);
1046 free(list_file_name
);
1047 return pkg
->installed_files
;
1051 sprintf_alloc(&list_file_name
, "%s/%s.list",
1052 pkg
->dest
->info_dir
, pkg
->name
);
1053 list_file
= fopen(list_file_name
, "r");
1054 if (list_file
== NULL
) {
1055 opkg_message(conf
, OPKG_ERROR
, "%s: fopen(%s): %s\n",
1056 __FUNCTION__
, list_file_name
, strerror(errno
));
1057 free(list_file_name
);
1058 return pkg
->installed_files
;
1060 free(list_file_name
);
1063 if (conf
->offline_root
)
1064 rootdirlen
= strlen(conf
->offline_root
);
1069 line
= file_read_line_alloc(list_file
);
1076 if (pkg
->state_status
== SS_NOT_INSTALLED
|| pkg
->dest
== NULL
) {
1077 if (*file_name
== '.') {
1080 if (*file_name
== '/') {
1083 sprintf_alloc(&installed_file_name
, "%s%s",
1084 pkg
->dest
->root_dir
, file_name
);
1086 if (conf
->offline_root
&&
1087 strncmp(conf
->offline_root
, file_name
, rootdirlen
)) {
1088 sprintf_alloc(&installed_file_name
, "%s%s",
1089 conf
->offline_root
, file_name
);
1091 // already contains root_dir as header -> ABSOLUTE
1092 sprintf_alloc(&installed_file_name
, "%s", file_name
);
1095 str_list_append(pkg
->installed_files
, installed_file_name
);
1096 free(installed_file_name
);
1102 if (pkg
->state_status
== SS_NOT_INSTALLED
|| pkg
->dest
== NULL
) {
1103 unlink(list_file_name
);
1104 free(list_file_name
);
1107 return pkg
->installed_files
;
1110 /* XXX: CLEANUP: This function and it's counterpart,
1111 (pkg_get_installed_files), do not match our init/deinit naming
1112 convention. Nor the alloc/free convention. But, then again, neither
1113 of these conventions currrently fit the way these two functions
1115 int pkg_free_installed_files(pkg_t
*pkg
)
1117 pkg
->installed_files_ref_cnt
--;
1119 if (pkg
->installed_files_ref_cnt
> 0)
1122 if (pkg
->installed_files
) {
1123 str_list_purge(pkg
->installed_files
);
1126 pkg
->installed_files
= NULL
;
1131 int pkg_remove_installed_files_list(opkg_conf_t
*conf
, pkg_t
*pkg
)
1134 char *list_file_name
;
1136 //I don't think pkg_free_installed_files should be called here. Jamey
1137 //pkg_free_installed_files(pkg);
1139 sprintf_alloc(&list_file_name
, "%s/%s.list",
1140 pkg
->dest
->info_dir
, pkg
->name
);
1141 if (!conf
->noaction
) {
1142 err
= unlink(list_file_name
);
1143 free(list_file_name
);
1152 conffile_t
*pkg_get_conffile(pkg_t
*pkg
, const char *file_name
)
1154 conffile_list_elt_t
*iter
;
1155 conffile_t
*conffile
;
1161 for (iter
= nv_pair_list_first(&pkg
->conffiles
); iter
; iter
= nv_pair_list_next(&pkg
->conffiles
, iter
)) {
1162 conffile
= (conffile_t
*)iter
->data
;
1164 if (strcmp(conffile
->name
, file_name
) == 0) {
1172 int pkg_run_script(opkg_conf_t
*conf
, pkg_t
*pkg
,
1173 const char *script
, const char *args
)
1182 /* XXX: CLEANUP: There must be a better way to handle maintainer
1183 scripts when running with offline_root mode and/or a dest other
1184 than '/'. I've been playing around with some clever chroot
1185 tricks and I might come up with something workable. */
1187 * Attempt to provide a restricted environment for offline operation
1188 * Need the following set as a minimum:
1189 * OPKG_OFFLINE_ROOT = absolute path to root dir
1190 * D = absolute path to root dir (for OE generated postinst)
1191 * PATH = something safe (a restricted set of utilities)
1194 if (conf
->offline_root
) {
1195 if (conf
->offline_root_path
) {
1196 setenv("PATH", conf
->offline_root_path
, 1);
1198 opkg_message(conf
, OPKG_NOTICE
,
1199 "(offline root mode: not running %s.%s)\n", pkg
->name
, script
);
1202 setenv("OPKG_OFFLINE_ROOT", conf
->offline_root
, 1);
1203 setenv("D", conf
->offline_root
, 1);
1206 /* XXX: FEATURE: When conf->offline_root is set, we should run the
1207 maintainer script within a chroot environment. */
1209 /* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages
1210 have scripts in pkg->tmp_unpack_dir. */
1211 if (pkg
->state_status
== SS_INSTALLED
|| pkg
->state_status
== SS_UNPACKED
) {
1212 if (pkg
->dest
== NULL
) {
1213 fprintf(stderr
, "%s: ERROR: installed package %s has a NULL dest\n",
1214 __FUNCTION__
, pkg
->name
);
1217 sprintf_alloc(&path
, "%s/%s.%s", pkg
->dest
->info_dir
, pkg
->name
, script
);
1219 if (pkg
->tmp_unpack_dir
== NULL
) {
1220 fprintf(stderr
, "%s: ERROR: uninstalled package %s has a NULL tmp_unpack_dir\n",
1221 __FUNCTION__
, pkg
->name
);
1224 sprintf_alloc(&path
, "%s/%s", pkg
->tmp_unpack_dir
, script
);
1227 opkg_message(conf
, OPKG_INFO
, "Running script %s\n", path
);
1230 pkg
->dest
? pkg
->dest
->root_dir
: conf
->default_dest
->root_dir
, 1);
1232 if (! file_exists(path
)) {
1237 sprintf_alloc(&cmd
, "%s %s", path
, args
);
1240 const char *argv
[] = {"sh", "-c", cmd
, NULL
};
1241 err
= xsystem(argv
);
1246 fprintf(stderr
, "%s script returned status %d\n", script
, err
);
1253 char *pkg_state_want_to_str(pkg_state_want_t sw
)
1257 for (i
=0; i
< ARRAY_SIZE(pkg_state_want_map
); i
++) {
1258 if (pkg_state_want_map
[i
].value
== sw
) {
1259 return xstrdup(pkg_state_want_map
[i
].str
);
1263 fprintf(stderr
, "%s: ERROR: Illegal value for state_want: %d\n",
1265 return xstrdup("<STATE_WANT_UNKNOWN>");
1268 pkg_state_want_t
pkg_state_want_from_str(char *str
)
1272 for (i
=0; i
< ARRAY_SIZE(pkg_state_want_map
); i
++) {
1273 if (strcmp(str
, pkg_state_want_map
[i
].str
) == 0) {
1274 return pkg_state_want_map
[i
].value
;
1278 fprintf(stderr
, "%s: ERROR: Illegal value for state_want string: %s\n",
1283 char *pkg_state_flag_to_str(pkg_state_flag_t sf
)
1286 int len
= 3; /* ok\000 is minimum */
1289 /* clear the temporary flags before converting to string */
1290 sf
&= SF_NONVOLATILE_FLAGS
;
1293 return xstrdup("ok");
1296 for (i
=0; i
< ARRAY_SIZE(pkg_state_flag_map
); i
++) {
1297 if (sf
& pkg_state_flag_map
[i
].value
) {
1298 len
+= strlen(pkg_state_flag_map
[i
].str
) + 1;
1303 for (i
=0; i
< ARRAY_SIZE(pkg_state_flag_map
); i
++) {
1304 if (sf
& pkg_state_flag_map
[i
].value
) {
1305 strcat(str
, pkg_state_flag_map
[i
].str
);
1310 str
[len
-1] = 0; /* squash last comma */
1315 pkg_state_flag_t
pkg_state_flag_from_str(const char *str
)
1320 if (strcmp(str
, "ok") == 0) {
1323 for (i
=0; i
< ARRAY_SIZE(pkg_state_flag_map
); i
++) {
1324 const char *sfname
= pkg_state_flag_map
[i
].str
;
1325 int sfname_len
= strlen(sfname
);
1326 if (strncmp(str
, sfname
, sfname_len
) == 0) {
1327 sf
|= pkg_state_flag_map
[i
].value
;
1329 if (str
[0] == ',') {
1340 char *pkg_state_status_to_str(pkg_state_status_t ss
)
1344 for (i
=0; i
< ARRAY_SIZE(pkg_state_status_map
); i
++) {
1345 if (pkg_state_status_map
[i
].value
== ss
) {
1346 return xstrdup(pkg_state_status_map
[i
].str
);
1350 fprintf(stderr
, "%s: ERROR: Illegal value for state_status: %d\n",
1352 return xstrdup("<STATE_STATUS_UNKNOWN>");
1355 pkg_state_status_t
pkg_state_status_from_str(const char *str
)
1359 for (i
=0; i
< ARRAY_SIZE(pkg_state_status_map
); i
++) {
1360 if (strcmp(str
, pkg_state_status_map
[i
].str
) == 0) {
1361 return pkg_state_status_map
[i
].value
;
1365 fprintf(stderr
, "%s: ERROR: Illegal value for state_status string: %s\n",
1367 return SS_NOT_INSTALLED
;
1370 int pkg_arch_supported(opkg_conf_t
*conf
, pkg_t
*pkg
)
1372 nv_pair_list_elt_t
*l
;
1374 if (!pkg
->architecture
)
1377 list_for_each_entry(l
, &conf
->arch_list
.head
, node
) {
1378 nv_pair_t
*nv
= (nv_pair_t
*)l
->data
;
1379 if (strcmp(nv
->name
, pkg
->architecture
) == 0) {
1380 opkg_message(conf
, OPKG_DEBUG
, "arch %s (priority %s) supported for pkg %s\n", nv
->name
, nv
->value
, pkg
->name
);
1385 opkg_message(conf
, OPKG_DEBUG
, "arch %s unsupported for pkg %s\n", pkg
->architecture
, pkg
->name
);
1389 int pkg_get_arch_priority(opkg_conf_t
*conf
, const char *archname
)
1391 nv_pair_list_elt_t
*l
;
1393 list_for_each_entry(l
, &conf
->arch_list
.head
, node
) {
1394 nv_pair_t
*nv
= (nv_pair_t
*)l
->data
;
1395 if (strcmp(nv
->name
, archname
) == 0) {
1396 int priority
= strtol(nv
->value
, NULL
, 0);
1403 int pkg_info_preinstall_check(opkg_conf_t
*conf
)
1406 hash_table_t
*pkg_hash
= &conf
->pkg_hash
;
1407 pkg_vec_t
*available_pkgs
= pkg_vec_alloc();
1408 pkg_vec_t
*installed_pkgs
= pkg_vec_alloc();
1410 opkg_message(conf
, OPKG_INFO
, "pkg_info_preinstall_check: updating arch priority for each package\n");
1411 pkg_hash_fetch_available(pkg_hash
, available_pkgs
);
1412 /* update arch_priority for each package */
1413 for (i
= 0; i
< available_pkgs
->len
; i
++) {
1414 pkg_t
*pkg
= available_pkgs
->pkgs
[i
];
1415 int arch_priority
= 1;
1418 // opkg_message(conf, OPKG_DEBUG2, " package %s version=%s arch=%p:", pkg->name, pkg->version, pkg->architecture);
1419 if (pkg
->architecture
)
1420 arch_priority
= pkg_get_arch_priority(conf
, pkg
->architecture
);
1422 opkg_message(conf
, OPKG_ERROR
, "pkg_info_preinstall_check: no architecture for package %s\n", pkg
->name
);
1423 // opkg_message(conf, OPKG_DEBUG2, "%s arch_priority=%d\n", pkg->architecture, arch_priority);
1424 pkg
->arch_priority
= arch_priority
;
1427 for (i
= 0; i
< available_pkgs
->len
; i
++) {
1428 pkg_t
*pkg
= available_pkgs
->pkgs
[i
];
1429 if (!pkg
->arch_priority
&& (pkg
->state_flag
|| (pkg
->state_want
!= SW_UNKNOWN
))) {
1430 /* clear flags and want for any uninstallable package */
1431 opkg_message(conf
, OPKG_DEBUG
, "Clearing state_want and state_flag for pkg=%s (arch_priority=%d flag=%d want=%d)\n",
1432 pkg
->name
, pkg
->arch_priority
, pkg
->state_flag
, pkg
->state_want
);
1433 pkg
->state_want
= SW_UNKNOWN
;
1434 pkg
->state_flag
= 0;
1437 pkg_vec_free(available_pkgs
);
1439 /* update the file owner data structure */
1440 opkg_message(conf
, OPKG_INFO
, "pkg_info_preinstall_check: update file owner list\n");
1441 pkg_hash_fetch_all_installed(pkg_hash
, installed_pkgs
);
1442 for (i
= 0; i
< installed_pkgs
->len
; i
++) {
1443 pkg_t
*pkg
= installed_pkgs
->pkgs
[i
];
1444 str_list_t
*installed_files
= pkg_get_installed_files(conf
, pkg
); /* this causes installed_files to be cached */
1445 str_list_elt_t
*iter
, *niter
;
1446 if (installed_files
== NULL
) {
1447 opkg_message(conf
, OPKG_ERROR
, "No installed files for pkg %s\n", pkg
->name
);
1450 for (iter
= str_list_first(installed_files
), niter
= str_list_next(installed_files
, iter
);
1452 iter
= niter
, niter
= str_list_next(installed_files
, iter
)) {
1453 char *installed_file
= (char *) iter
->data
;
1454 // opkg_message(conf, OPKG_DEBUG2, "pkg %s: file=%s\n", pkg->name, installed_file);
1455 file_hash_set_file_owner(conf
, installed_file
, pkg
);
1457 pkg_free_installed_files(pkg
);
1459 pkg_vec_free(installed_pkgs
);
1464 struct pkg_write_filelist_data
{
1470 void pkg_write_filelist_helper(const char *key
, void *entry_
, void *data_
)
1472 struct pkg_write_filelist_data
*data
= data_
;
1473 pkg_t
*entry
= entry_
;
1474 if (entry
== data
->pkg
) {
1475 fprintf(data
->stream
, "%s\n", key
);
1479 int pkg_write_filelist(opkg_conf_t
*conf
, pkg_t
*pkg
)
1481 struct pkg_write_filelist_data data
;
1482 char *list_file_name
= NULL
;
1486 opkg_message(conf
, OPKG_ERROR
, "Null pkg\n");
1489 opkg_message(conf
, OPKG_INFO
,
1490 " creating %s.list file\n", pkg
->name
);
1491 sprintf_alloc(&list_file_name
, "%s/%s.list", pkg
->dest
->info_dir
, pkg
->name
);
1492 if (!list_file_name
) {
1493 opkg_message(conf
, OPKG_ERROR
, "Failed to alloc list_file_name\n");
1496 opkg_message(conf
, OPKG_INFO
,
1497 " creating %s file for pkg %s\n", list_file_name
, pkg
->name
);
1498 data
.stream
= fopen(list_file_name
, "w");
1500 opkg_message(conf
, OPKG_ERROR
, "Could not open %s for writing: %s\n",
1501 list_file_name
, strerror(errno
));
1506 hash_table_foreach(&conf
->file_hash
, pkg_write_filelist_helper
, &data
);
1507 fclose(data
.stream
);
1508 free(list_file_name
);
1510 pkg
->state_flag
&= ~SF_FILELIST_CHANGED
;
1515 int pkg_write_changed_filelists(opkg_conf_t
*conf
)
1517 pkg_vec_t
*installed_pkgs
= pkg_vec_alloc();
1518 hash_table_t
*pkg_hash
= &conf
->pkg_hash
;
1524 opkg_message(conf
, OPKG_INFO
, "%s: saving changed filelists\n", __FUNCTION__
);
1525 pkg_hash_fetch_all_installed(pkg_hash
, installed_pkgs
);
1526 for (i
= 0; i
< installed_pkgs
->len
; i
++) {
1527 pkg_t
*pkg
= installed_pkgs
->pkgs
[i
];
1528 if (pkg
->state_flag
& SF_FILELIST_CHANGED
) {
1529 opkg_message(conf
, OPKG_DEBUG
, "Calling pkg_write_filelist for pkg=%s from %s\n", pkg
->name
, __FUNCTION__
);
1530 err
= pkg_write_filelist(conf
, pkg
);
1532 opkg_message(conf
, OPKG_NOTICE
, "pkg_write_filelist pkg=%s returned %d\n", pkg
->name
, err
);
1535 pkg_vec_free (installed_pkgs
);