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.
26 #include "pkg_parse.h"
27 #include "pkg_extract.h"
28 #include "opkg_message.h"
29 #include "opkg_utils.h"
31 #include "sprintf_alloc.h"
32 #include "file_util.h"
35 #include "opkg_conf.h"
37 typedef struct enum_map enum_map_t;
44 static const enum_map_t pkg_state_want_map[] = {
45 { SW_UNKNOWN, "unknown"},
46 { SW_INSTALL, "install"},
47 { SW_DEINSTALL, "deinstall"},
51 static const enum_map_t pkg_state_flag_map[] = {
53 { SF_REINSTREQ, "reinstreq"},
55 { SF_REPLACE, "replace"},
56 { SF_NOPRUNE, "noprune"},
57 { SF_PREFER, "prefer"},
58 { SF_OBSOLETE, "obsolete"},
62 static const enum_map_t pkg_state_status_map[] = {
63 { SS_NOT_INSTALLED, "not-installed" },
64 { SS_UNPACKED, "unpacked" },
65 { SS_HALF_CONFIGURED, "half-configured" },
66 { SS_INSTALLED, "installed" },
67 { SS_HALF_INSTALLED, "half-installed" },
68 { SS_CONFIG_FILES, "config-files" },
69 { SS_POST_INST_FAILED, "post-inst-failed" },
70 { SS_REMOVAL_FAILED, "removal-failed" }
73 static int verrevcmp(const char *val, const char *ref);
80 pkg = calloc(1, sizeof(pkg_t));
82 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
91 int pkg_init(pkg_t *pkg)
99 pkg->architecture = NULL;
100 pkg->maintainer = NULL;
102 pkg->description = NULL;
103 pkg->state_want = SW_UNKNOWN;
104 pkg->state_flag = SF_OK;
105 pkg->state_status = SS_NOT_INSTALLED;
106 pkg->depends_str = NULL;
107 pkg->provides_str = NULL;
108 pkg->depends_count = 0;
110 pkg->suggests_str = NULL;
111 pkg->recommends_str = NULL;
112 pkg->suggests_count = 0;
113 pkg->recommends_count = 0;
115 active_list_init(&pkg->list);
117 /* Abhaya: added init for conflicts fields */
118 pkg->conflicts = NULL;
119 pkg->conflicts_count = 0;
121 /* added for replaces. Jamey 7/23/2002 */
122 pkg->replaces = NULL;
123 pkg->replaces_count = 0;
125 pkg->pre_depends_count = 0;
126 pkg->pre_depends_str = NULL;
127 pkg->provides_count = 0;
128 pkg->provides = NULL;
129 pkg->filename = NULL;
130 pkg->local_filename = NULL;
131 pkg->tmp_unpack_dir = 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)
168 /* revision shares storage with version, so
170 pkg->revision = NULL;
171 /* owned by opkg_conf_t */
173 /* owned by opkg_conf_t */
175 free(pkg->architecture);
176 pkg->architecture = NULL;
177 free(pkg->maintainer);
178 pkg->maintainer = NULL;
181 free(pkg->description);
182 pkg->description = NULL;
183 pkg->state_want = SW_UNKNOWN;
184 pkg->state_flag = SF_OK;
185 pkg->state_status = SS_NOT_INSTALLED;
187 active_list_clear(&pkg->list);
189 free (pkg->replaces);
190 pkg->replaces = NULL;
192 for (i = 0; i < pkg->depends_count; i++)
193 free (pkg->depends_str[i]);
194 free(pkg->depends_str);
195 pkg->depends_str = NULL;
197 for (i = 0; i < pkg->provides_count; i++)
198 free (pkg->provides_str[i]);
199 free(pkg->provides_str);
200 pkg->provides_str = NULL;
202 for (i = 0; i < pkg->conflicts_count; i++)
203 free (pkg->conflicts_str[i]);
204 free(pkg->conflicts_str);
205 pkg->conflicts_str = NULL;
207 for (i = 0; i < pkg->replaces_count; i++)
208 free (pkg->replaces_str[i]);
209 free(pkg->replaces_str);
210 pkg->replaces_str = NULL;
212 for (i = 0; i < pkg->recommends_count; i++)
213 free (pkg->recommends_str[i]);
214 free(pkg->recommends_str);
215 pkg->recommends_str = NULL;
217 for (i = 0; i < pkg->suggests_count; i++)
218 free (pkg->suggests_str[i]);
219 free(pkg->suggests_str);
220 pkg->suggests_str = NULL;
224 int count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
227 for (x = 0; x < count; x++)
228 compound_depend_deinit (&pkg->depends[x]);
235 for (x = 0; x < pkg->conflicts_count; x++)
236 compound_depend_deinit (&pkg->conflicts[x]);
237 free (pkg->conflicts);
240 free (pkg->provides);
242 pkg->pre_depends_count = 0;
243 free(pkg->pre_depends_str);
244 pkg->pre_depends_str = NULL;
245 pkg->provides_count = 0;
247 pkg->filename = NULL;
248 free(pkg->local_filename);
249 pkg->local_filename = NULL;
250 /* CLEANUP: It'd be nice to pullin the cleanup function from
251 opkg_install.c here. See comment in
252 opkg_install.c:cleanup_temporary_files */
253 free(pkg->tmp_unpack_dir);
254 pkg->tmp_unpack_dir = NULL;
259 free(pkg->installed_size);
260 pkg->installed_size = NULL;
262 pkg->priority = NULL;
265 conffile_list_deinit(&pkg->conffiles);
266 /* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
267 since if they are calling deinit, they should know. Maybe do an
268 assertion here instead? */
269 pkg->installed_files_ref_cnt = 1;
270 pkg_free_installed_files(pkg);
276 int pkg_init_from_file(pkg_t *pkg, const char *filename)
283 if (err) { return err; }
285 pkg->local_filename = strdup(filename);
287 control_file = tmpfile();
288 err = pkg_extract_control_file_to_stream(pkg, control_file);
289 if (err) { return err; }
291 rewind(control_file);
292 raw = read_raw_pkgs_from_stream(control_file);
293 pkg_parse_raw(pkg, &raw, NULL, NULL);
295 fclose(control_file);
300 /* Merge any new information in newpkg into oldpkg */
301 /* XXX: CLEANUP: This function shouldn't actually modify anything in
302 newpkg, but should leave it usable. This rework is so that
303 pkg_hash_insert doesn't clobber the pkg that you pass into it. */
305 * uh, i thought that i had originally written this so that it took
306 * two pkgs and returned a new one? we can do that again... -sma
308 int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
310 if (oldpkg == newpkg) {
315 oldpkg->src = newpkg->src;
317 oldpkg->dest = newpkg->dest;
318 if (!oldpkg->architecture)
319 oldpkg->architecture = str_dup_safe(newpkg->architecture);
320 if (!oldpkg->arch_priority)
321 oldpkg->arch_priority = newpkg->arch_priority;
322 if (!oldpkg->section)
323 oldpkg->section = str_dup_safe(newpkg->section);
324 if(!oldpkg->maintainer)
325 oldpkg->maintainer = str_dup_safe(newpkg->maintainer);
326 if(!oldpkg->description)
327 oldpkg->description = str_dup_safe(newpkg->description);
329 /* merge the state_flags from the new package */
330 oldpkg->state_want = newpkg->state_want;
331 oldpkg->state_status = newpkg->state_status;
332 oldpkg->state_flag = newpkg->state_flag;
334 if (oldpkg->state_want == SW_UNKNOWN)
335 oldpkg->state_want = newpkg->state_want;
336 if (oldpkg->state_status == SS_NOT_INSTALLED)
337 oldpkg->state_status = newpkg->state_status;
338 oldpkg->state_flag |= newpkg->state_flag;
341 if (!oldpkg->depends_str && !oldpkg->pre_depends_str && !oldpkg->recommends_str && !oldpkg->suggests_str) {
342 oldpkg->depends_str = newpkg->depends_str;
343 newpkg->depends_str = NULL;
344 oldpkg->depends_count = newpkg->depends_count;
345 newpkg->depends_count = 0;
347 oldpkg->depends = newpkg->depends;
348 newpkg->depends = NULL;
350 oldpkg->pre_depends_str = newpkg->pre_depends_str;
351 newpkg->pre_depends_str = NULL;
352 oldpkg->pre_depends_count = newpkg->pre_depends_count;
353 newpkg->pre_depends_count = 0;
355 oldpkg->recommends_str = newpkg->recommends_str;
356 newpkg->recommends_str = NULL;
357 oldpkg->recommends_count = newpkg->recommends_count;
358 newpkg->recommends_count = 0;
360 oldpkg->suggests_str = newpkg->suggests_str;
361 newpkg->suggests_str = NULL;
362 oldpkg->suggests_count = newpkg->suggests_count;
363 newpkg->suggests_count = 0;
366 if (!oldpkg->provides_str) {
367 oldpkg->provides_str = newpkg->provides_str;
368 newpkg->provides_str = NULL;
369 oldpkg->provides_count = newpkg->provides_count;
370 newpkg->provides_count = 0;
372 oldpkg->provides = newpkg->provides;
373 newpkg->provides = NULL;
376 if (!oldpkg->conflicts_str) {
377 oldpkg->conflicts_str = newpkg->conflicts_str;
378 newpkg->conflicts_str = NULL;
379 oldpkg->conflicts_count = newpkg->conflicts_count;
380 newpkg->conflicts_count = 0;
382 oldpkg->conflicts = newpkg->conflicts;
383 newpkg->conflicts = NULL;
386 if (!oldpkg->replaces_str) {
387 oldpkg->replaces_str = newpkg->replaces_str;
388 newpkg->replaces_str = NULL;
389 oldpkg->replaces_count = newpkg->replaces_count;
390 newpkg->replaces_count = 0;
392 oldpkg->replaces = newpkg->replaces;
393 newpkg->replaces = NULL;
396 if (!oldpkg->filename)
397 oldpkg->filename = str_dup_safe(newpkg->filename);
399 fprintf(stdout, "pkg=%s old local_filename=%s new local_filename=%s\n",
400 oldpkg->name, oldpkg->local_filename, newpkg->local_filename);
401 if (!oldpkg->local_filename)
402 oldpkg->local_filename = str_dup_safe(newpkg->local_filename);
403 if (!oldpkg->tmp_unpack_dir)
404 oldpkg->tmp_unpack_dir = str_dup_safe(newpkg->tmp_unpack_dir);
406 oldpkg->md5sum = str_dup_safe(newpkg->md5sum);
408 oldpkg->size = str_dup_safe(newpkg->size);
409 if (!oldpkg->installed_size)
410 oldpkg->installed_size = str_dup_safe(newpkg->installed_size);
411 if (!oldpkg->priority)
412 oldpkg->priority = str_dup_safe(newpkg->priority);
414 oldpkg->source = str_dup_safe(newpkg->source);
415 if (nv_pair_list_empty(&oldpkg->conffiles)){
416 list_splice_init(&newpkg->conffiles.head, &oldpkg->conffiles.head);
417 conffile_list_init(&newpkg->conffiles);
419 if (!oldpkg->installed_files){
420 oldpkg->installed_files = newpkg->installed_files;
421 oldpkg->installed_files_ref_cnt = newpkg->installed_files_ref_cnt;
422 newpkg->installed_files = NULL;
424 if (!oldpkg->essential)
425 oldpkg->essential = newpkg->essential;
430 abstract_pkg_t *abstract_pkg_new(void)
432 abstract_pkg_t * ab_pkg;
434 ab_pkg = calloc(1, sizeof(abstract_pkg_t));
436 if (ab_pkg == NULL) {
437 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
441 if ( abstract_pkg_init(ab_pkg) < 0 )
447 int abstract_pkg_init(abstract_pkg_t *ab_pkg)
449 ab_pkg->provided_by = abstract_pkg_vec_alloc();
450 if (ab_pkg->provided_by==NULL){
453 ab_pkg->dependencies_checked = 0;
454 ab_pkg->state_status = SS_NOT_INSTALLED;
459 void set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){
462 char **raw_start=NULL;
464 temp_str = (char *) calloc (1, strlen(pkg->dest->info_dir)+strlen(pkg->name)+12);
465 if (temp_str == NULL ){
466 opkg_message(conf, OPKG_INFO, "Out of memory in %s\n", __FUNCTION__);
469 sprintf( temp_str,"%s/%s.control",pkg->dest->info_dir,pkg->name);
471 raw = raw_start = read_raw_pkgs_from_file(temp_str);
473 opkg_message(conf, OPKG_ERROR, "Unable to open the control file in %s\n", __FUNCTION__);
478 if (!pkg_valorize_other_field(pkg, &raw ) == 0) {
479 opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name);
495 char * pkg_formatted_info(pkg_t *pkg )
500 buff = calloc(1, 8192);
502 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
508 line = pkg_formatted_field(pkg, "Package");
509 strncat(buff ,line, strlen(line));
512 line = pkg_formatted_field(pkg, "Version");
513 strncat(buff ,line, strlen(line));
516 line = pkg_formatted_field(pkg, "Depends");
517 strncat(buff ,line, strlen(line));
520 line = pkg_formatted_field(pkg, "Recommends");
521 strncat(buff ,line, strlen(line));
524 line = pkg_formatted_field(pkg, "Suggests");
525 strncat(buff ,line, strlen(line));
528 line = pkg_formatted_field(pkg, "Provides");
529 strncat(buff ,line, strlen(line));
532 line = pkg_formatted_field(pkg, "Replaces");
533 strncat(buff ,line, strlen(line));
536 line = pkg_formatted_field(pkg, "Conflicts");
537 strncat(buff ,line, strlen(line));
540 line = pkg_formatted_field(pkg, "Status");
541 strncat(buff ,line, strlen(line));
544 line = pkg_formatted_field(pkg, "Section");
545 strncat(buff ,line, strlen(line));
548 line = pkg_formatted_field(pkg, "Essential"); /* @@@@ should be removed in future release. *//* I do not agree with this Pigi*/
549 strncat(buff ,line, strlen(line));
552 line = pkg_formatted_field(pkg, "Architecture");
553 strncat(buff ,line, strlen(line));
556 line = pkg_formatted_field(pkg, "Maintainer");
557 strncat(buff ,line, strlen(line));
560 line = pkg_formatted_field(pkg, "MD5sum");
561 strncat(buff ,line, strlen(line));
564 line = pkg_formatted_field(pkg, "Size");
565 strncat(buff ,line, strlen(line));
568 line = pkg_formatted_field(pkg, "Filename");
569 strncat(buff ,line, strlen(line));
572 line = pkg_formatted_field(pkg, "Conffiles");
573 strncat(buff ,line, strlen(line));
576 line = pkg_formatted_field(pkg, "Source");
577 strncat(buff ,line, strlen(line));
580 line = pkg_formatted_field(pkg, "Description");
581 strncat(buff ,line, strlen(line));
584 line = pkg_formatted_field(pkg, "Installed-Time");
585 strncat(buff ,line, strlen(line));
588 line = pkg_formatted_field(pkg, "Tags");
589 strncat(buff ,line, strlen(line));
595 char * pkg_formatted_field(pkg_t *pkg, const char *field )
597 static size_t LINE_LEN = 128;
598 char * temp = (char *)malloc(1);
600 int flag_provide_false = 0;
603 Pigi: After some discussion with Florian we decided to modify the full procedure in
604 dynamic memory allocation. This should avoid any other segv in this area ( except for bugs )
607 if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
608 goto UNKNOWN_FMT_FIELD;
617 if (strcasecmp(field, "Architecture") == 0) {
619 if (pkg->architecture) {
620 temp = (char *)realloc(temp,strlen(pkg->architecture)+17);
622 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
626 snprintf(temp, (strlen(pkg->architecture)+17), "Architecture: %s\n", pkg->architecture);
628 } else if (strcasecmp(field, "Auto-Installed") == 0) {
629 /* Auto-Installed flag */
630 if (pkg->auto_installed) {
631 char * s = "Auto-Installed: yes\n";
632 temp = (char *)realloc(temp, strlen(s) + 1);
636 goto UNKNOWN_FMT_FIELD;
641 if (strcasecmp(field, "Conffiles") == 0) {
643 conffile_list_elt_t *iter;
644 char confstr[LINE_LEN];
646 if (nv_pair_list_empty(&pkg->conffiles)) {
651 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
652 if (((conffile_t *)iter->data)->name && ((conffile_t *)iter->data)->value) {
653 len = len + (strlen(((conffile_t *)iter->data)->name)+strlen(((conffile_t *)iter->data)->value)+5);
656 temp = (char *)realloc(temp,len);
658 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
662 strncpy(temp, "Conffiles:\n", 12);
663 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
664 if (((conffile_t *)iter->data)->name && ((conffile_t *)iter->data)->value) {
665 snprintf(confstr, LINE_LEN, "%s %s\n",
666 ((conffile_t *)iter->data)->name,
667 ((conffile_t *)iter->data)->value);
668 strncat(temp, confstr, strlen(confstr));
671 } else if (strcasecmp(field, "Conflicts") == 0) {
674 if (pkg->conflicts_count) {
675 char conflictstr[LINE_LEN];
677 for(i = 0; i < pkg->conflicts_count; i++) {
678 len = len + (strlen(pkg->conflicts_str[i])+5);
680 temp = (char *)realloc(temp,len);
682 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
686 strncpy(temp, "Conflicts:", 11);
687 for(i = 0; i < pkg->conflicts_count; i++) {
688 snprintf(conflictstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->conflicts_str[i]);
689 strncat(temp, conflictstr, strlen(conflictstr));
691 strncat(temp, "\n", strlen("\n"));
694 goto UNKNOWN_FMT_FIELD;
699 if (strcasecmp(field, "Depends") == 0) {
703 if (pkg->depends_count) {
704 char depstr[LINE_LEN];
706 for(i = 0; i < pkg->depends_count; i++) {
707 len = len + (strlen(pkg->depends_str[i])+4);
709 temp = (char *)realloc(temp,len);
711 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
715 strncpy(temp, "Depends:", 10);
716 for(i = 0; i < pkg->depends_count; i++) {
717 snprintf(depstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->depends_str[i]);
718 strncat(temp, depstr, strlen(depstr));
720 strncat(temp, "\n", strlen("\n"));
722 } else if (strcasecmp(field, "Description") == 0) {
724 if (pkg->description) {
725 temp = (char *)realloc(temp,strlen(pkg->description)+16);
727 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
731 snprintf(temp, (strlen(pkg->description)+16), "Description: %s\n", pkg->description);
734 goto UNKNOWN_FMT_FIELD;
740 if (pkg->essential) {
741 temp = (char *)realloc(temp,16);
743 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
747 snprintf(temp, (16), "Essential: yes\n");
755 temp = (char *)realloc(temp,strlen(pkg->filename)+12);
757 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
761 snprintf(temp, (strlen(pkg->filename)+12), "Filename: %s\n", pkg->filename);
767 if (strcasecmp(field, "Installed-Size") == 0) {
769 temp = (char *)realloc(temp,strlen(pkg->installed_size)+17);
771 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
775 snprintf(temp, (strlen(pkg->installed_size)+17), "Installed-Size: %s\n", pkg->installed_size);
776 } else if (strcasecmp(field, "Installed-Time") == 0 && pkg->installed_time) {
777 temp = (char *)realloc(temp,29);
779 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
783 snprintf(temp, 29, "Installed-Time: %lu\n", pkg->installed_time);
789 /* Maintainer | MD5sum */
790 if (strcasecmp(field, "Maintainer") == 0) {
792 if (pkg->maintainer) {
793 temp = (char *)realloc(temp,strlen(pkg->maintainer)+14);
795 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
799 snprintf(temp, (strlen(pkg->maintainer)+14), "maintainer: %s\n", pkg->maintainer);
801 } else if (strcasecmp(field, "MD5sum") == 0) {
804 temp = (char *)realloc(temp,strlen(pkg->md5sum)+11);
806 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
810 snprintf(temp, (strlen(pkg->md5sum)+11), "MD5Sum: %s\n", pkg->md5sum);
813 goto UNKNOWN_FMT_FIELD;
819 if (strcasecmp(field, "Package") == 0) {
821 temp = (char *)realloc(temp,strlen(pkg->name)+11);
823 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
827 snprintf(temp, (strlen(pkg->name)+11), "Package: %s\n", pkg->name);
828 } else if (strcasecmp(field, "Priority") == 0) {
830 temp = (char *)realloc(temp,strlen(pkg->priority)+12);
832 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
836 snprintf(temp, (strlen(pkg->priority)+12), "Priority: %s\n", pkg->priority);
837 } else if (strcasecmp(field, "Provides") == 0) {
841 if (pkg->provides_count) {
842 /* Here we check if the opkg_internal_use_only is used, and we discard it.*/
843 for ( i=0; i < pkg->provides_count; i++ ){
844 if (strstr(pkg->provides_str[i],"opkg_internal_use_only")!=NULL) {
845 memset (pkg->provides_str[i],'\x0',strlen(pkg->provides_str[i])); /* Pigi clear my trick flag, just in case */
846 flag_provide_false = 1;
849 if ( !flag_provide_false || /* Pigi there is not my trick flag */
850 ((flag_provide_false) && (pkg->provides_count > 1))){ /* Pigi There is, but we also have others Provides */
851 char provstr[LINE_LEN];
853 for(i = 0; i < pkg->provides_count; i++) {
854 len = len + (strlen(pkg->provides_str[i])+5);
856 temp = (char *)realloc(temp,len);
858 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
862 strncpy(temp, "Provides:", 12);
863 for(i = 0; i < pkg->provides_count; i++) {
864 if (strlen(pkg->provides_str[i])>0){;
865 snprintf(provstr, LINE_LEN, "%s %s", i == 1 ? "" : ",", pkg->provides_str[i]);
866 strncat(temp, provstr, strlen(provstr));
869 strncat(temp, "\n", strlen("\n"));
873 goto UNKNOWN_FMT_FIELD;
880 /* Replaces | Recommends*/
881 if (strcasecmp (field, "Replaces") == 0) {
882 if (pkg->replaces_count) {
883 char replstr[LINE_LEN];
885 for (i = 0; i < pkg->replaces_count; i++) {
886 len = len + (strlen(pkg->replaces_str[i])+5);
888 temp = (char *)realloc(temp,len);
890 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
894 strncpy(temp, "Replaces:", 12);
895 for (i = 0; i < pkg->replaces_count; i++) {
896 snprintf(replstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->replaces_str[i]);
897 strncat(temp, replstr, strlen(replstr));
899 strncat(temp, "\n", strlen("\n"));
901 } else if (strcasecmp (field, "Recommends") == 0) {
902 if (pkg->recommends_count) {
903 char recstr[LINE_LEN];
905 for(i = 0; i < pkg->recommends_count; i++) {
906 len = len + (strlen( pkg->recommends_str[i])+5);
908 temp = (char *)realloc(temp,len);
910 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
914 strncpy(temp, "Recommends:", 13);
915 for(i = 0; i < pkg->recommends_count; i++) {
916 snprintf(recstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->recommends_str[i]);
917 strncat(temp, recstr, strlen(recstr));
919 strncat(temp, "\n", strlen("\n"));
922 goto UNKNOWN_FMT_FIELD;
928 /* Section | Size | Source | Status | Suggests */
929 if (strcasecmp(field, "Section") == 0) {
932 temp = (char *)realloc(temp,strlen(pkg->section)+11);
934 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
938 snprintf(temp, (strlen(pkg->section)+11), "Section: %s\n", pkg->section);
940 } else if (strcasecmp(field, "Size") == 0) {
943 temp = (char *)realloc(temp,strlen(pkg->size)+8);
945 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
949 snprintf(temp, (strlen(pkg->size)+8), "Size: %s\n", pkg->size);
951 } else if (strcasecmp(field, "Source") == 0) {
954 temp = (char *)realloc(temp,strlen(pkg->source)+10);
956 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
960 snprintf(temp, (strlen(pkg->source)+10), "Source: %s\n", pkg->source);
962 } else if (strcasecmp(field, "Status") == 0) {
964 /* Benjamin Pineau note: we should avoid direct usage of
965 * strlen(arg) without keeping "arg" for later free()
967 char *pflag=pkg_state_flag_to_str(pkg->state_flag);
968 char *pstat=pkg_state_status_to_str(pkg->state_status);
969 char *pwant=pkg_state_want_to_str(pkg->state_want);
971 size_t sum_of_sizes = (size_t) ( strlen(pwant)+ strlen(pflag)+ strlen(pstat) + 12 );
972 temp = (char *)realloc(temp,sum_of_sizes);
974 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
978 snprintf(temp, sum_of_sizes , "Status: %s %s %s\n", pwant, pflag, pstat);
981 if(pstat) /* pfstat can be NULL if ENOMEM */
983 } else if (strcasecmp(field, "Suggests") == 0) {
984 if (pkg->suggests_count) {
986 char sugstr[LINE_LEN];
988 for(i = 0; i < pkg->suggests_count; i++) {
989 len = len + (strlen(pkg->suggests_str[i])+5);
991 temp = (char *)realloc(temp,len);
993 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
997 strncpy(temp, "Suggests:", 10);
998 for(i = 0; i < pkg->suggests_count; i++) {
999 snprintf(sugstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->suggests_str[i]);
1000 strncat(temp, sugstr, strlen(sugstr));
1002 strncat(temp, "\n", strlen("\n"));
1005 goto UNKNOWN_FMT_FIELD;
1011 if (strcasecmp(field, "Tags") == 0) {
1014 temp = (char *)realloc(temp,strlen(pkg->tags)+8);
1015 if ( temp == NULL ){
1016 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
1020 snprintf(temp, (strlen(pkg->tags)+8), "Tags: %s\n", pkg->tags);
1027 char *version = pkg_version_str_alloc(pkg);
1028 temp = (char *)realloc(temp,strlen(version)+14);
1029 if ( temp == NULL ){
1030 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
1034 snprintf(temp, (strlen(version)+12), "Version: %s\n", version);
1039 goto UNKNOWN_FMT_FIELD;
1042 if ( strlen(temp)<2 ) {
1048 fprintf(stderr, "%s: ERROR: Unknown field name: %s\n", __FUNCTION__, field);
1049 if ( strlen(temp)<2 ) {
1056 void pkg_print_info(pkg_t *pkg, FILE *file)
1064 buff = pkg_formatted_info(pkg);
1067 if (strlen(buff)>2){
1068 t = fwrite(buff, 1, strlen(buff), file); //#~rzr:TODO
1073 void pkg_print_status(pkg_t * pkg, FILE * file)
1079 /* XXX: QUESTION: Do we actually want more fields here? The
1080 original idea was to save space by installing only what was
1081 needed for actual computation, (package, version, status,
1082 essential, conffiles). The assumption is that all other fields
1083 can be found in th available file.
1085 But, someone proposed the idea to make it possible to
1086 reconstruct a .opk from an installed package, (ie. for beaming
1087 from one handheld to another). So, maybe we actually want a few
1088 more fields here, (depends, suggests, etc.), so that that would
1089 be guaranteed to work even in the absence of more information
1090 from the available file.
1092 28-MAR-03: kergoth and I discussed this yesterday. We think
1093 the essential info needs to be here for all installed packages
1094 because they may not appear in the Packages files on various
1095 feeds. Furthermore, one should be able to install from URL or
1096 local storage without requiring a Packages file from any feed.
1099 pkg_print_field(pkg, file, "Package");
1100 pkg_print_field(pkg, file, "Version");
1101 pkg_print_field(pkg, file, "Depends");
1102 pkg_print_field(pkg, file, "Recommends");
1103 pkg_print_field(pkg, file, "Suggests");
1104 pkg_print_field(pkg, file, "Provides");
1105 pkg_print_field(pkg, file, "Replaces");
1106 pkg_print_field(pkg, file, "Conflicts");
1107 pkg_print_field(pkg, file, "Status");
1108 pkg_print_field(pkg, file, "Essential"); /* @@@@ should be removed in future release. */
1109 pkg_print_field(pkg, file, "Architecture");
1110 pkg_print_field(pkg, file, "Conffiles");
1111 pkg_print_field(pkg, file, "Installed-Time");
1112 pkg_print_field(pkg, file, "Auto-Installed");
1116 void pkg_print_field(pkg_t *pkg, FILE *file, const char *field)
1119 if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
1120 fprintf(stderr, "%s: ERROR: Unknown field name: %s\n",
1121 __FUNCTION__, field);
1123 buff = pkg_formatted_field(pkg, field);
1124 if (strlen(buff)>2) {
1125 fprintf(file, "%s", buff);
1133 * libdpkg - Debian packaging suite library routines
1134 * vercmp.c - comparison of version numbers
1136 * Copyright (C) 1995 Ian Jackson <iwj10@cus.cam.ac.uk>
1138 int pkg_compare_versions(const pkg_t *pkg, const pkg_t *ref_pkg)
1142 if (pkg->epoch > ref_pkg->epoch) {
1146 if (pkg->epoch < ref_pkg->epoch) {
1150 r = verrevcmp(pkg->version, ref_pkg->version);
1155 r = verrevcmp(pkg->revision, ref_pkg->revision);
1163 /* assume ascii; warning: evaluates x multiple times! */
1164 #define order(x) ((x) == '~' ? -1 \
1165 : isdigit((x)) ? 0 \
1167 : isalpha((x)) ? (x) \
1170 static int verrevcmp(const char *val, const char *ref) {
1174 while (*val || *ref) {
1177 while ( (*val && !isdigit(*val)) || (*ref && !isdigit(*ref)) ) {
1178 int vc= order(*val), rc= order(*ref);
1179 if (vc != rc) return vc - rc;
1183 while ( *val == '0' ) val++;
1184 while ( *ref == '0' ) ref++;
1185 while (isdigit(*val) && isdigit(*ref)) {
1186 if (!first_diff) first_diff= *val - *ref;
1189 if (isdigit(*val)) return 1;
1190 if (isdigit(*ref)) return -1;
1191 if (first_diff) return first_diff;
1196 int pkg_version_satisfied(pkg_t *it, pkg_t *ref, const char *op)
1200 r = pkg_compare_versions(it, ref);
1202 if (strcmp(op, "<=") == 0 || strcmp(op, "<") == 0) {
1206 if (strcmp(op, ">=") == 0 || strcmp(op, ">") == 0) {
1210 if (strcmp(op, "<<") == 0) {
1214 if (strcmp(op, ">>") == 0) {
1218 if (strcmp(op, "=") == 0) {
1222 fprintf(stderr, "unknown operator: %s", op);
1226 int pkg_name_version_and_architecture_compare(const void *p1, const void *p2)
1228 const pkg_t *a = *(const pkg_t**) p1;
1229 const pkg_t *b = *(const pkg_t**) p2;
1232 if (!a->name || !b->name) {
1233 fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->name=%p b=%p b->name=%p\n",
1234 a, a->name, b, b->name);
1238 namecmp = strcmp(a->name, b->name);
1241 vercmp = pkg_compare_versions(a, b);
1244 if (!a->arch_priority || !b->arch_priority) {
1245 fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->arch_priority=%i b=%p b->arch_priority=%i\n",
1246 a, a->arch_priority, b, b->arch_priority);
1249 if (a->arch_priority > b->arch_priority)
1251 if (a->arch_priority < b->arch_priority)
1256 int abstract_pkg_name_compare(const void *p1, const void *p2)
1258 const abstract_pkg_t *a = *(const abstract_pkg_t **)p1;
1259 const abstract_pkg_t *b = *(const abstract_pkg_t **)p2;
1260 if (!a->name || !b->name) {
1261 fprintf(stderr, "abstract_pkg_name_compare: a=%p a->name=%p b=%p b->name=%p\n",
1262 a, a->name, b, b->name);
1265 return strcmp(a->name, b->name);
1269 char *pkg_version_str_alloc(pkg_t *pkg)
1271 char *complete_version;
1276 sprintf_alloc(&epoch_str, "%d:", pkg->epoch);
1278 epoch_str = strdup("");
1281 if (pkg->revision && strlen(pkg->revision)) {
1282 sprintf_alloc(&revision_str, "-%s", pkg->revision);
1284 revision_str = strdup("");
1288 sprintf_alloc(&complete_version, "%s%s%s",
1289 epoch_str, pkg->version, revision_str);
1294 return complete_version;
1297 str_list_t *pkg_get_installed_files(pkg_t *pkg)
1300 char *list_file_name = NULL;
1301 FILE *list_file = NULL;
1303 char *installed_file_name;
1306 pkg->installed_files_ref_cnt++;
1308 if (pkg->installed_files) {
1309 return pkg->installed_files;
1312 pkg->installed_files = str_list_alloc();
1313 if (pkg->installed_files == NULL) {
1314 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
1318 /* For uninstalled packages, get the file list directly from the package.
1319 For installed packages, look at the package.list file in the database.
1321 if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) {
1322 if (pkg->local_filename == NULL) {
1323 return pkg->installed_files;
1325 /* XXX: CLEANUP: Maybe rewrite this to avoid using a temporary
1326 file. In other words, change deb_extract so that it can
1327 simply return the file list as a char *[] rather than
1328 insisting on writing in to a FILE * as it does now. */
1329 list_file = tmpfile();
1330 err = pkg_extract_data_file_names_to_stream(pkg, list_file);
1333 fprintf(stderr, "%s: Error extracting file list from %s: %s\n",
1334 __FUNCTION__, pkg->local_filename, strerror(err));
1335 return pkg->installed_files;
1339 sprintf_alloc(&list_file_name, "%s/%s.list",
1340 pkg->dest->info_dir, pkg->name);
1341 if (! file_exists(list_file_name)) {
1342 free(list_file_name);
1343 return pkg->installed_files;
1346 list_file = fopen(list_file_name, "r");
1347 if (list_file == NULL) {
1348 fprintf(stderr, "WARNING: Cannot open %s: %s\n",
1349 list_file_name, strerror(errno));
1350 free(list_file_name);
1351 return pkg->installed_files;
1353 free(list_file_name);
1356 rootdirlen = strlen( pkg->dest->root_dir );
1360 line = file_read_line_alloc(list_file);
1367 /* Take pains to avoid uglies like "/./" in the middle of file_name. */
1368 if( strncmp( pkg->dest->root_dir,
1371 if (*file_name == '.') {
1374 if (*file_name == '/') {
1378 /* Freed in pkg_free_installed_files */
1379 sprintf_alloc(&installed_file_name, "%s%s", pkg->dest->root_dir, file_name);
1381 // already contains root_dir as header -> ABSOLUTE
1382 sprintf_alloc(&installed_file_name, "%s", file_name);
1384 str_list_append(pkg->installed_files, installed_file_name);
1390 return pkg->installed_files;
1393 /* XXX: CLEANUP: This function and it's counterpart,
1394 (pkg_get_installed_files), do not match our init/deinit naming
1395 convention. Nor the alloc/free convention. But, then again, neither
1396 of these conventions currrently fit the way these two functions
1398 int pkg_free_installed_files(pkg_t *pkg)
1400 pkg->installed_files_ref_cnt--;
1402 if (pkg->installed_files_ref_cnt > 0)
1405 if (pkg->installed_files) {
1406 str_list_deinit(pkg->installed_files);
1409 pkg->installed_files = NULL;
1414 int pkg_remove_installed_files_list(opkg_conf_t *conf, pkg_t *pkg)
1417 char *list_file_name;
1419 //I don't think pkg_free_installed_files should be called here. Jamey
1420 //pkg_free_installed_files(pkg);
1422 sprintf_alloc(&list_file_name, "%s/%s.list",
1423 pkg->dest->info_dir, pkg->name);
1424 if (!conf->noaction) {
1425 err = unlink(list_file_name);
1426 free(list_file_name);
1435 conffile_t *pkg_get_conffile(pkg_t *pkg, const char *file_name)
1437 conffile_list_elt_t *iter;
1438 conffile_t *conffile;
1444 for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
1445 conffile = (conffile_t *)iter->data;
1447 if (strcmp(conffile->name, file_name) == 0) {
1455 int pkg_run_script(opkg_conf_t *conf, pkg_t *pkg,
1456 const char *script, const char *args)
1462 /* XXX: FEATURE: When conf->offline_root is set, we should run the
1463 maintainer script within a chroot environment. */
1465 /* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages
1466 have scripts in pkg->tmp_unpack_dir. */
1467 if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) {
1468 if (pkg->dest == NULL) {
1469 fprintf(stderr, "%s: ERROR: installed package %s has a NULL dest\n",
1470 __FUNCTION__, pkg->name);
1473 sprintf_alloc(&path, "%s/%s.%s", pkg->dest->info_dir, pkg->name, script);
1475 if (pkg->tmp_unpack_dir == NULL) {
1476 fprintf(stderr, "%s: ERROR: uninstalled package %s has a NULL tmp_unpack_dir\n",
1477 __FUNCTION__, pkg->name);
1480 sprintf_alloc(&path, "%s/%s", pkg->tmp_unpack_dir, script);
1483 opkg_message(conf, OPKG_INFO, "Running script %s\n", path);
1484 if (conf->noaction) return 0;
1486 /* XXX: CLEANUP: There must be a better way to handle maintainer
1487 scripts when running with offline_root mode and/or a dest other
1488 than '/'. I've been playing around with some clever chroot
1489 tricks and I might come up with something workable. */
1491 * Attempt to provide a restricted environment for offline operation
1492 * Need the following set as a minimum:
1493 * OPKG_OFFLINE_ROOT = absolute path to root dir
1494 * D = absolute path to root dir (for OE generated postinst)
1495 * PATH = something safe (a restricted set of utilities)
1498 bool AllowOfflineMode = false;
1499 if (conf->offline_root) {
1500 setenv("OPKG_OFFLINE_ROOT", conf->offline_root, 1);
1501 setenv("D", conf->offline_root, 1);
1502 if (NULL == conf->offline_root_path || '\0' == conf->offline_root_path[0]) {
1503 setenv("PATH", "/dev/null", 1);
1505 setenv("PATH", conf->offline_root_path, 1);
1506 AllowOfflineMode = true;
1511 pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir, 1);
1513 if (! file_exists(path)) {
1518 if (conf->offline_root && !AllowOfflineMode) {
1519 fprintf(stderr, "(offline root mode: not running %s.%s)\n", pkg->name, script);
1524 sprintf_alloc(&cmd, "%s %s", path, args);
1531 fprintf(stderr, "%s script returned status %d\n", script, err);
1538 char *pkg_state_want_to_str(pkg_state_want_t sw)
1542 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1543 if (pkg_state_want_map[i].value == sw) {
1544 return strdup(pkg_state_want_map[i].str);
1548 fprintf(stderr, "%s: ERROR: Illegal value for state_want: %d\n",
1550 return strdup("<STATE_WANT_UNKNOWN>");
1553 pkg_state_want_t pkg_state_want_from_str(char *str)
1557 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1558 if (strcmp(str, pkg_state_want_map[i].str) == 0) {
1559 return pkg_state_want_map[i].value;
1563 fprintf(stderr, "%s: ERROR: Illegal value for state_want string: %s\n",
1568 char *pkg_state_flag_to_str(pkg_state_flag_t sf)
1571 int len = 3; /* ok\000 is minimum */
1574 /* clear the temporary flags before converting to string */
1575 sf &= SF_NONVOLATILE_FLAGS;
1578 return strdup("ok");
1581 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1582 if (sf & pkg_state_flag_map[i].value) {
1583 len += strlen(pkg_state_flag_map[i].str) + 1;
1587 if ( str == NULL ) {
1588 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
1592 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1593 if (sf & pkg_state_flag_map[i].value) {
1594 strcat(str, pkg_state_flag_map[i].str);
1599 str[len-1] = 0; /* squash last comma */
1604 pkg_state_flag_t pkg_state_flag_from_str(const char *str)
1609 if (strcmp(str, "ok") == 0) {
1612 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1613 const char *sfname = pkg_state_flag_map[i].str;
1614 int sfname_len = strlen(sfname);
1615 if (strncmp(str, sfname, sfname_len) == 0) {
1616 sf |= pkg_state_flag_map[i].value;
1618 if (str[0] == ',') {
1629 char *pkg_state_status_to_str(pkg_state_status_t ss)
1633 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1634 if (pkg_state_status_map[i].value == ss) {
1635 return strdup(pkg_state_status_map[i].str);
1639 fprintf(stderr, "%s: ERROR: Illegal value for state_status: %d\n",
1641 return strdup("<STATE_STATUS_UNKNOWN>");
1644 pkg_state_status_t pkg_state_status_from_str(const char *str)
1648 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1649 if (strcmp(str, pkg_state_status_map[i].str) == 0) {
1650 return pkg_state_status_map[i].value;
1654 fprintf(stderr, "%s: ERROR: Illegal value for state_status string: %s\n",
1656 return SS_NOT_INSTALLED;
1659 int pkg_arch_supported(opkg_conf_t *conf, pkg_t *pkg)
1661 nv_pair_list_elt_t *l;
1663 if (!pkg->architecture)
1666 list_for_each_entry(l , &conf->arch_list.head, node) {
1667 nv_pair_t *nv = (nv_pair_t *)l->data;
1668 if (strcmp(nv->name, pkg->architecture) == 0) {
1669 opkg_message(conf, OPKG_DEBUG, "arch %s (priority %s) supported for pkg %s\n", nv->name, nv->value, pkg->name);
1674 opkg_message(conf, OPKG_DEBUG, "arch %s unsupported for pkg %s\n", pkg->architecture, pkg->name);
1678 int pkg_get_arch_priority(opkg_conf_t *conf, const char *archname)
1680 nv_pair_list_elt_t *l;
1682 list_for_each_entry(l , &conf->arch_list.head, node) {
1683 nv_pair_t *nv = (nv_pair_t *)l->data;
1684 if (strcmp(nv->name, archname) == 0) {
1685 int priority = strtol(nv->value, NULL, 0);
1692 int pkg_info_preinstall_check(opkg_conf_t *conf)
1695 hash_table_t *pkg_hash = &conf->pkg_hash;
1696 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1697 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1699 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: updating arch priority for each package\n");
1700 pkg_hash_fetch_available(pkg_hash, available_pkgs);
1701 /* update arch_priority for each package */
1702 for (i = 0; i < available_pkgs->len; i++) {
1703 pkg_t *pkg = available_pkgs->pkgs[i];
1704 int arch_priority = 1;
1707 // opkg_message(conf, OPKG_DEBUG2, " package %s version=%s arch=%p:", pkg->name, pkg->version, pkg->architecture);
1708 if (pkg->architecture)
1709 arch_priority = pkg_get_arch_priority(conf, pkg->architecture);
1711 opkg_message(conf, OPKG_ERROR, "pkg_info_preinstall_check: no architecture for package %s\n", pkg->name);
1712 // opkg_message(conf, OPKG_DEBUG2, "%s arch_priority=%d\n", pkg->architecture, arch_priority);
1713 pkg->arch_priority = arch_priority;
1716 for (i = 0; i < available_pkgs->len; i++) {
1717 pkg_t *pkg = available_pkgs->pkgs[i];
1718 if (!pkg->arch_priority && (pkg->state_flag || (pkg->state_want != SW_UNKNOWN))) {
1719 /* clear flags and want for any uninstallable package */
1720 opkg_message(conf, OPKG_DEBUG, "Clearing state_want and state_flag for pkg=%s (arch_priority=%d flag=%d want=%d)\n",
1721 pkg->name, pkg->arch_priority, pkg->state_flag, pkg->state_want);
1722 pkg->state_want = SW_UNKNOWN;
1723 pkg->state_flag = 0;
1726 pkg_vec_free(available_pkgs);
1728 /* update the file owner data structure */
1729 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: update file owner list\n");
1730 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1731 for (i = 0; i < installed_pkgs->len; i++) {
1732 pkg_t *pkg = installed_pkgs->pkgs[i];
1733 str_list_t *installed_files = pkg_get_installed_files(pkg); /* this causes installed_files to be cached */
1734 str_list_elt_t *iter;
1735 if (installed_files == NULL) {
1736 opkg_message(conf, OPKG_ERROR, "No installed files for pkg %s\n", pkg->name);
1739 for (iter = str_list_first(installed_files); iter; iter = str_list_next(installed_files, iter)) {
1740 char *installed_file = (char *) iter->data;
1741 // opkg_message(conf, OPKG_DEBUG2, "pkg %s: file=%s\n", pkg->name, installed_file);
1742 file_hash_set_file_owner(conf, installed_file, pkg);
1744 pkg_free_installed_files(pkg);
1746 pkg_vec_free(installed_pkgs);
1751 struct pkg_write_filelist_data {
1757 void pkg_write_filelist_helper(const char *key, void *entry_, void *data_)
1759 struct pkg_write_filelist_data *data = data_;
1760 pkg_t *entry = entry_;
1761 if (entry == data->pkg) {
1762 fprintf(data->stream, "%s\n", key);
1766 int pkg_write_filelist(opkg_conf_t *conf, pkg_t *pkg)
1768 struct pkg_write_filelist_data data;
1769 char *list_file_name = NULL;
1773 opkg_message(conf, OPKG_ERROR, "Null pkg\n");
1776 opkg_message(conf, OPKG_INFO,
1777 " creating %s.list file\n", pkg->name);
1778 sprintf_alloc(&list_file_name, "%s/%s.list", pkg->dest->info_dir, pkg->name);
1779 if (!list_file_name) {
1780 opkg_message(conf, OPKG_ERROR, "Failed to alloc list_file_name\n");
1783 opkg_message(conf, OPKG_INFO,
1784 " creating %s file for pkg %s\n", list_file_name, pkg->name);
1785 data.stream = fopen(list_file_name, "w");
1787 opkg_message(conf, OPKG_ERROR, "Could not open %s for writing: %s\n",
1788 list_file_name, strerror(errno));
1793 hash_table_foreach(&conf->file_hash, pkg_write_filelist_helper, &data);
1794 fclose(data.stream);
1795 free(list_file_name);
1797 pkg->state_flag &= ~SF_FILELIST_CHANGED;
1802 int pkg_write_changed_filelists(opkg_conf_t *conf)
1804 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1805 hash_table_t *pkg_hash = &conf->pkg_hash;
1811 opkg_message(conf, OPKG_INFO, "%s: saving changed filelists\n", __FUNCTION__);
1812 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1813 for (i = 0; i < installed_pkgs->len; i++) {
1814 pkg_t *pkg = installed_pkgs->pkgs[i];
1815 if (pkg->state_flag & SF_FILELIST_CHANGED) {
1816 opkg_message(conf, OPKG_DEBUG, "Calling pkg_write_filelist for pkg=%s from %s\n", pkg->name, __FUNCTION__);
1817 err = pkg_write_filelist(conf, pkg);
1819 opkg_message(conf, OPKG_NOTICE, "pkg_write_filelist pkg=%s returned %d\n", pkg->name, err);
1822 pkg_vec_free (installed_pkgs);