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);
116 active_list_init(&pkg->searched_node);
118 /* Abhaya: added init for conflicts fields */
119 pkg->conflicts = NULL;
120 pkg->conflicts_count = 0;
122 /* added for replaces. Jamey 7/23/2002 */
123 pkg->replaces = NULL;
124 pkg->replaces_count = 0;
126 pkg->pre_depends_count = 0;
127 pkg->pre_depends_str = NULL;
128 pkg->provides_count = 0;
129 pkg->provides = NULL;
130 pkg->filename = NULL;
131 pkg->local_filename = NULL;
132 pkg->tmp_unpack_dir = NULL;
135 pkg->installed_size = NULL;
136 pkg->priority = NULL;
138 conffile_list_init(&pkg->conffiles);
139 pkg->installed_files = NULL;
140 pkg->installed_files_ref_cnt = 0;
142 pkg->provided_by_hand = 0;
147 void compound_depend_deinit (compound_depend_t *depends)
150 for (i = 0; i < depends->possibility_count; i++)
153 d = depends->possibilities[i];
157 free (depends->possibilities);
160 void pkg_deinit(pkg_t *pkg)
169 /* revision shares storage with version, so
171 pkg->revision = NULL;
172 /* owned by opkg_conf_t */
174 /* owned by opkg_conf_t */
176 free(pkg->architecture);
177 pkg->architecture = NULL;
178 free(pkg->maintainer);
179 pkg->maintainer = NULL;
182 free(pkg->description);
183 pkg->description = NULL;
184 pkg->state_want = SW_UNKNOWN;
185 pkg->state_flag = SF_OK;
186 pkg->state_status = SS_NOT_INSTALLED;
188 active_list_clear(&pkg->list);
190 free (pkg->replaces);
191 pkg->replaces = NULL;
193 for (i = 0; i < pkg->depends_count; i++)
194 free (pkg->depends_str[i]);
195 free(pkg->depends_str);
196 pkg->depends_str = NULL;
198 for (i = 0; i < pkg->provides_count; i++)
199 free (pkg->provides_str[i]);
200 free(pkg->provides_str);
201 pkg->provides_str = NULL;
203 for (i = 0; i < pkg->conflicts_count; i++)
204 free (pkg->conflicts_str[i]);
205 free(pkg->conflicts_str);
206 pkg->conflicts_str = NULL;
208 for (i = 0; i < pkg->replaces_count; i++)
209 free (pkg->replaces_str[i]);
210 free(pkg->replaces_str);
211 pkg->replaces_str = NULL;
213 for (i = 0; i < pkg->recommends_count; i++)
214 free (pkg->recommends_str[i]);
215 free(pkg->recommends_str);
216 pkg->recommends_str = NULL;
218 for (i = 0; i < pkg->suggests_count; i++)
219 free (pkg->suggests_str[i]);
220 free(pkg->suggests_str);
221 pkg->suggests_str = NULL;
225 int count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
228 for (x = 0; x < count; x++)
229 compound_depend_deinit (&pkg->depends[x]);
236 for (x = 0; x < pkg->conflicts_count; x++)
237 compound_depend_deinit (&pkg->conflicts[x]);
238 free (pkg->conflicts);
241 free (pkg->provides);
243 pkg->pre_depends_count = 0;
244 free(pkg->pre_depends_str);
245 pkg->pre_depends_str = NULL;
246 pkg->provides_count = 0;
248 pkg->filename = NULL;
249 free(pkg->local_filename);
250 pkg->local_filename = NULL;
251 /* CLEANUP: It'd be nice to pullin the cleanup function from
252 opkg_install.c here. See comment in
253 opkg_install.c:cleanup_temporary_files */
254 free(pkg->tmp_unpack_dir);
255 pkg->tmp_unpack_dir = NULL;
260 free(pkg->installed_size);
261 pkg->installed_size = NULL;
263 pkg->priority = NULL;
266 conffile_list_deinit(&pkg->conffiles);
267 /* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
268 since if they are calling deinit, they should know. Maybe do an
269 assertion here instead? */
270 pkg->installed_files_ref_cnt = 1;
271 pkg_free_installed_files(pkg);
277 int pkg_init_from_file(pkg_t *pkg, const char *filename)
284 if (err) { return err; }
286 pkg->local_filename = strdup(filename);
288 control_file = tmpfile();
289 err = pkg_extract_control_file_to_stream(pkg, control_file);
290 if (err) { return err; }
292 rewind(control_file);
293 raw = read_raw_pkgs_from_stream(control_file);
294 pkg_parse_raw(pkg, &raw, NULL, NULL);
296 fclose(control_file);
301 /* Merge any new information in newpkg into oldpkg */
302 /* XXX: CLEANUP: This function shouldn't actually modify anything in
303 newpkg, but should leave it usable. This rework is so that
304 pkg_hash_insert doesn't clobber the pkg that you pass into it. */
306 * uh, i thought that i had originally written this so that it took
307 * two pkgs and returned a new one? we can do that again... -sma
309 int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
311 if (oldpkg == newpkg) {
316 oldpkg->src = newpkg->src;
318 oldpkg->dest = newpkg->dest;
319 if (!oldpkg->architecture)
320 oldpkg->architecture = str_dup_safe(newpkg->architecture);
321 if (!oldpkg->arch_priority)
322 oldpkg->arch_priority = newpkg->arch_priority;
323 if (!oldpkg->section)
324 oldpkg->section = str_dup_safe(newpkg->section);
325 if(!oldpkg->maintainer)
326 oldpkg->maintainer = str_dup_safe(newpkg->maintainer);
327 if(!oldpkg->description)
328 oldpkg->description = str_dup_safe(newpkg->description);
330 /* merge the state_flags from the new package */
331 oldpkg->state_want = newpkg->state_want;
332 oldpkg->state_status = newpkg->state_status;
333 oldpkg->state_flag = newpkg->state_flag;
335 if (oldpkg->state_want == SW_UNKNOWN)
336 oldpkg->state_want = newpkg->state_want;
337 if (oldpkg->state_status == SS_NOT_INSTALLED)
338 oldpkg->state_status = newpkg->state_status;
339 oldpkg->state_flag |= newpkg->state_flag;
342 if (!oldpkg->depends_str && !oldpkg->pre_depends_str && !oldpkg->recommends_str && !oldpkg->suggests_str) {
343 oldpkg->depends_str = newpkg->depends_str;
344 newpkg->depends_str = NULL;
345 oldpkg->depends_count = newpkg->depends_count;
346 newpkg->depends_count = 0;
348 oldpkg->depends = newpkg->depends;
349 newpkg->depends = NULL;
351 oldpkg->pre_depends_str = newpkg->pre_depends_str;
352 newpkg->pre_depends_str = NULL;
353 oldpkg->pre_depends_count = newpkg->pre_depends_count;
354 newpkg->pre_depends_count = 0;
356 oldpkg->recommends_str = newpkg->recommends_str;
357 newpkg->recommends_str = NULL;
358 oldpkg->recommends_count = newpkg->recommends_count;
359 newpkg->recommends_count = 0;
361 oldpkg->suggests_str = newpkg->suggests_str;
362 newpkg->suggests_str = NULL;
363 oldpkg->suggests_count = newpkg->suggests_count;
364 newpkg->suggests_count = 0;
367 if (!oldpkg->provides_str) {
368 oldpkg->provides_str = newpkg->provides_str;
369 newpkg->provides_str = NULL;
370 oldpkg->provides_count = newpkg->provides_count;
371 newpkg->provides_count = 0;
373 oldpkg->provides = newpkg->provides;
374 newpkg->provides = NULL;
377 if (!oldpkg->conflicts_str) {
378 oldpkg->conflicts_str = newpkg->conflicts_str;
379 newpkg->conflicts_str = NULL;
380 oldpkg->conflicts_count = newpkg->conflicts_count;
381 newpkg->conflicts_count = 0;
383 oldpkg->conflicts = newpkg->conflicts;
384 newpkg->conflicts = NULL;
387 if (!oldpkg->replaces_str) {
388 oldpkg->replaces_str = newpkg->replaces_str;
389 newpkg->replaces_str = NULL;
390 oldpkg->replaces_count = newpkg->replaces_count;
391 newpkg->replaces_count = 0;
393 oldpkg->replaces = newpkg->replaces;
394 newpkg->replaces = NULL;
397 if (!oldpkg->filename)
398 oldpkg->filename = str_dup_safe(newpkg->filename);
400 fprintf(stdout, "pkg=%s old local_filename=%s new local_filename=%s\n",
401 oldpkg->name, oldpkg->local_filename, newpkg->local_filename);
402 if (!oldpkg->local_filename)
403 oldpkg->local_filename = str_dup_safe(newpkg->local_filename);
404 if (!oldpkg->tmp_unpack_dir)
405 oldpkg->tmp_unpack_dir = str_dup_safe(newpkg->tmp_unpack_dir);
407 oldpkg->md5sum = str_dup_safe(newpkg->md5sum);
409 oldpkg->size = str_dup_safe(newpkg->size);
410 if (!oldpkg->installed_size)
411 oldpkg->installed_size = str_dup_safe(newpkg->installed_size);
412 if (!oldpkg->priority)
413 oldpkg->priority = str_dup_safe(newpkg->priority);
415 oldpkg->source = str_dup_safe(newpkg->source);
416 if (oldpkg->conffiles.head == NULL){
417 oldpkg->conffiles = newpkg->conffiles;
418 conffile_list_init(&newpkg->conffiles);
420 if (!oldpkg->installed_files){
421 oldpkg->installed_files = newpkg->installed_files;
422 oldpkg->installed_files_ref_cnt = newpkg->installed_files_ref_cnt;
423 newpkg->installed_files = NULL;
425 if (!oldpkg->essential)
426 oldpkg->essential = newpkg->essential;
431 abstract_pkg_t *abstract_pkg_new(void)
433 abstract_pkg_t * ab_pkg;
435 ab_pkg = calloc(1, sizeof(abstract_pkg_t));
437 if (ab_pkg == NULL) {
438 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
442 if ( abstract_pkg_init(ab_pkg) < 0 )
448 int abstract_pkg_init(abstract_pkg_t *ab_pkg)
450 ab_pkg->provided_by = abstract_pkg_vec_alloc();
451 if (ab_pkg->provided_by==NULL){
454 ab_pkg->dependencies_checked = 0;
455 ab_pkg->state_status = SS_NOT_INSTALLED;
456 active_list_init(&ab_pkg->searched_node);
461 void set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){
464 char **raw_start=NULL;
466 temp_str = (char *) calloc (1, strlen(pkg->dest->info_dir)+strlen(pkg->name)+12);
467 if (temp_str == NULL ){
468 opkg_message(conf, OPKG_INFO, "Out of memory in %s\n", __FUNCTION__);
471 sprintf( temp_str,"%s/%s.control",pkg->dest->info_dir,pkg->name);
473 raw = raw_start = read_raw_pkgs_from_file(temp_str);
475 opkg_message(conf, OPKG_ERROR, "Unable to open the control file in %s\n", __FUNCTION__);
480 if (!pkg_valorize_other_field(pkg, &raw ) == 0) {
481 opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name);
497 char * pkg_formatted_info(pkg_t *pkg )
502 buff = calloc(1, 8192);
504 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
510 line = pkg_formatted_field(pkg, "Package");
511 strncat(buff ,line, strlen(line));
514 line = pkg_formatted_field(pkg, "Version");
515 strncat(buff ,line, strlen(line));
518 line = pkg_formatted_field(pkg, "Depends");
519 strncat(buff ,line, strlen(line));
522 line = pkg_formatted_field(pkg, "Recommends");
523 strncat(buff ,line, strlen(line));
526 line = pkg_formatted_field(pkg, "Suggests");
527 strncat(buff ,line, strlen(line));
530 line = pkg_formatted_field(pkg, "Provides");
531 strncat(buff ,line, strlen(line));
534 line = pkg_formatted_field(pkg, "Replaces");
535 strncat(buff ,line, strlen(line));
538 line = pkg_formatted_field(pkg, "Conflicts");
539 strncat(buff ,line, strlen(line));
542 line = pkg_formatted_field(pkg, "Status");
543 strncat(buff ,line, strlen(line));
546 line = pkg_formatted_field(pkg, "Section");
547 strncat(buff ,line, strlen(line));
550 line = pkg_formatted_field(pkg, "Essential"); /* @@@@ should be removed in future release. *//* I do not agree with this Pigi*/
551 strncat(buff ,line, strlen(line));
554 line = pkg_formatted_field(pkg, "Architecture");
555 strncat(buff ,line, strlen(line));
558 line = pkg_formatted_field(pkg, "Maintainer");
559 strncat(buff ,line, strlen(line));
562 line = pkg_formatted_field(pkg, "MD5sum");
563 strncat(buff ,line, strlen(line));
566 line = pkg_formatted_field(pkg, "Size");
567 strncat(buff ,line, strlen(line));
570 line = pkg_formatted_field(pkg, "Filename");
571 strncat(buff ,line, strlen(line));
574 line = pkg_formatted_field(pkg, "Conffiles");
575 strncat(buff ,line, strlen(line));
578 line = pkg_formatted_field(pkg, "Source");
579 strncat(buff ,line, strlen(line));
582 line = pkg_formatted_field(pkg, "Description");
583 strncat(buff ,line, strlen(line));
586 line = pkg_formatted_field(pkg, "Installed-Time");
587 strncat(buff ,line, strlen(line));
590 line = pkg_formatted_field(pkg, "Tags");
591 strncat(buff ,line, strlen(line));
597 char * pkg_formatted_field(pkg_t *pkg, const char *field )
599 static size_t LINE_LEN = 128;
600 char * temp = (char *)malloc(1);
602 int flag_provide_false = 0;
605 Pigi: After some discussion with Florian we decided to modify the full procedure in
606 dynamic memory allocation. This should avoid any other segv in this area ( except for bugs )
609 if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
610 goto UNKNOWN_FMT_FIELD;
619 if (strcasecmp(field, "Architecture") == 0) {
621 if (pkg->architecture) {
622 temp = (char *)realloc(temp,strlen(pkg->architecture)+17);
624 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
628 snprintf(temp, (strlen(pkg->architecture)+17), "Architecture: %s\n", pkg->architecture);
630 } else if (strcasecmp(field, "Auto-Installed") == 0) {
631 /* Auto-Installed flag */
632 if (pkg->auto_installed) {
633 char * s = "Auto-Installed: yes\n";
634 temp = (char *)realloc(temp, strlen(s) + 1);
638 goto UNKNOWN_FMT_FIELD;
643 if (strcasecmp(field, "Conffiles") == 0) {
645 conffile_list_elt_t *iter;
646 char confstr[LINE_LEN];
648 if (pkg->conffiles.head == NULL) {
653 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
654 if (iter->data->name && iter->data->value) {
655 len = len + (strlen(iter->data->name)+strlen(iter->data->value)+5);
658 temp = (char *)realloc(temp,len);
660 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
664 strncpy(temp, "Conffiles:\n", 12);
665 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
666 if (iter->data->name && iter->data->value) {
667 snprintf(confstr, LINE_LEN, "%s %s\n", iter->data->name, 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 str_list_elt_t *iter;
1402 pkg->installed_files_ref_cnt--;
1404 if (pkg->installed_files_ref_cnt > 0)
1407 if (pkg->installed_files) {
1409 for (iter = pkg->installed_files->head; iter; iter = iter->next) {
1410 /* malloced in pkg_get_installed_files */
1415 str_list_deinit(pkg->installed_files);
1416 free (pkg->installed_files);
1419 pkg->installed_files = NULL;
1424 int pkg_remove_installed_files_list(opkg_conf_t *conf, pkg_t *pkg)
1427 char *list_file_name;
1429 //I don't think pkg_free_installed_files should be called here. Jamey
1430 //pkg_free_installed_files(pkg);
1432 sprintf_alloc(&list_file_name, "%s/%s.list",
1433 pkg->dest->info_dir, pkg->name);
1434 if (!conf->noaction) {
1435 err = unlink(list_file_name);
1436 free(list_file_name);
1445 conffile_t *pkg_get_conffile(pkg_t *pkg, const char *file_name)
1447 conffile_list_elt_t *iter;
1448 conffile_t *conffile;
1454 for (iter = pkg->conffiles.head; iter; iter = iter->next) {
1455 conffile = iter->data;
1457 if (strcmp(conffile->name, file_name) == 0) {
1465 int pkg_run_script(opkg_conf_t *conf, pkg_t *pkg,
1466 const char *script, const char *args)
1472 /* XXX: FEATURE: When conf->offline_root is set, we should run the
1473 maintainer script within a chroot environment. */
1475 /* Installed packages have scripts in pkg->dest->info_dir, uninstalled packages
1476 have scripts in pkg->tmp_unpack_dir. */
1477 if (pkg->state_status == SS_INSTALLED || pkg->state_status == SS_UNPACKED) {
1478 if (pkg->dest == NULL) {
1479 fprintf(stderr, "%s: ERROR: installed package %s has a NULL dest\n",
1480 __FUNCTION__, pkg->name);
1483 sprintf_alloc(&path, "%s/%s.%s", pkg->dest->info_dir, pkg->name, script);
1485 if (pkg->tmp_unpack_dir == NULL) {
1486 fprintf(stderr, "%s: ERROR: uninstalled package %s has a NULL tmp_unpack_dir\n",
1487 __FUNCTION__, pkg->name);
1490 sprintf_alloc(&path, "%s/%s", pkg->tmp_unpack_dir, script);
1493 opkg_message(conf, OPKG_INFO, "Running script %s\n", path);
1494 if (conf->noaction) return 0;
1496 /* XXX: CLEANUP: There must be a better way to handle maintainer
1497 scripts when running with offline_root mode and/or a dest other
1498 than '/'. I've been playing around with some clever chroot
1499 tricks and I might come up with something workable. */
1501 * Attempt to provide a restricted environment for offline operation
1502 * Need the following set as a minimum:
1503 * OPKG_OFFLINE_ROOT = absolute path to root dir
1504 * D = absolute path to root dir (for OE generated postinst)
1505 * PATH = something safe (a restricted set of utilities)
1508 bool AllowOfflineMode = false;
1509 if (conf->offline_root) {
1510 setenv("OPKG_OFFLINE_ROOT", conf->offline_root, 1);
1511 setenv("D", conf->offline_root, 1);
1512 if (NULL == conf->offline_root_path || '\0' == conf->offline_root_path[0]) {
1513 setenv("PATH", "/dev/null", 1);
1515 setenv("PATH", conf->offline_root_path, 1);
1516 AllowOfflineMode = true;
1521 pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir, 1);
1523 if (! file_exists(path)) {
1528 if (conf->offline_root && !AllowOfflineMode) {
1529 fprintf(stderr, "(offline root mode: not running %s.%s)\n", pkg->name, script);
1534 sprintf_alloc(&cmd, "%s %s", path, args);
1541 fprintf(stderr, "%s script returned status %d\n", script, err);
1548 char *pkg_state_want_to_str(pkg_state_want_t sw)
1552 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1553 if (pkg_state_want_map[i].value == sw) {
1554 return strdup(pkg_state_want_map[i].str);
1558 fprintf(stderr, "%s: ERROR: Illegal value for state_want: %d\n",
1560 return strdup("<STATE_WANT_UNKNOWN>");
1563 pkg_state_want_t pkg_state_want_from_str(char *str)
1567 for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
1568 if (strcmp(str, pkg_state_want_map[i].str) == 0) {
1569 return pkg_state_want_map[i].value;
1573 fprintf(stderr, "%s: ERROR: Illegal value for state_want string: %s\n",
1578 char *pkg_state_flag_to_str(pkg_state_flag_t sf)
1581 int len = 3; /* ok\000 is minimum */
1584 /* clear the temporary flags before converting to string */
1585 sf &= SF_NONVOLATILE_FLAGS;
1588 return strdup("ok");
1591 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1592 if (sf & pkg_state_flag_map[i].value) {
1593 len += strlen(pkg_state_flag_map[i].str) + 1;
1597 if ( str == NULL ) {
1598 fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
1602 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1603 if (sf & pkg_state_flag_map[i].value) {
1604 strcat(str, pkg_state_flag_map[i].str);
1609 str[len-1] = 0; /* squash last comma */
1614 pkg_state_flag_t pkg_state_flag_from_str(const char *str)
1619 if (strcmp(str, "ok") == 0) {
1622 for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
1623 const char *sfname = pkg_state_flag_map[i].str;
1624 int sfname_len = strlen(sfname);
1625 if (strncmp(str, sfname, sfname_len) == 0) {
1626 sf |= pkg_state_flag_map[i].value;
1628 if (str[0] == ',') {
1639 char *pkg_state_status_to_str(pkg_state_status_t ss)
1643 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1644 if (pkg_state_status_map[i].value == ss) {
1645 return strdup(pkg_state_status_map[i].str);
1649 fprintf(stderr, "%s: ERROR: Illegal value for state_status: %d\n",
1651 return strdup("<STATE_STATUS_UNKNOWN>");
1654 pkg_state_status_t pkg_state_status_from_str(const char *str)
1658 for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
1659 if (strcmp(str, pkg_state_status_map[i].str) == 0) {
1660 return pkg_state_status_map[i].value;
1664 fprintf(stderr, "%s: ERROR: Illegal value for state_status string: %s\n",
1666 return SS_NOT_INSTALLED;
1669 int pkg_arch_supported(opkg_conf_t *conf, pkg_t *pkg)
1671 nv_pair_list_elt_t *l;
1673 if (!pkg->architecture)
1676 l = conf->arch_list.head;
1679 nv_pair_t *nv = l->data;
1680 if (strcmp(nv->name, pkg->architecture) == 0) {
1681 opkg_message(conf, OPKG_DEBUG, "arch %s (priority %s) supported for pkg %s\n", nv->name, nv->value, pkg->name);
1687 opkg_message(conf, OPKG_DEBUG, "arch %s unsupported for pkg %s\n", pkg->architecture, pkg->name);
1691 int pkg_get_arch_priority(opkg_conf_t *conf, const char *archname)
1693 nv_pair_list_elt_t *l;
1695 l = conf->arch_list.head;
1698 nv_pair_t *nv = l->data;
1699 if (strcmp(nv->name, archname) == 0) {
1700 int priority = strtol(nv->value, NULL, 0);
1708 int pkg_info_preinstall_check(opkg_conf_t *conf)
1711 hash_table_t *pkg_hash = &conf->pkg_hash;
1712 pkg_vec_t *available_pkgs = pkg_vec_alloc();
1713 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1715 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: updating arch priority for each package\n");
1716 pkg_hash_fetch_available(pkg_hash, available_pkgs);
1717 /* update arch_priority for each package */
1718 for (i = 0; i < available_pkgs->len; i++) {
1719 pkg_t *pkg = available_pkgs->pkgs[i];
1720 int arch_priority = 1;
1723 // opkg_message(conf, OPKG_DEBUG2, " package %s version=%s arch=%p:", pkg->name, pkg->version, pkg->architecture);
1724 if (pkg->architecture)
1725 arch_priority = pkg_get_arch_priority(conf, pkg->architecture);
1727 opkg_message(conf, OPKG_ERROR, "pkg_info_preinstall_check: no architecture for package %s\n", pkg->name);
1728 // opkg_message(conf, OPKG_DEBUG2, "%s arch_priority=%d\n", pkg->architecture, arch_priority);
1729 pkg->arch_priority = arch_priority;
1732 for (i = 0; i < available_pkgs->len; i++) {
1733 pkg_t *pkg = available_pkgs->pkgs[i];
1734 if (!pkg->arch_priority && (pkg->state_flag || (pkg->state_want != SW_UNKNOWN))) {
1735 /* clear flags and want for any uninstallable package */
1736 opkg_message(conf, OPKG_DEBUG, "Clearing state_want and state_flag for pkg=%s (arch_priority=%d flag=%d want=%d)\n",
1737 pkg->name, pkg->arch_priority, pkg->state_flag, pkg->state_want);
1738 pkg->state_want = SW_UNKNOWN;
1739 pkg->state_flag = 0;
1742 pkg_vec_free(available_pkgs);
1744 /* update the file owner data structure */
1745 opkg_message(conf, OPKG_INFO, "pkg_info_preinstall_check: update file owner list\n");
1746 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1747 for (i = 0; i < installed_pkgs->len; i++) {
1748 pkg_t *pkg = installed_pkgs->pkgs[i];
1749 str_list_t *installed_files = pkg_get_installed_files(pkg); /* this causes installed_files to be cached */
1750 str_list_elt_t *iter;
1751 if (installed_files == NULL) {
1752 opkg_message(conf, OPKG_ERROR, "No installed files for pkg %s\n", pkg->name);
1755 for (iter = installed_files->head; iter; iter = iter->next) {
1756 char *installed_file = iter->data;
1757 // opkg_message(conf, OPKG_DEBUG2, "pkg %s: file=%s\n", pkg->name, installed_file);
1758 file_hash_set_file_owner(conf, installed_file, pkg);
1760 pkg_free_installed_files(pkg);
1762 pkg_vec_free(installed_pkgs);
1767 struct pkg_write_filelist_data {
1773 void pkg_write_filelist_helper(const char *key, void *entry_, void *data_)
1775 struct pkg_write_filelist_data *data = data_;
1776 pkg_t *entry = entry_;
1777 if (entry == data->pkg) {
1778 fprintf(data->stream, "%s\n", key);
1782 int pkg_write_filelist(opkg_conf_t *conf, pkg_t *pkg)
1784 struct pkg_write_filelist_data data;
1785 char *list_file_name = NULL;
1789 opkg_message(conf, OPKG_ERROR, "Null pkg\n");
1792 opkg_message(conf, OPKG_INFO,
1793 " creating %s.list file\n", pkg->name);
1794 sprintf_alloc(&list_file_name, "%s/%s.list", pkg->dest->info_dir, pkg->name);
1795 if (!list_file_name) {
1796 opkg_message(conf, OPKG_ERROR, "Failed to alloc list_file_name\n");
1799 opkg_message(conf, OPKG_INFO,
1800 " creating %s file for pkg %s\n", list_file_name, pkg->name);
1801 data.stream = fopen(list_file_name, "w");
1803 opkg_message(conf, OPKG_ERROR, "Could not open %s for writing: %s\n",
1804 list_file_name, strerror(errno));
1809 hash_table_foreach(&conf->file_hash, pkg_write_filelist_helper, &data);
1810 fclose(data.stream);
1811 free(list_file_name);
1813 pkg->state_flag &= ~SF_FILELIST_CHANGED;
1818 int pkg_write_changed_filelists(opkg_conf_t *conf)
1820 pkg_vec_t *installed_pkgs = pkg_vec_alloc();
1821 hash_table_t *pkg_hash = &conf->pkg_hash;
1827 opkg_message(conf, OPKG_INFO, "%s: saving changed filelists\n", __FUNCTION__);
1828 pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
1829 for (i = 0; i < installed_pkgs->len; i++) {
1830 pkg_t *pkg = installed_pkgs->pkgs[i];
1831 if (pkg->state_flag & SF_FILELIST_CHANGED) {
1832 opkg_message(conf, OPKG_DEBUG, "Calling pkg_write_filelist for pkg=%s from %s\n", pkg->name, __FUNCTION__);
1833 err = pkg_write_filelist(conf, pkg);
1835 opkg_message(conf, OPKG_NOTICE, "pkg_write_filelist pkg=%s returned %d\n", pkg->name, err);
1838 pkg_vec_free (installed_pkgs);