1 /* pkg.c - the itsy 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.
25 #include "pkg_parse.h"
26 #include "pkg_extract.h"
27 #include "opkg_message.h"
28 #include "opkg_utils.h"
30 #include "sprintf_alloc.h"
31 #include "file_util.h"
34 #include "opkg_conf.h"
36 typedef struct enum_map enum_map_t;
43 static const enum_map_t pkg_state_want_map[] = {
44 { SW_UNKNOWN, "unknown"},
45 { SW_INSTALL, "install"},
46 { SW_DEINSTALL, "deinstall"},
50 static const enum_map_t pkg_state_flag_map[] = {
52 { SF_REINSTREQ, "reinstreq"},
54 { SF_REPLACE, "replace"},
55 { SF_NOPRUNE, "noprune"},
56 { SF_PREFER, "prefer"},
57 { SF_OBSOLETE, "obsolete"},
61 static const enum_map_t pkg_state_status_map[] = {
62 { SS_NOT_INSTALLED, "not-installed" },
63 { SS_UNPACKED, "unpacked" },
64 { SS_HALF_CONFIGURED, "half-configured" },
65 { SS_INSTALLED, "installed" },
66 { SS_HALF_INSTALLED, "half-installed" },
67 { SS_CONFIG_FILES, "config-files" },
68 { SS_POST_INST_FAILED, "post-inst-failed" },
69 { SS_REMOVAL_FAILED, "removal-failed" }
72 static int verrevcmp(const char *val, const char *ref);
79 pkg = malloc(sizeof(pkg_t));
81 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
90 int pkg_init(pkg_t *pkg)
92 memset(pkg, 0, sizeof(pkg_t));
97 pkg->familiar_revision = NULL;
100 pkg->architecture = NULL;
101 pkg->maintainer = NULL;
103 pkg->description = NULL;
104 pkg->state_want = SW_UNKNOWN;
105 pkg->state_flag = SF_OK;
106 pkg->state_status = SS_NOT_INSTALLED;
107 pkg->depends_str = NULL;
108 pkg->provides_str = NULL;
109 pkg->depends_count = 0;
111 pkg->suggests_str = NULL;
112 pkg->recommends_str = NULL;
113 pkg->suggests_count = 0;
114 pkg->recommends_count = 0;
116 /* Abhaya: added init for conflicts fields */
117 pkg->conflicts = NULL;
118 pkg->conflicts_count = 0;
120 /* added for replaces. Jamey 7/23/2002 */
121 pkg->replaces = NULL;
122 pkg->replaces_count = 0;
124 pkg->pre_depends_count = 0;
125 pkg->pre_depends_str = NULL;
126 pkg->provides_count = 0;
127 pkg->provides = NULL;
128 pkg->filename = NULL;
129 pkg->local_filename = NULL;
130 pkg->tmp_unpack_dir = NULL;
133 pkg->installed_size = NULL;
134 pkg->priority = NULL;
136 conffile_list_init(&pkg->conffiles);
137 pkg->installed_files = NULL;
138 pkg->installed_files_ref_cnt = 0;
140 pkg->provided_by_hand = 0;
145 void pkg_deinit(pkg_t *pkg)
152 /* revision and familiar_revision share storage with version, so
154 pkg->revision = NULL;
155 pkg->familiar_revision = NULL;
156 /* owned by opkg_conf_t */
158 /* owned by opkg_conf_t */
160 free(pkg->architecture);
161 pkg->architecture = NULL;
162 free(pkg->maintainer);
163 pkg->maintainer = NULL;
166 free(pkg->description);
167 pkg->description = NULL;
168 pkg->state_want = SW_UNKNOWN;
169 pkg->state_flag = SF_OK;
170 pkg->state_status = SS_NOT_INSTALLED;
171 free(pkg->depends_str);
172 pkg->depends_str = NULL;
173 free(pkg->provides_str);
174 pkg->provides_str = NULL;
175 pkg->depends_count = 0;
176 /* XXX: CLEANUP: MEMORY_LEAK: how to free up pkg->depends ? */
177 pkg->pre_depends_count = 0;
178 free(pkg->pre_depends_str);
179 pkg->pre_depends_str = NULL;
180 pkg->provides_count = 0;
181 /* XXX: CLEANUP: MEMORY_LEAK: how to free up pkg->provides ? */
182 /* XXX: CLEANUP: MEMORY_LEAK: how to free up pkg->suggests ? */
184 pkg->filename = NULL;
185 free(pkg->local_filename);
186 pkg->local_filename = NULL;
187 /* CLEANUP: It'd be nice to pullin the cleanup function from
188 opkg_install.c here. See comment in
189 opkg_install.c:cleanup_temporary_files */
190 free(pkg->tmp_unpack_dir);
191 pkg->tmp_unpack_dir = NULL;
196 free(pkg->installed_size);
197 pkg->installed_size = NULL;
199 pkg->priority = NULL;
202 conffile_list_deinit(&pkg->conffiles);
203 /* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
204 since if they are calling deinit, they should know. Maybe do an
205 assertion here instead? */
206 pkg->installed_files_ref_cnt = 1;
207 pkg_free_installed_files(pkg);
213 int pkg_init_from_file(pkg_t *pkg, const char *filename)
220 if (err) { return err; }
222 pkg->local_filename = strdup(filename);
224 control_file = tmpfile();
225 err = pkg_extract_control_file_to_stream(pkg, control_file);
226 if (err) { return err; }
228 rewind(control_file);
229 raw = read_raw_pkgs_from_stream(control_file);
230 pkg_parse_raw(pkg, &raw, NULL, NULL);
232 fclose(control_file);
237 /* Merge any new information in newpkg into oldpkg */
238 /* XXX: CLEANUP: This function shouldn't actually modify anything in
239 newpkg, but should leave it usable. This rework is so that
240 pkg_hash_insert doesn't clobber the pkg that you pass into it. */
242 * uh, i thought that i had originally written this so that it took
243 * two pkgs and returned a new one? we can do that again... -sma
245 int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
247 if (oldpkg == newpkg) {
252 oldpkg->src = newpkg->src;
254 oldpkg->dest = newpkg->dest;
255 if (!oldpkg->architecture)
256 oldpkg->architecture = str_dup_safe(newpkg->architecture);
257 if (!oldpkg->arch_priority)
258 oldpkg->arch_priority = newpkg->arch_priority;
259 if (!oldpkg->section)
260 oldpkg->section = str_dup_safe(newpkg->section);
261 if(!oldpkg->maintainer)
262 oldpkg->maintainer = str_dup_safe(newpkg->maintainer);
263 if(!oldpkg->description)
264 oldpkg->description = str_dup_safe(newpkg->description);
266 /* merge the state_flags from the new package */
267 oldpkg->state_want = newpkg->state_want;
268 oldpkg->state_status = newpkg->state_status;
269 oldpkg->state_flag = newpkg->state_flag;
271 if (oldpkg->state_want == SW_UNKNOWN)
272 oldpkg->state_want = newpkg->state_want;
273 if (oldpkg->state_status == SS_NOT_INSTALLED)
274 oldpkg->state_status = newpkg->state_status;
275 oldpkg->state_flag |= newpkg->state_flag;
278 if (!oldpkg->depends_str && !oldpkg->pre_depends_str && !oldpkg->recommends_str && !oldpkg->suggests_str) {
279 oldpkg->depends_str = newpkg->depends_str;
280 newpkg->depends_str = NULL;
281 oldpkg->depends_count = newpkg->depends_count;
282 newpkg->depends_count = 0;
284 oldpkg->depends = newpkg->depends;
285 newpkg->depends = NULL;
287 oldpkg->pre_depends_str = newpkg->pre_depends_str;
288 newpkg->pre_depends_str = NULL;
289 oldpkg->pre_depends_count = newpkg->pre_depends_count;
290 newpkg->pre_depends_count = 0;
292 oldpkg->recommends_str = newpkg->recommends_str;
293 newpkg->recommends_str = NULL;
294 oldpkg->recommends_count = newpkg->recommends_count;
295 newpkg->recommends_count = 0;
297 oldpkg->suggests_str = newpkg->suggests_str;
298 newpkg->suggests_str = NULL;
299 oldpkg->suggests_count = newpkg->suggests_count;
300 newpkg->suggests_count = 0;
303 if (!oldpkg->provides_str) {
304 oldpkg->provides_str = newpkg->provides_str;
305 newpkg->provides_str = NULL;
306 oldpkg->provides_count = newpkg->provides_count;
307 newpkg->provides_count = 0;
309 oldpkg->provides = newpkg->provides;
310 newpkg->provides = NULL;
313 if (!oldpkg->conflicts_str) {
314 oldpkg->conflicts_str = newpkg->conflicts_str;
315 newpkg->conflicts_str = NULL;
316 oldpkg->conflicts_count = newpkg->conflicts_count;
317 newpkg->conflicts_count = 0;
319 oldpkg->conflicts = newpkg->conflicts;
320 newpkg->conflicts = NULL;
323 if (!oldpkg->replaces_str) {
324 oldpkg->replaces_str = newpkg->replaces_str;
325 newpkg->replaces_str = NULL;
326 oldpkg->replaces_count = newpkg->replaces_count;
327 newpkg->replaces_count = 0;
329 oldpkg->replaces = newpkg->replaces;
330 newpkg->replaces = NULL;
333 if (!oldpkg->filename)
334 oldpkg->filename = str_dup_safe(newpkg->filename);
336 fprintf(stdout, "pkg=%s old local_filename=%s new local_filename=%s\n",
337 oldpkg->name, oldpkg->local_filename, newpkg->local_filename);
338 if (!oldpkg->local_filename)
339 oldpkg->local_filename = str_dup_safe(newpkg->local_filename);
340 if (!oldpkg->tmp_unpack_dir)
341 oldpkg->tmp_unpack_dir = str_dup_safe(newpkg->tmp_unpack_dir);
343 oldpkg->md5sum = str_dup_safe(newpkg->md5sum);
345 oldpkg->size = str_dup_safe(newpkg->size);
346 if (!oldpkg->installed_size)
347 oldpkg->installed_size = str_dup_safe(newpkg->installed_size);
348 if (!oldpkg->priority)
349 oldpkg->priority = str_dup_safe(newpkg->priority);
351 oldpkg->source = str_dup_safe(newpkg->source);
352 if (oldpkg->conffiles.head == NULL){
353 oldpkg->conffiles = newpkg->conffiles;
354 conffile_list_init(&newpkg->conffiles);
356 if (!oldpkg->installed_files){
357 oldpkg->installed_files = newpkg->installed_files;
358 oldpkg->installed_files_ref_cnt = newpkg->installed_files_ref_cnt;
359 newpkg->installed_files = NULL;
361 if (!oldpkg->essential)
362 oldpkg->essential = newpkg->essential;
367 abstract_pkg_t *abstract_pkg_new(void)
369 abstract_pkg_t * ab_pkg;
371 ab_pkg = malloc(sizeof(abstract_pkg_t));
373 if (ab_pkg == NULL) {
374 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
378 if ( abstract_pkg_init(ab_pkg) < 0 )
384 int abstract_pkg_init(abstract_pkg_t *ab_pkg)
386 memset(ab_pkg, 0, sizeof(abstract_pkg_t));
388 ab_pkg->provided_by = abstract_pkg_vec_alloc();
389 if (ab_pkg->provided_by==NULL){
392 ab_pkg->dependencies_checked = 0;
393 ab_pkg->state_status = SS_NOT_INSTALLED;
398 void set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){
401 char **raw_start=NULL;
403 temp_str = (char *) malloc (strlen(pkg->dest->info_dir)+strlen(pkg->name)+12);
404 if (temp_str == NULL ){
405 opkg_message(conf, OPKG_INFO, "Out of memory in %s\n", __FUNCTION__);
408 sprintf( temp_str,"%s/%s.control",pkg->dest->info_dir,pkg->name);
410 raw = raw_start = read_raw_pkgs_from_file(temp_str);
412 opkg_message(conf, OPKG_ERROR, "Unable to open the control file in %s\n", __FUNCTION__);
417 if (!pkg_valorize_other_field(pkg, &raw ) == 0) {
418 opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name);
434 char * pkg_formatted_info(pkg_t *pkg )
441 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
447 line = pkg_formatted_field(pkg, "Package");
448 strncat(buff ,line, strlen(line));
451 line = pkg_formatted_field(pkg, "Version");
452 strncat(buff ,line, strlen(line));
455 line = pkg_formatted_field(pkg, "Depends");
456 strncat(buff ,line, strlen(line));
459 line = pkg_formatted_field(pkg, "Recommends");
460 strncat(buff ,line, strlen(line));
463 line = pkg_formatted_field(pkg, "Suggests");
464 strncat(buff ,line, strlen(line));
467 line = pkg_formatted_field(pkg, "Provides");
468 strncat(buff ,line, strlen(line));
471 line = pkg_formatted_field(pkg, "Replaces");
472 strncat(buff ,line, strlen(line));
475 line = pkg_formatted_field(pkg, "Conflicts");
476 strncat(buff ,line, strlen(line));
479 line = pkg_formatted_field(pkg, "Status");
480 strncat(buff ,line, strlen(line));
483 line = pkg_formatted_field(pkg, "Section");
484 strncat(buff ,line, strlen(line));
487 line = pkg_formatted_field(pkg, "Essential"); /* @@@@ should be removed in future release. *//* I do not agree with this Pigi*/
488 strncat(buff ,line, strlen(line));
491 line = pkg_formatted_field(pkg, "Architecture");
492 strncat(buff ,line, strlen(line));
495 line = pkg_formatted_field(pkg, "Maintainer");
496 strncat(buff ,line, strlen(line));
499 line = pkg_formatted_field(pkg, "MD5sum");
500 strncat(buff ,line, strlen(line));
503 line = pkg_formatted_field(pkg, "Size");
504 strncat(buff ,line, strlen(line));
507 line = pkg_formatted_field(pkg, "Filename");
508 strncat(buff ,line, strlen(line));
511 line = pkg_formatted_field(pkg, "Conffiles");
512 strncat(buff ,line, strlen(line));
515 line = pkg_formatted_field(pkg, "Source");
516 strncat(buff ,line, strlen(line));
519 line = pkg_formatted_field(pkg, "Description");
520 strncat(buff ,line, strlen(line));
523 line = pkg_formatted_field(pkg, "Installed-Time");
524 strncat(buff ,line, strlen(line));
527 line = pkg_formatted_field(pkg, "Tags");
528 strncat(buff ,line, strlen(line));
534 char * pkg_formatted_field(pkg_t *pkg, const char *field )
536 static size_t LINE_LEN = 128;
537 char * temp = (char *)malloc(1);
539 int flag_provide_false = 0;
542 Pigi: After some discussion with Florian we decided to modify the full procedure in
543 dynamic memory allocation. This should avoid any other segv in this area ( except for bugs )
546 if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
547 goto UNKNOWN_FMT_FIELD;
556 if (strcasecmp(field, "Architecture") == 0) {
558 if (pkg->architecture) {
559 temp = (char *)realloc(temp,strlen(pkg->architecture)+17);
561 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
565 snprintf(temp, (strlen(pkg->architecture)+17), "Architecture: %s\n", pkg->architecture);
567 } else if (strcasecmp(field, "Auto-Installed") == 0) {
568 /* Auto-Installed flag */
569 if (pkg->auto_installed) {
570 char * s = "Auto-Installed: yes\n";
571 temp = (char *)realloc(temp, strlen(s) + 1);
575 goto UNKNOWN_FMT_FIELD;
580 if (strcasecmp(field, "Conffiles") == 0) {
582 conffile_list_elt_t *iter;
583 char confstr[LINE_LEN];
585 if (pkg->conffiles.head == NULL) {
590 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
591 if (iter->data->name && iter->data->value) {
592 len = len + (strlen(iter->data->name)+strlen(iter->data->value)+5);
595 temp = (char *)realloc(temp,len);
597 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
601 strncpy(temp, "Conffiles:\n", 12);
602 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
603 if (iter->data->name && iter->data->value) {
604 snprintf(confstr, LINE_LEN, "%s %s\n", iter->data->name, iter->data->value);
605 strncat(temp, confstr, strlen(confstr));
608 } else if (strcasecmp(field, "Conflicts") == 0) {
611 if (pkg->conflicts_count) {
612 char conflictstr[LINE_LEN];
614 for(i = 0; i < pkg->conflicts_count; i++) {
615 len = len + (strlen(pkg->conflicts_str[i])+5);
617 temp = (char *)realloc(temp,len);
619 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
623 strncpy(temp, "Conflicts:", 11);
624 for(i = 0; i < pkg->conflicts_count; i++) {
625 snprintf(conflictstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->conflicts_str[i]);
626 strncat(temp, conflictstr, strlen(conflictstr));
628 strncat(temp, "\n", strlen("\n"));
631 goto UNKNOWN_FMT_FIELD;
636 if (strcasecmp(field, "Depends") == 0) {
640 if (pkg->depends_count) {
641 char depstr[LINE_LEN];
643 for(i = 0; i < pkg->depends_count; i++) {
644 len = len + (strlen(pkg->depends_str[i])+4);
646 temp = (char *)realloc(temp,len);
648 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
652 strncpy(temp, "Depends:", 10);
653 for(i = 0; i < pkg->depends_count; i++) {
654 snprintf(depstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->depends_str[i]);
655 strncat(temp, depstr, strlen(depstr));
657 strncat(temp, "\n", strlen("\n"));
659 } else if (strcasecmp(field, "Description") == 0) {
661 if (pkg->description) {
662 temp = (char *)realloc(temp,strlen(pkg->description)+16);
664 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
668 snprintf(temp, (strlen(pkg->description)+16), "Description: %s\n", pkg->description);
671 goto UNKNOWN_FMT_FIELD;
677 if (pkg->essential) {
678 temp = (char *)realloc(temp,16);
680 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
684 snprintf(temp, (16), "Essential: yes\n");
692 temp = (char *)realloc(temp,strlen(pkg->filename)+12);
694 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
698 snprintf(temp, (strlen(pkg->filename)+12), "Filename: %s\n", pkg->filename);
704 if (strcasecmp(field, "Installed-Size") == 0) {
706 temp = (char *)realloc(temp,strlen(pkg->installed_size)+17);
708 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
712 snprintf(temp, (strlen(pkg->installed_size)+17), "Installed-Size: %s\n", pkg->installed_size);
713 } else if (strcasecmp(field, "Installed-Time") == 0 && pkg->installed_time) {
714 temp = (char *)realloc(temp,29);
716 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
720 snprintf(temp, 29, "Installed-Time: %lu\n", pkg->installed_time);
726 /* Maintainer | MD5sum */
727 if (strcasecmp(field, "Maintainer") == 0) {
729 if (pkg->maintainer) {
730 temp = (char *)realloc(temp,strlen(pkg->maintainer)+14);
732 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
736 snprintf(temp, (strlen(pkg->maintainer)+14), "maintainer: %s\n", pkg->maintainer);
738 } else if (strcasecmp(field, "MD5sum") == 0) {
741 temp = (char *)realloc(temp,strlen(pkg->md5sum)+11);
743 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
747 snprintf(temp, (strlen(pkg->md5sum)+11), "MD5Sum: %s\n", pkg->md5sum);
750 goto UNKNOWN_FMT_FIELD;
756 if (strcasecmp(field, "Package") == 0) {
758 temp = (char *)realloc(temp,strlen(pkg->name)+11);
760 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
764 snprintf(temp, (strlen(pkg->name)+11), "Package: %s\n", pkg->name);
765 } else if (strcasecmp(field, "Priority") == 0) {
767 temp = (char *)realloc(temp,strlen(pkg->priority)+12);
769 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
773 snprintf(temp, (strlen(pkg->priority)+12), "Priority: %s\n", pkg->priority);
774 } else if (strcasecmp(field, "Provides") == 0) {
778 if (pkg->provides_count) {
779 /* Here we check if the opkg_internal_use_only is used, and we discard it.*/
780 for ( i=0; i < pkg->provides_count; i++ ){
781 if (strstr(pkg->provides_str[i],"opkg_internal_use_only")!=NULL) {
782 memset (pkg->provides_str[i],'\x0',strlen(pkg->provides_str[i])); /* Pigi clear my trick flag, just in case */
783 flag_provide_false = 1;
786 if ( !flag_provide_false || /* Pigi there is not my trick flag */
787 ((flag_provide_false) && (pkg->provides_count > 1))){ /* Pigi There is, but we also have others Provides */
788 char provstr[LINE_LEN];
790 for(i = 0; i < pkg->provides_count; i++) {
791 len = len + (strlen(pkg->provides_str[i])+5);
793 temp = (char *)realloc(temp,len);
795 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
799 strncpy(temp, "Provides:", 12);
800 for(i = 0; i < pkg->provides_count; i++) {
801 if (strlen(pkg->provides_str[i])>0){;
802 snprintf(provstr, LINE_LEN, "%s %s", i == 1 ? "" : ",", pkg->provides_str[i]);
803 strncat(temp, provstr, strlen(provstr));
806 strncat(temp, "\n", strlen("\n"));
810 goto UNKNOWN_FMT_FIELD;
817 /* Replaces | Recommends*/
818 if (strcasecmp (field, "Replaces") == 0) {
819 if (pkg->replaces_count) {
820 char replstr[LINE_LEN];
822 for (i = 0; i < pkg->replaces_count; i++) {
823 len = len + (strlen(pkg->replaces_str[i])+5);
825 temp = (char *)realloc(temp,len);
827 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
831 strncpy(temp, "Replaces:", 12);
832 for (i = 0; i < pkg->replaces_count; i++) {
833 snprintf(replstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->replaces_str[i]);
834 strncat(temp, replstr, strlen(replstr));
836 strncat(temp, "\n", strlen("\n"));
838 } else if (strcasecmp (field, "Recommends") == 0) {
839 if (pkg->recommends_count) {
840 char recstr[LINE_LEN];
842 for(i = 0; i < pkg->recommends_count; i++) {
843 len = len + (strlen( pkg->recommends_str[i])+5);
845 temp = (char *)realloc(temp,len);
847 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
851 strncpy(temp, "Recommends:", 13);
852 for(i = 0; i < pkg->recommends_count; i++) {
853 snprintf(recstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->recommends_str[i]);
854 strncat(temp, recstr, strlen(recstr));
856 strncat(temp, "\n", strlen("\n"));
859 goto UNKNOWN_FMT_FIELD;
865 /* Section | Size | Source | Status | Suggests */
866 if (strcasecmp(field, "Section") == 0) {
869 temp = (char *)realloc(temp,strlen(pkg->section)+11);
871 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
875 snprintf(temp, (strlen(pkg->section)+11), "Section: %s\n", pkg->section);
877 } else if (strcasecmp(field, "Size") == 0) {
880 temp = (char *)realloc(temp,strlen(pkg->size)+8);
882 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
886 snprintf(temp, (strlen(pkg->size)+8), "Size: %s\n", pkg->size);
888 } else if (strcasecmp(field, "Source") == 0) {
891 temp = (char *)realloc(temp,strlen(pkg->source)+10);
893 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
897 snprintf(temp, (strlen(pkg->source)+10), "Source: %s\n", pkg->source);
899 } else if (strcasecmp(field, "Status") == 0) {
901 /* Benjamin Pineau note: we should avoid direct usage of
902 * strlen(arg) without keeping "arg" for later free()
904 char *pflag=pkg_state_flag_to_str(pkg->state_flag);
905 char *pstat=pkg_state_status_to_str(pkg->state_status);
906 char *pwant=pkg_state_want_to_str(pkg->state_want);
908 size_t sum_of_sizes = (size_t) ( strlen(pwant)+ strlen(pflag)+ strlen(pstat) + 12 );
909 temp = (char *)realloc(temp,sum_of_sizes);
911 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
915 snprintf(temp, sum_of_sizes , "Status: %s %s %s\n", pwant, pflag, pstat);
918 if(pstat) /* pfstat can be NULL if ENOMEM */
920 } else if (strcasecmp(field, "Suggests") == 0) {
921 if (pkg->suggests_count) {
923 char sugstr[LINE_LEN];
925 for(i = 0; i < pkg->suggests_count; i++) {
926 len = len + (strlen(pkg->suggests_str[i])+5);
928 temp = (char *)realloc(temp,len);
930 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
934 strncpy(temp, "Suggests:", 10);
935 for(i = 0; i < pkg->suggests_count; i++) {
936 snprintf(sugstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->suggests_str[i]);
937 strncat(temp, sugstr, strlen(sugstr));
939 strncat(temp, "\n", strlen("\n"));
942 goto UNKNOWN_FMT_FIELD;
948 if (strcasecmp(field, "Tags") == 0) {
951 temp = (char *)realloc(temp,strlen(pkg->tags)+8);
953 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
957 snprintf(temp, (strlen(pkg->tags)+8), "Tags: %s\n", pkg->tags);
964 char *version = pkg_version_str_alloc(pkg);
965 temp = (char *)realloc(temp,strlen(version)+14);
967 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
971 snprintf(temp, (strlen(version)+12), "Version: %s\n", version);
976 goto UNKNOWN_FMT_FIELD;
979 if ( strlen(temp)<2 ) {
985 fprintf(stderr, "%s: ERROR: Unknown field name: %s\n", __FUNCTION__, field);
986 if ( strlen(temp)<2 ) {
993 void pkg_print_info(pkg_t *pkg, FILE *file)
1000 buff = pkg_formatted_info(pkg);
1003 if (strlen(buff)>2){
1004 fwrite(buff, 1, strlen(buff), file);
1009 void pkg_print_status(pkg_t * pkg, FILE * file)
1015 /* XXX: QUESTION: Do we actually want more fields here? The
1016 original idea was to save space by installing only what was
1017 needed for actual computation, (package, version, status,
1018 essential, conffiles). The assumption is that all other fields
1019 can be found in th available file.
1021 But, someone proposed the idea to make it possible to
1022 reconstruct a .ipk from an installed package, (ie. for beaming
1023 from one handheld to another). So, maybe we actually want a few
1024 more fields here, (depends, suggests, etc.), so that that would
1025 be guaranteed to work even in the absence of more information
1026 from the available file.
1028 28-MAR-03: kergoth and I discussed this yesterday. We think
1029 the essential info needs to be here for all installed packages
1030 because they may not appear in the Packages files on various
1031 feeds. Furthermore, one should be able to install from URL or
1032 local storage without requiring a Packages file from any feed.
1035 pkg_print_field(pkg, file, "Package");
1036 pkg_print_field(pkg, file, "Version");
1037 pkg_print_field(pkg, file, "Depends");
1038 pkg_print_field(pkg, file, "Recommends");
1039 pkg_print_field(pkg, file, "Suggests");
1040 pkg_print_field(pkg, file, "Provides");
1041 pkg_print_field(pkg, file, "Replaces");
1042 pkg_print_field(pkg, file, "Conflicts");
1043 pkg_print_field(pkg, file, "Status");
1044 pkg_print_field(pkg, file, "Essential"); /* @@@@ should be removed in future release. */
1045 pkg_print_field(pkg, file, "Architecture");
1046 pkg_print_field(pkg, file, "Conffiles");
1047 pkg_print_field(pkg, file, "Installed-Time");
1048 pkg_print_field(pkg, file, "Auto-Installed");
1052 void pkg_print_field(pkg_t *pkg, FILE *file, const char *field)
1055 if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
1056 fprintf(stderr, "%s: ERROR: Unknown field name: %s\n",
1057 __FUNCTION__, field);
1059 buff = pkg_formatted_field(pkg, field);
1060 if (strlen(buff)>2) {
1061 fprintf(file, "%s", buff);
1069 * libdpkg - Debian packaging suite library routines
1070 * vercmp.c - comparison of version numbers
1072 * Copyright (C) 1995 Ian Jackson <iwj10@cus.cam.ac.uk>
1074 int pkg_compare_versions(const pkg_t *pkg, const pkg_t *ref_pkg)
1078 if (pkg->epoch > ref_pkg->epoch) {
1082 if (pkg->epoch < ref_pkg->epoch) {
1086 r = verrevcmp(pkg->version, ref_pkg->version);
1091 r = verrevcmp(pkg->revision, ref_pkg->revision);
1099 /* assume ascii; warning: evaluates x multiple times! */
1100 #define order(x) ((x) == '~' ? -1 \
1101 : isdigit((x)) ? 0 \
1103 : isalpha((x)) ? (x) \
1106 static int verrevcmp(const char *val, const char *ref) {
1110 while (*val || *ref) {
1113 while ( (*val && !isdigit(*val)) || (*ref && !isdigit(*ref)) ) {
1114 int vc= order(*val), rc= order(*ref);
1115 if (vc != rc) return vc - rc;
1119 while ( *val == '0' ) val++;
1120 while ( *ref == '0' ) ref++;
1121 while (isdigit(*val) && isdigit(*ref)) {
1122 if (!first_diff) first_diff= *val - *ref;
1125 if (isdigit(*val)) return 1;
1126 if (isdigit(*ref)) return -1;
1127 if (first_diff) return first_diff;
1132 int pkg_version_satisfied(pkg_t *it, pkg_t *ref, const char *op)
1136 r = pkg_compare_versions(it, ref);
1138 if (strcmp(op, "<=") == 0 || strcmp(op, "<") == 0) {
1142 if (strcmp(op, ">=") == 0 || strcmp(op, ">") == 0) {
1146 if (strcmp(op, "<<") == 0) {
1150 if (strcmp(op, ">>") == 0) {
1154 if (strcmp(op, "=") == 0) {
1158 fprintf(stderr, "unknown operator: %s", op);
1162 int pkg_name_version_and_architecture_compare(const void *p1, const void *p2)
1164 const pkg_t *a = *(const pkg_t**) p1;
1165 const pkg_t *b = *(const pkg_t**) p2;
1168 if (!a->name || !b->name) {
1169 fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->name=%p b=%p b->name=%p\n",
1170 a, a->name, b, b->name);
1174 namecmp = strcmp(a->name, b->name);
1177 vercmp = pkg_compare_versions(a, b);
1180 if (!a->arch_priority || !b->arch_priority) {
1181 fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->arch_priority=%i b=%p b->arch_priority=%i\n",
1182 a, a->arch_priority, b, b->arch_priority);
1185 if (a->arch_priority > b->arch_priority)
1187 if (a->arch_priority < b->arch_priority)
1192 int abstract_pkg_name_compare(const void *p1, const void *p2)
1194 const abstract_pkg_t *a = *(const abstract_pkg_t **)p1;
1195 const abstract_pkg_t *b = *(const abstract_pkg_t **)p2;
1196 if (!a->name || !b->name) {
1197 fprintf(stderr, "abstract_pkg_name_compare: a=%p a->name=%p b=%p b->name=%p\n",
1198 a, a->name, b, b->name);
1201 return strcmp(a->name, b->name);
1205 char *pkg_version_str_alloc(pkg_t *pkg)
1207 char *complete_version;
1212 sprintf_alloc(&epoch_str, "%d:", pkg->epoch);
1214 epoch_str = strdup("");
1217 if (pkg->revision && strlen(pkg->revision)) {
1218 sprintf_alloc(&revision_str, "-%s", pkg->revision);
1220 revision_str = strdup("");
1224 sprintf_alloc(&complete_version, "%s%s%s",
1225 epoch_str, pkg->version, revision_str);
1230 return complete_version;
1233 str_list_t *pkg_get_installed_files(pkg_t *pkg)
1236 char *list_file_name = NULL;
1237 FILE *list_file = NULL;
1239 char *installed_file_name;
1242 pkg->installed_files_ref_cnt++;
1244 if (pkg->installed_files) {
1245 return pkg->installed_files;
1248 pkg->installed_files = str_list_alloc();
1249 if (pkg->installed_files == NULL) {
1250 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
1254 /* For uninstalled packages, get the file list firectly from the package.
1255 For installed packages, look at the package.list file in the database.
1257 if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) {
1258 if (pkg->local_filename == NULL) {
1259 return pkg->installed_files;
1261 /* XXX: CLEANUP: Maybe rewrite this to avoid using a temporary
1262 file. In other words, change deb_extract so that it can
1263 simply return the file list as a char *[] rather than
1264 insisting on writing in to a FILE * as it does now. */
1265 list_file = tmpfile();
1266 err = pkg_extract_data_file_names_to_stream(pkg, list_file);
1269 fprintf(stderr, "%s: Error extracting file list from %s: %s\n",
1270 __FUNCTION__, pkg->local_filename, strerror(err));
1271 return pkg->installed_files;
1275 sprintf_alloc(&list_file_name, "%s/%s.list",
1276 pkg->dest->info_dir, pkg->name);
1277 if (! file_exists(list_file_name)) {
1278 free(list_file_name);
1279 return pkg->installed_files;
1282 list_file = fopen(list_file_name, "r");
1283 if (list_file == NULL) {
1284 fprintf(stderr, "WARNING: Cannot open %s: %s\n",
1285 list_file_name, strerror(errno));
1286 free(list_file_name);
1287 return pkg->installed_files;
1289 free(list_file_name);
1292 rootdirlen = strlen( pkg->dest->root_dir );
1296 line = file_read_line_alloc(list_file);
1303 /* Take pains to avoid uglies like "/./" in the middle of file_name. */
1304 if( strncmp( pkg->dest->root_dir,
1307 if (*file_name == '.') {
1310 if (*file_name == '/') {
1314 /* Freed in pkg_free_installed_files */
1315 sprintf_alloc(&installed_file_name, "%s%s", pkg->dest->root_dir, file_name);
1317 // already contains root_dir as header -> ABSOLUTE
1318 sprintf_alloc(&installed_file_name, "%s", file_name);
1320 str_list_append(pkg->installed_files, installed_file_name);
1326 return pkg->installed_files;
1329 /* XXX: CLEANUP: This function and it's counterpart,
1330 (pkg_get_installed_files), do not match our init/deinit naming
1331 convention. Nor the alloc/free convention. But, then again, neither
1332 of these conventions currrently fit the way these two functions
1334 int pkg_free_installed_files(pkg_t *pkg)
1336 str_list_elt_t *iter;
1338 pkg->installed_files_ref_cnt--;
1339 if (pkg->installed_files_ref_cnt > 0) {
1343 if (pkg->installed_files) {
1345 for (iter = pkg->installed_files->head; iter; iter = iter->next) {
1346 /* malloced in pkg_get_installed_files */
1351 str_list_deinit(pkg->installed_files);
1354 pkg->installed_files = NULL;
1359 int pkg_remove_installed_files_list(opkg_conf_t *conf, pkg_t *pkg)
1362 char *list_file_name;
1364 //I don't think pkg_free_installed_files should be called here. Jamey
1365 //pkg_free_installed_files(pkg);
1367 sprintf_alloc(&list_file_name, "%s/%s.list",
1368 pkg->dest->info_dir, pkg->name);
1369 if (!conf->noaction) {
1370 err = unlink(list_file_name);
1371 free(list_file_name);
1380 conffile_t *pkg_get_conffile(pkg_t *pkg, const char *file_name)
1382 conffile_list_elt_t *iter;
1383 conffile_t *conffile;
1389 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
1390 conffile = iter->data;
1392 if (strcmp(conffile->name, file_name) == 0) {
1400 int pkg_run_script(opkg_conf_t *conf, pkg_t *pkg,
1401 const char *script, const char *args)
1407 /* XXX: FEATURE: When conf->offline_root is set, we should run the
1408 maintainer script within a chroot environment. */
1410 /* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages
1411 have scripts in pkg->tmp_unpack_dir. */
1412 if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) {
1413 if (pkg->dest == NULL) {
1414 fprintf(stderr, "%s: ERROR: installed package %s has a NULL dest\n",
1415 __FUNCTION__, pkg->name);
1418 sprintf_alloc(&path, "%s/%s.%s", pkg->dest->info_dir, pkg->name, script);
1420 if (pkg->tmp_unpack_dir == NULL) {
1421 fprintf(stderr, "%s: ERROR: uninstalled package %s has a NULL tmp_unpack_dir\n",
1422 __FUNCTION__, pkg->name);
1425 sprintf_alloc(&path, "%s/%s", pkg->tmp_unpack_dir, script);
1428 opkg_message(conf, OPKG_INFO, "Running script %s\n", path);
1429 if (conf->noaction) return 0;
1431 /* XXX: CLEANUP: There must be a better way to handle maintainer
1432 scripts when running with offline_root mode and/or a dest other
1433 than '/'. I've been playing around with some clever chroot
1434 tricks and I might come up with something workable. */
1435 if (conf->offline_root) {
1436 setenv("OPKG_OFFLINE_ROOT", conf->offline_root, 1);
1440 pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir, 1);
1442 if (! file_exists(path)) {
1447 if (conf->offline_root) {
1448 fprintf(stderr, "(offline root mode: not running %s.%s)\n", pkg->name, script);
1453 sprintf_alloc(&cmd, "%s %s", path, args);
1460 fprintf(stderr, "%s script returned status %d\n", script, err);
1467 char *pkg_state_want_to_str(pkg_state_want_t sw)
1471 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1472 if (pkg_state_want_map[i].value == sw) {
1473 return strdup(pkg_state_want_map[i].str);
1477 fprintf(stderr, "%s: ERROR: Illegal value for state_want: %d\n",
1479 return strdup("<STATE_WANT_UNKNOWN>");
1482 pkg_state_want_t pkg_state_want_from_str(char *str)
1486 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1487 if (strcmp(str, pkg_state_want_map[i].str) == 0) {
1488 return pkg_state_want_map[i].value;
1492 fprintf(stderr, "%s: ERROR: Illegal value for state_want string: %s\n",
1497 char *pkg_state_flag_to_str(pkg_state_flag_t sf)
1500 int len = 3; /* ok\000 is minimum */
1503 /* clear the temporary flags before converting to string */
1504 sf &= SF_NONVOLATILE_FLAGS;
1507 return strdup("ok");
1510 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1511 if (sf & pkg_state_flag_map[i].value) {
1512 len += strlen(pkg_state_flag_map[i].str) + 1;
1516 if ( str == NULL ) {
1517 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
1521 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1522 if (sf & pkg_state_flag_map[i].value) {
1523 strcat(str, pkg_state_flag_map[i].str);
1528 str[len-1] = 0; /* squash last comma */
1533 pkg_state_flag_t pkg_state_flag_from_str(const char *str)
1538 if (strcmp(str, "ok") == 0) {
1541 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1542 const char *sfname = pkg_state_flag_map[i].str;
1543 int sfname_len = strlen(sfname);
1544 if (strncmp(str, sfname, sfname_len) == 0) {
1545 sf |= pkg_state_flag_map[i].value;
1547 if (str[0] == ',') {
1558 char *pkg_state_status_to_str(pkg_state_status_t ss)
1562 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1563 if (pkg_state_status_map[i].value == ss) {
1564 return strdup(pkg_state_status_map[i].str);
1568 fprintf(stderr, "%s: ERROR: Illegal value for state_status: %d\n",
1570 return strdup("<STATE_STATUS_UNKNOWN>");
1573 pkg_state_status_t pkg_state_status_from_str(const char *str)
1577 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1578 if (strcmp(str, pkg_state_status_map[i].str) == 0) {
1579 return pkg_state_status_map[i].value;
1583 fprintf(stderr, "%s: ERROR: Illegal value for state_status string: %s\n",
1585 return SS_NOT_INSTALLED;
1588 int pkg_arch_supported(opkg_conf_t *conf, pkg_t *pkg)
1590 nv_pair_list_elt_t *l;
1592 if (!pkg->architecture)
1595 l = conf->arch_list.head;
1598 nv_pair_t *nv = l->data;
1599 if (strcmp(nv->name, pkg->architecture) == 0) {
1600 opkg_message(conf, OPKG_DEBUG, "arch %s (priority %s) supported for pkg %s\n", nv->name, nv->value, pkg->name);
1606 opkg_message(conf, OPKG_DEBUG, "arch %s unsupported for pkg %s\n", pkg->architecture, pkg->name);
1610 int pkg_get_arch_priority(opkg_conf_t *conf, const char *archname)
1612 nv_pair_list_elt_t *l;
1614 l = conf->arch_list.head;
1617 nv_pair_t *nv = l->data;
1618 if (strcmp(nv->name, archname) == 0) {
1619 int priority = strtol(nv->value, NULL, 0);
1627 int pkg_info_preinstall_check(opkg_conf_t *conf)
1630 hash_table_t *pkg_hash = &conf->pkg_hash;
1631 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1632 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1634 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: updating arch priority for each package\n");
1635 pkg_hash_fetch_available(pkg_hash, available_pkgs);
1636 /* update arch_priority for each package */
1637 for (i = 0; i < available_pkgs->len; i++) {
1638 pkg_t *pkg = available_pkgs->pkgs[i];
1639 int arch_priority = 1;
1642 // opkg_message(conf, OPKG_DEBUG2, " package %s version=%s arch=%p:", pkg->name, pkg->version, pkg->architecture);
1643 if (pkg->architecture)
1644 arch_priority = pkg_get_arch_priority(conf, pkg->architecture);
1646 opkg_message(conf, OPKG_ERROR, "pkg_info_preinstall_check: no architecture for package %s\n", pkg->name);
1647 // opkg_message(conf, OPKG_DEBUG2, "%s arch_priority=%d\n", pkg->architecture, arch_priority);
1648 pkg->arch_priority = arch_priority;
1651 for (i = 0; i < available_pkgs->len; i++) {
1652 pkg_t *pkg = available_pkgs->pkgs[i];
1653 if (!pkg->arch_priority && (pkg->state_flag || (pkg->state_want != SW_UNKNOWN))) {
1654 /* clear flags and want for any uninstallable package */
1655 opkg_message(conf, OPKG_NOTICE, "Clearing state_want and state_flag for pkg=%s (arch_priority=%d flag=%d want=%d)\n",
1656 pkg->name, pkg->arch_priority, pkg->state_flag, pkg->state_want);
1657 pkg->state_want = SW_UNKNOWN;
1658 pkg->state_flag = 0;
1661 pkg_vec_free(available_pkgs);
1663 /* update the file owner data structure */
1664 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: update file owner list\n");
1665 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1666 for (i = 0; i < installed_pkgs->len; i++) {
1667 pkg_t *pkg = installed_pkgs->pkgs[i];
1668 str_list_t *installed_files = pkg_get_installed_files(pkg); /* this causes installed_files to be cached */
1669 str_list_elt_t *iter;
1670 if (installed_files == NULL) {
1671 opkg_message(conf, OPKG_ERROR, "No installed files for pkg %s\n", pkg->name);
1674 for (iter = installed_files->head; iter; iter = iter->next) {
1675 char *installed_file = iter->data;
1676 // opkg_message(conf, OPKG_DEBUG2, "pkg %s: file=%s\n", pkg->name, installed_file);
1677 file_hash_set_file_owner(conf, installed_file, pkg);
1680 pkg_vec_free(installed_pkgs);
1685 struct pkg_write_filelist_data {
1691 void pkg_write_filelist_helper(const char *key, void *entry_, void *data_)
1693 struct pkg_write_filelist_data *data = data_;
1694 pkg_t *entry = entry_;
1695 if (entry == data->pkg) {
1696 fprintf(data->stream, "%s\n", key);
1700 int pkg_write_filelist(opkg_conf_t *conf, pkg_t *pkg)
1702 struct pkg_write_filelist_data data;
1703 char *list_file_name = NULL;
1707 opkg_message(conf, OPKG_ERROR, "Null pkg\n");
1710 opkg_message(conf, OPKG_INFO,
1711 " creating %s.list file\n", pkg->name);
1712 sprintf_alloc(&list_file_name, "%s/%s.list", pkg->dest->info_dir, pkg->name);
1713 if (!list_file_name) {
1714 opkg_message(conf, OPKG_ERROR, "Failed to alloc list_file_name\n");
1717 opkg_message(conf, OPKG_INFO,
1718 " creating %s file for pkg %s\n", list_file_name, pkg->name);
1719 data.stream = fopen(list_file_name, "w");
1721 opkg_message(conf, OPKG_ERROR, "Could not open %s for writing: %s\n",
1722 list_file_name, strerror(errno));
1727 hash_table_foreach(&conf->file_hash, pkg_write_filelist_helper, &data);
1728 fclose(data.stream);
1729 free(list_file_name);
1734 int pkg_write_changed_filelists(opkg_conf_t *conf)
1736 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1737 hash_table_t *pkg_hash = &conf->pkg_hash;
1743 opkg_message(conf, OPKG_INFO, "%s: saving changed filelists\n", __FUNCTION__);
1744 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1745 for (i = 0; i < installed_pkgs->len; i++) {
1746 pkg_t *pkg = installed_pkgs->pkgs[i];
1747 if (pkg->state_flag & SF_FILELIST_CHANGED) {
1748 opkg_message(conf, OPKG_DEBUG, "Calling pkg_write_filelist for pkg=%s from %s\n", pkg->name, __FUNCTION__);
1749 err = pkg_write_filelist(conf, pkg);
1751 opkg_message(conf, OPKG_NOTICE, "pkg_write_filelist pkg=%s returned %d\n", pkg->name, err);