X-Git-Url: https://git.librecmc.org/?p=oweals%2Fopkg-lede.git;a=blobdiff_plain;f=libopkg%2Fpkg.c;h=b01db61d98148a161d861795dc6c359699bfc470;hp=6e0f3968f700a309601e8445b9c1a7cb11c9d2fc;hb=b25d96944364269c61835d7a80a9165f0ee95667;hpb=3d39889a7b2689be560a92b4d0bf1e086e6605b2

diff --git a/libopkg/pkg.c b/libopkg/pkg.c
index 6e0f396..b01db61 100644
--- a/libopkg/pkg.c
+++ b/libopkg/pkg.c
@@ -29,6 +29,7 @@
 #include "opkg_message.h"
 #include "opkg_utils.h"
 
+#include "libbb/libbb.h"
 #include "sprintf_alloc.h"
 #include "file_util.h"
 #include "str_util.h"
@@ -78,12 +79,7 @@ pkg_t *pkg_new(void)
 {
      pkg_t *pkg;
 
-     pkg = calloc(1, sizeof(pkg_t));
-     if (pkg == NULL) {
-	  fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	  return NULL;
-     }
-
+     pkg = xcalloc(1, sizeof(pkg_t));
      pkg_init(pkg);
 
      return pkg;
@@ -131,6 +127,9 @@ int pkg_init(pkg_t *pkg)
      pkg->local_filename = NULL;
      pkg->tmp_unpack_dir = NULL;
      pkg->md5sum = NULL;
+#if defined HAVE_SHA256
+     pkg->sha256sum = NULL;
+#endif
      pkg->size = NULL;
      pkg->installed_size = NULL;
      pkg->priority = NULL;
@@ -159,143 +158,190 @@ void compound_depend_deinit (compound_depend_t *depends)
 
 void pkg_deinit(pkg_t *pkg)
 {
-     int i;
+	int i;
 
-     free(pkg->name);
-     pkg->name = NULL;
-     pkg->epoch = 0;
-     free(pkg->version);
-     pkg->version = NULL;
-     /* revision shares storage with version, so
-	don't free */
-     pkg->revision = NULL;
-     /* owned by opkg_conf_t */
-     pkg->dest = NULL;
-     /* owned by opkg_conf_t */
-     pkg->src = NULL;
-     free(pkg->architecture);
-     pkg->architecture = NULL;
-     free(pkg->maintainer);
-     pkg->maintainer = NULL;
-     free(pkg->section);
-     pkg->section = NULL;
-     free(pkg->description);
-     pkg->description = NULL;
-     pkg->state_want = SW_UNKNOWN;
-     pkg->state_flag = SF_OK;
-     pkg->state_status = SS_NOT_INSTALLED;
+	if (pkg->name)
+		free(pkg->name);
+	pkg->name = NULL;
 
-     active_list_clear(&pkg->list);
+	pkg->epoch = 0;
 
-     free (pkg->replaces);
-     pkg->replaces = NULL;
-
-     for (i = 0; i < pkg->depends_count; i++)
-       free (pkg->depends_str[i]);
-     free(pkg->depends_str);
-     pkg->depends_str = NULL;
+	if (pkg->version)
+		free(pkg->version);
+	pkg->version = NULL;
+	/* revision shares storage with version, so don't free */
+	pkg->revision = NULL;
 
-     for (i = 0; i < pkg->provides_count; i++)
-       free (pkg->provides_str[i]);
-     free(pkg->provides_str);
-     pkg->provides_str = NULL;
+	/* owned by opkg_conf_t */
+	pkg->dest = NULL;
+	/* owned by opkg_conf_t */
+	pkg->src = NULL;
 
-     for (i = 0; i < pkg->conflicts_count; i++)
-       free (pkg->conflicts_str[i]);
-     free(pkg->conflicts_str);
-     pkg->conflicts_str = NULL;
+	if (pkg->architecture)
+		free(pkg->architecture);
+	pkg->architecture = NULL;
 
-     for (i = 0; i < pkg->replaces_count; i++)
-       free (pkg->replaces_str[i]);
-     free(pkg->replaces_str);
-     pkg->replaces_str = NULL;
+	if (pkg->maintainer)
+		free(pkg->maintainer);
+	pkg->maintainer = NULL;
 
-     for (i = 0; i < pkg->recommends_count; i++)
-       free (pkg->recommends_str[i]);
-     free(pkg->recommends_str);
-     pkg->recommends_str = NULL;
+	if (pkg->section)
+		free(pkg->section);
+	pkg->section = NULL;
 
-     for (i = 0; i < pkg->suggests_count; i++)
-       free (pkg->suggests_str[i]);
-     free(pkg->suggests_str);
-     pkg->suggests_str = NULL;
+	if (pkg->description)
+		free(pkg->description);
+	pkg->description = NULL;
+	
+	pkg->state_want = SW_UNKNOWN;
+	pkg->state_flag = SF_OK;
+	pkg->state_status = SS_NOT_INSTALLED;
+
+	active_list_clear(&pkg->list);
+
+	if (pkg->replaces)
+		free (pkg->replaces);
+	pkg->replaces = NULL;
+
+	for (i = 0; i < pkg->depends_count; i++)
+		free (pkg->depends_str[i]);
+	free(pkg->depends_str);
+	pkg->depends_str = NULL;
+
+	for (i = 0; i < pkg->recommends_count; i++)
+		free (pkg->recommends_str[i]);
+	free(pkg->recommends_str);
+	pkg->recommends_str = NULL;
+
+	for (i = 0; i < pkg->suggests_count; i++)
+		free (pkg->suggests_str[i]);
+	free(pkg->suggests_str);
+	pkg->suggests_str = NULL;
+
+	if (pkg->depends) {
+		int count = pkg->pre_depends_count
+				+ pkg->depends_count
+				+ pkg->recommends_count
+				+ pkg->suggests_count;
+
+		for (i=0; i<count; i++)
+			compound_depend_deinit (&pkg->depends[i]);
+		free (pkg->depends);
+	}
+
+	if (pkg->conflicts) {
+		for (i=0; i<pkg->conflicts_count; i++)
+			compound_depend_deinit (&pkg->conflicts[i]);
+		free (pkg->conflicts);
+	}
+
+	if (pkg->provides)
+		free (pkg->provides);
+
+	pkg->pre_depends_count = 0;
+	if (pkg->pre_depends_str)
+		free(pkg->pre_depends_str);
+	pkg->pre_depends_str = NULL;
+	
+	pkg->provides_count = 0;
+	
+	if (pkg->filename)
+		free(pkg->filename);
+	pkg->filename = NULL;
+	
+	if (pkg->local_filename)
+		free(pkg->local_filename);
+	pkg->local_filename = NULL;
 
-     if (pkg->depends)
-     {
-       int count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count;
-       int x;
+     /* CLEANUP: It'd be nice to pullin the cleanup function from
+	opkg_install.c here. See comment in
+	opkg_install.c:cleanup_temporary_files */
+	if (pkg->tmp_unpack_dir)
+		free(pkg->tmp_unpack_dir);
+	pkg->tmp_unpack_dir = NULL;
 
-       for (x = 0; x < count; x++)
-	 compound_depend_deinit (&pkg->depends[x]);
-       free (pkg->depends);
-     }
+	if (pkg->md5sum)
+		free(pkg->md5sum);
+	pkg->md5sum = NULL;
 
-     if (pkg->conflicts)
-     {
-       int x;
-       for (x = 0; x < pkg->conflicts_count; x++)
-         compound_depend_deinit (&pkg->conflicts[x]);
-       free (pkg->conflicts);
-     }
+#if defined HAVE_SHA256
+	if (pkg->sha256sum)
+		free(pkg->sha256sum);
+	pkg->sha256sum = NULL;
+#endif
 
-     free (pkg->provides);
+	if (pkg->size)
+		free(pkg->size);
+	pkg->size = NULL;
 
-     pkg->pre_depends_count = 0;
-     free(pkg->pre_depends_str);
-     pkg->pre_depends_str = NULL;
-     pkg->provides_count = 0;
-     free(pkg->filename);
-     pkg->filename = NULL;
-     free(pkg->local_filename);
-     pkg->local_filename = NULL;
-     /* CLEANUP: It'd be nice to pullin the cleanup function from
-	opkg_install.c here. See comment in
-	opkg_install.c:cleanup_temporary_files */
-     free(pkg->tmp_unpack_dir);
-     pkg->tmp_unpack_dir = NULL;
-     free(pkg->md5sum);
-     pkg->md5sum = NULL;
-     free(pkg->size);
-     pkg->size = NULL;
-     free(pkg->installed_size);
-     pkg->installed_size = NULL;
-     free(pkg->priority);
-     pkg->priority = NULL;
-     free(pkg->source);
-     pkg->source = NULL;
-     conffile_list_deinit(&pkg->conffiles);
-     /* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
-	since if they are calling deinit, they should know. Maybe do an
-	assertion here instead? */
-     pkg->installed_files_ref_cnt = 1;
-     pkg_free_installed_files(pkg);
-     pkg->essential = 0;
-     free (pkg->tags);
-     pkg->tags = NULL;
-}
+	if (pkg->installed_size)
+		free(pkg->installed_size);
+	pkg->installed_size = NULL;
 
-int pkg_init_from_file(pkg_t *pkg, const char *filename)
-{
-     int err;
-     char **raw;
-     FILE *control_file;
+	if (pkg->priority)
+		free(pkg->priority);
+	pkg->priority = NULL;
 
-     err = pkg_init(pkg);
-     if (err) { return err; }
+	if (pkg->source)
+		free(pkg->source);
+	pkg->source = NULL;
 
-     pkg->local_filename = strdup(filename);
-    
-     control_file = tmpfile();
-     err = pkg_extract_control_file_to_stream(pkg, control_file);
-     if (err) { return err; }
+	conffile_list_deinit(&pkg->conffiles);
 
-     rewind(control_file);
-     raw = read_raw_pkgs_from_stream(control_file);
-     pkg_parse_raw(pkg, &raw, NULL, NULL);
+	/* XXX: QUESTION: Is forcing this to 1 correct? I suppose so,
+	since if they are calling deinit, they should know. Maybe do an
+	assertion here instead? */
+	pkg->installed_files_ref_cnt = 1;
+	pkg_free_installed_files(pkg);
+	pkg->essential = 0;
 
-     fclose(control_file);
+	if (pkg->tags)
+		free (pkg->tags);
+	pkg->tags = NULL;
+}
 
-     return 0;
+int
+pkg_init_from_file(pkg_t *pkg, const char *filename)
+{
+	int fd, err = 0;
+	FILE *control_file;
+	char *control_path;
+
+	pkg_init(pkg);
+
+	pkg->local_filename = xstrdup(filename);
+
+	sprintf_alloc(&control_path, "%s.control.XXXXXX", filename);
+	fd = mkstemp(control_path);
+	if (fd == -1) {
+		perror_msg("%s: mkstemp(%s)", __FUNCTION__, control_path);
+		err = -1;
+		goto err0;
+	}
+
+	control_file = fdopen(fd, "rw+");
+	if (control_file == NULL) {
+		perror_msg("%s: fdopen", __FUNCTION__, control_path);
+		close(fd);
+		err = -1;
+		goto err1;
+	}
+
+	err = pkg_extract_control_file_to_stream(pkg, control_file);
+	if (err)
+		goto err2;
+
+	rewind(control_file);
+	pkg_parse_from_stream(pkg, control_file, PFM_ALL);
+
+err2:
+	fclose(control_file);
+err1:
+	unlink(control_path);
+err0:
+	free(control_path);
+
+	return err;
 }
 
 /* Merge any new information in newpkg into oldpkg */
@@ -312,20 +358,23 @@ int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
 	  return 0;
      }
 
+     if (!oldpkg->auto_installed)
+	  oldpkg->auto_installed = newpkg->auto_installed;
+
      if (!oldpkg->src)
 	  oldpkg->src = newpkg->src;
      if (!oldpkg->dest)
 	  oldpkg->dest = newpkg->dest;
      if (!oldpkg->architecture)
-	  oldpkg->architecture = str_dup_safe(newpkg->architecture);
+	  oldpkg->architecture = xstrdup(newpkg->architecture);
      if (!oldpkg->arch_priority)
 	  oldpkg->arch_priority = newpkg->arch_priority;
      if (!oldpkg->section)
-	  oldpkg->section = str_dup_safe(newpkg->section);
+	  oldpkg->section = xstrdup(newpkg->section);
      if(!oldpkg->maintainer)
-	  oldpkg->maintainer = str_dup_safe(newpkg->maintainer);
+	  oldpkg->maintainer = xstrdup(newpkg->maintainer);
      if(!oldpkg->description)
-	  oldpkg->description = str_dup_safe(newpkg->description);
+	  oldpkg->description = xstrdup(newpkg->description);
      if (set_status) {
 	  /* merge the state_flags from the new package */
 	  oldpkg->state_want = newpkg->state_want;
@@ -364,19 +413,17 @@ int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
 	  newpkg->suggests_count = 0;
      }
 
-     if (!oldpkg->provides_str) {
-	  oldpkg->provides_str = newpkg->provides_str;
-	  newpkg->provides_str = NULL;
+     if (oldpkg->provides_count <= 1) {
 	  oldpkg->provides_count = newpkg->provides_count;
 	  newpkg->provides_count = 0;
 
-	  oldpkg->provides = newpkg->provides;
-	  newpkg->provides = NULL;
+	  if (!oldpkg->provides) {
+		oldpkg->provides = newpkg->provides;
+		newpkg->provides = NULL;
+	  }
      }
 
-     if (!oldpkg->conflicts_str) {
-	  oldpkg->conflicts_str = newpkg->conflicts_str;
-	  newpkg->conflicts_str = NULL;
+     if (!oldpkg->conflicts_count) {
 	  oldpkg->conflicts_count = newpkg->conflicts_count;
 	  newpkg->conflicts_count = 0;
 
@@ -384,9 +431,7 @@ int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
 	  newpkg->conflicts = NULL;
      }
 
-     if (!oldpkg->replaces_str) {
-	  oldpkg->replaces_str = newpkg->replaces_str;
-	  newpkg->replaces_str = NULL;
+     if (!oldpkg->replaces_count) {
 	  oldpkg->replaces_count = newpkg->replaces_count;
 	  newpkg->replaces_count = 0;
 
@@ -395,24 +440,25 @@ int pkg_merge(pkg_t *oldpkg, pkg_t *newpkg, int set_status)
      }
 
      if (!oldpkg->filename)
-	  oldpkg->filename = str_dup_safe(newpkg->filename);
-     if (0)
-     fprintf(stdout, "pkg=%s old local_filename=%s new local_filename=%s\n", 
-	     oldpkg->name, oldpkg->local_filename, newpkg->local_filename);
+	  oldpkg->filename = xstrdup(newpkg->filename);
      if (!oldpkg->local_filename)
-	  oldpkg->local_filename = str_dup_safe(newpkg->local_filename);
+	  oldpkg->local_filename = xstrdup(newpkg->local_filename);
      if (!oldpkg->tmp_unpack_dir)
-	  oldpkg->tmp_unpack_dir = str_dup_safe(newpkg->tmp_unpack_dir);
+	  oldpkg->tmp_unpack_dir = xstrdup(newpkg->tmp_unpack_dir);
      if (!oldpkg->md5sum)
-	  oldpkg->md5sum = str_dup_safe(newpkg->md5sum);
+	  oldpkg->md5sum = xstrdup(newpkg->md5sum);
+#if defined HAVE_SHA256
+     if (!oldpkg->sha256sum)
+	  oldpkg->sha256sum = xstrdup(newpkg->sha256sum);
+#endif
      if (!oldpkg->size)
-	  oldpkg->size = str_dup_safe(newpkg->size);
+	  oldpkg->size = xstrdup(newpkg->size);
      if (!oldpkg->installed_size)
-	  oldpkg->installed_size = str_dup_safe(newpkg->installed_size);
+	  oldpkg->installed_size = xstrdup(newpkg->installed_size);
      if (!oldpkg->priority)
-	  oldpkg->priority = str_dup_safe(newpkg->priority);
+	  oldpkg->priority = xstrdup(newpkg->priority);
      if (!oldpkg->source)
-	  oldpkg->source = str_dup_safe(newpkg->source);
+	  oldpkg->source = xstrdup(newpkg->source);
      if (nv_pair_list_empty(&oldpkg->conffiles)){
 	  list_splice_init(&newpkg->conffiles.head, &oldpkg->conffiles.head);
 	  conffile_list_init(&newpkg->conffiles);
@@ -432,7 +478,7 @@ abstract_pkg_t *abstract_pkg_new(void)
 {
      abstract_pkg_t * ab_pkg;
 
-     ab_pkg = calloc(1, sizeof(abstract_pkg_t));
+     ab_pkg = xcalloc(1, sizeof(abstract_pkg_t));
 
      if (ab_pkg == NULL) {
 	  fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
@@ -458,210 +504,70 @@ int abstract_pkg_init(abstract_pkg_t *ab_pkg)
 }
 
 void set_flags_from_control(opkg_conf_t *conf, pkg_t *pkg){
-     char * temp_str;
-     char **raw =NULL;
-     char **raw_start=NULL; 
+     char *file_name;
+     FILE *fp;
 
-     size_t str_size = strlen(pkg->dest->info_dir)+strlen(pkg->name)+12;
-     temp_str = (char *) alloca (str_size);
-     memset(temp_str, 0 , str_size);
-     
-     if (temp_str == NULL ){
-        opkg_message(conf, OPKG_INFO, "Out of memory in  %s\n", __FUNCTION__);
-        return;
-     }
-     sprintf( temp_str,"%s/%s.control",pkg->dest->info_dir,pkg->name);
-   
-     raw = raw_start = read_raw_pkgs_from_file(temp_str);
-     if (raw == NULL ){
-        opkg_message(conf, OPKG_ERROR, "Unable to open the control file in  %s\n", __FUNCTION__);
-        return;
-     }
+     sprintf_alloc(&file_name,"%s/%s.control", pkg->dest->info_dir, pkg->name);
 
-     while(*raw){
-        if (!pkg_valorize_other_field(pkg, &raw ) == 0) {
-            opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name);
-        }
-     }
-     raw = raw_start;
-     while (*raw) {
-        if (raw!=NULL)
-          free(*raw++);
+     fp = fopen(file_name, "r");
+     if (fp == NULL) {
+	     opkg_message(conf, OPKG_ERROR, "fopen(%s): %s\n",
+			     file_name, strerror(errno));
+	     free(file_name);
+	     return;
      }
 
-     free(raw_start); 
-
-     return ;
-
-}
-
-#define CHECK_BUFF_SIZE(buff, line, buf_size, page_size) do { \
-        if (strlen(buff) + strlen(line) >= (buf_size)) { \
-            buf_size += page_size; \
-            buff = realloc(buff, buf_size); \
-        } \
-    } while(0)
-char * pkg_formatted_info(pkg_t *pkg )
-{
-     char *line;
-     char * buff;
-     const size_t page_size = 8192;
-     size_t buff_size = page_size;
+     free(file_name);
 
-     buff = calloc(1, buff_size);
-     if (buff == NULL) {
-	  fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	  return NULL;
+     if (pkg_parse_from_stream(pkg, fp, PFM_ESSENTIAL)) {
+        opkg_message(conf, OPKG_DEBUG, "unable to read control file for %s. May be empty\n", pkg->name);
      }
 
-     line = pkg_formatted_field(pkg, "Package");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Version");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
+     fclose(fp);
 
-     line = pkg_formatted_field(pkg, "Depends");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-     
-     line = pkg_formatted_field(pkg, "Recommends");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Suggests");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Provides");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Replaces");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Conflicts");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Status");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Section");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Essential"); /* @@@@ should be removed in future release. *//* I do not agree with this Pigi*/
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Architecture");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Maintainer");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "MD5sum");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Size");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Filename");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Conffiles");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Source");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Description");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Installed-Time");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     line = pkg_formatted_field(pkg, "Tags");
-     CHECK_BUFF_SIZE(buff, line, buff_size, page_size);
-     strncat(buff ,line, strlen(line));
-     free(line);
-
-     return buff;
+     return;
 }
 
-char * pkg_formatted_field(pkg_t *pkg, const char *field )
+const char*
+constraint_to_str(enum version_constraint c)
 {
-     static size_t LINE_LEN = 128;
-     char * temp = (char *)malloc(1);
-     int len = 0;
-     int flag_provide_false = 0;
+	switch (c) {
+	case NONE:
+		return "";
+	case EARLIER:
+		return "< ";
+	case EARLIER_EQUAL:
+	       return "<= ";
+	case EQUAL:
+	       return "= ";
+	case LATER_EQUAL:
+	      return ">= ";
+	case LATER:
+	     return "> ";
+	}
+
+	return "";
+}
 
-/*
-  Pigi: After some discussion with Florian we decided to modify the full procedure in 
-        dynamic memory allocation. This should avoid any other segv in this area ( except for bugs )
-*/
+void pkg_formatted_field(FILE *fp, pkg_t *pkg, const char *field)
+{
+     int i;
 
      if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
 	  goto UNKNOWN_FMT_FIELD;
      }
 
-     temp[0]='\0'; 
-
      switch (field[0])
      {
      case 'a':
      case 'A':
 	  if (strcasecmp(field, "Architecture") == 0) {
-	       /* Architecture */
 	       if (pkg->architecture) {
-                   temp = (char *)realloc(temp,strlen(pkg->architecture)+17);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->architecture)+17), "Architecture: %s\n", pkg->architecture);
+                   fprintf(fp, "Architecture: %s\n", pkg->architecture);
 	       }
 	  } else if (strcasecmp(field, "Auto-Installed") == 0) {
-		/* Auto-Installed flag */
-		if (pkg->auto_installed) {
-		    char * s = "Auto-Installed: yes\n";
-		    temp = (char *)realloc(temp, strlen(s) + 1);
-		    strcpy (temp, s);
-		}
+		if (pkg->auto_installed)
+		    fprintf(fp, "Auto-Installed: yes\n");
 	  } else {
 	       goto UNKNOWN_FMT_FIELD;
 	  }
@@ -669,56 +575,34 @@ char * pkg_formatted_field(pkg_t *pkg, const char *field )
      case 'c':
      case 'C':
 	  if (strcasecmp(field, "Conffiles") == 0) {
-	       /* Conffiles */
 	       conffile_list_elt_t *iter;
-               char confstr[LINE_LEN];
 
-	       if (nv_pair_list_empty(&pkg->conffiles)) {
-		    return temp;
-	       }
+	       if (nv_pair_list_empty(&pkg->conffiles))
+		    return;
 
-               len = 14 ;
+               fprintf(fp, "Conffiles:\n");
 	       for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
 		    if (((conffile_t *)iter->data)->name && ((conffile_t *)iter->data)->value) {
-                       len = len + (strlen(((conffile_t *)iter->data)->name)+strlen(((conffile_t *)iter->data)->value)+5);
-		    }
-	       }
-               temp = (char *)realloc(temp,len);
-               if ( temp == NULL ){
-	          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	          return NULL;
-               }
-               temp[0]='\0';
-               strncpy(temp, "Conffiles:\n", 12);
-	       for (iter = nv_pair_list_first(&pkg->conffiles); iter; iter = nv_pair_list_next(&pkg->conffiles, iter)) {
-		    if (((conffile_t *)iter->data)->name && ((conffile_t *)iter->data)->value) {
-                         snprintf(confstr, LINE_LEN, "%s %s\n", 
+                         fprintf(fp, " %s %s\n", 
                                  ((conffile_t *)iter->data)->name, 
                                  ((conffile_t *)iter->data)->value);
-                         strncat(temp, confstr, strlen(confstr));           
 		    }
 	       }
 	  } else if (strcasecmp(field, "Conflicts") == 0) {
-	       int i;
-
+	       struct depend *cdep;
 	       if (pkg->conflicts_count) {
-                    char conflictstr[LINE_LEN];
-                    len = 14 ;
+                    fprintf(fp, "Conflicts:");
 		    for(i = 0; i < pkg->conflicts_count; i++) {
-                        len = len + (strlen(pkg->conflicts_str[i])+5);
+			cdep = pkg->conflicts[i].possibilities[0];
+                        fprintf(fp, "%s %s", i == 0 ? "" : ",",
+				cdep->pkg->name);
+			if (cdep->version) {
+				fprintf(fp, "(%s%s)",
+					constraint_to_str(cdep->constraint),
+					cdep->version);
+			}
                     }
-                    temp = (char *)realloc(temp,len);
-                    if ( temp == NULL ){
-	               fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	               return NULL;
-                    }
-                    temp[0]='\0';
-                    strncpy(temp, "Conflicts:", 11);
-		    for(i = 0; i < pkg->conflicts_count; i++) {
-                        snprintf(conflictstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->conflicts_str[i]);
-                        strncat(temp, conflictstr, strlen(conflictstr));           
-                    }
-                    strncat(temp, "\n", strlen("\n")); 
+                    fprintf(fp, "\n");
 	       }
 	  } else {
 	       goto UNKNOWN_FMT_FIELD;
@@ -727,377 +611,194 @@ char * pkg_formatted_field(pkg_t *pkg, const char *field )
      case 'd':
      case 'D':
 	  if (strcasecmp(field, "Depends") == 0) {
-	       /* Depends */
-	       int i;
-
 	       if (pkg->depends_count) {
-                    char depstr[LINE_LEN];
-                    len = 14 ;
-		    for(i = 0; i < pkg->depends_count; i++) {
-                        len = len + (strlen(pkg->depends_str[i])+4);
-                    }
-                    temp = (char *)realloc(temp,len);
-                    if ( temp == NULL ){
-	               fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	               return NULL;
-                    }
-                    temp[0]='\0';
-                    strncpy(temp, "Depends:", 10);
+                    fprintf(fp, "Depends:");
 		    for(i = 0; i < pkg->depends_count; i++) {
-                        snprintf(depstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->depends_str[i]);
-                        strncat(temp, depstr, strlen(depstr));           
+                        fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->depends_str[i]);
                     }
-                    strncat(temp, "\n", strlen("\n")); 
+		    fprintf(fp, "\n");
 	       }
 	  } else if (strcasecmp(field, "Description") == 0) {
-	       /* Description */
 	       if (pkg->description) {
-                   temp = (char *)realloc(temp,strlen(pkg->description)+16);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->description)+16), "Description: %s\n", pkg->description);
+                   fprintf(fp, "Description: %s\n", pkg->description);
 	       }
 	  } else {
 	       goto UNKNOWN_FMT_FIELD;
 	  }
-      break;
+          break;
      case 'e':
-     case 'E': {
-	  /* Essential */
+     case 'E':
 	  if (pkg->essential) {
-              temp = (char *)realloc(temp,16);
-              if ( temp == NULL ){
-	         fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	         return NULL;
-              }
-              temp[0]='\0';
-              snprintf(temp, (16), "Essential: yes\n");
+              fprintf(fp, "Essential: yes\n");
 	  }
-     }
 	  break;
      case 'f':
-     case 'F': {
-	  /* Filename */
+     case 'F':
 	  if (pkg->filename) {
-              temp = (char *)realloc(temp,strlen(pkg->filename)+12);
-              if ( temp == NULL ){
-	          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	          return NULL;
-              }
-              temp[0]='\0';
-              snprintf(temp, (strlen(pkg->filename)+12), "Filename: %s\n", pkg->filename);
+              fprintf(fp, "Filename: %s\n", pkg->filename);
 	  }
-     }
 	  break;
      case 'i':
-     case 'I': {
+     case 'I':
 	  if (strcasecmp(field, "Installed-Size") == 0) {
-	       /* Installed-Size */
-               temp = (char *)realloc(temp,strlen(pkg->installed_size)+17);
-               if ( temp == NULL ){
-	           fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	           return NULL;
-               }
-               temp[0]='\0';
-               snprintf(temp, (strlen(pkg->installed_size)+17), "Installed-Size: %s\n", pkg->installed_size);
+               fprintf(fp, "Installed-Size: %s\n", pkg->installed_size);
 	  } else if (strcasecmp(field, "Installed-Time") == 0 && pkg->installed_time) {
-               temp = (char *)realloc(temp,29);
-               if ( temp == NULL ){
-	          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	          return NULL;
-               }
-               temp[0]='\0';
-               snprintf(temp, 29, "Installed-Time: %lu\n", pkg->installed_time);
+               fprintf(fp, "Installed-Time: %lu\n", pkg->installed_time);
 	  }
-     }
 	  break;
      case 'm':
-     case 'M': {
-	  /* Maintainer | MD5sum */
+     case 'M':
 	  if (strcasecmp(field, "Maintainer") == 0) {
-	       /* Maintainer */
 	       if (pkg->maintainer) {
-                   temp = (char *)realloc(temp,strlen(pkg->maintainer)+14);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->maintainer)+14), "maintainer: %s\n", pkg->maintainer);
+                   fprintf(fp, "maintainer: %s\n", pkg->maintainer);
 	       }
 	  } else if (strcasecmp(field, "MD5sum") == 0) {
-	       /* MD5sum */
 	       if (pkg->md5sum) {
-                   temp = (char *)realloc(temp,strlen(pkg->md5sum)+11);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->md5sum)+11), "MD5Sum: %s\n", pkg->md5sum);
+                   fprintf(fp, "MD5Sum: %s\n", pkg->md5sum);
 	       }
 	  } else {
 	       goto UNKNOWN_FMT_FIELD;
 	  }
-     }
 	  break;
      case 'p':
-     case 'P': {
+     case 'P':
 	  if (strcasecmp(field, "Package") == 0) {
-	       /* Package */
-               temp = (char *)realloc(temp,strlen(pkg->name)+11);
-               if ( temp == NULL ){
-	          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	          return NULL;
-               }
-               temp[0]='\0';
-               snprintf(temp, (strlen(pkg->name)+11), "Package: %s\n", pkg->name);
+               fprintf(fp, "Package: %s\n", pkg->name);
 	  } else if (strcasecmp(field, "Priority") == 0) {
-	       /* Priority */
-               temp = (char *)realloc(temp,strlen(pkg->priority)+12);
-               if ( temp == NULL ){
-	          fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	          return NULL;
-               }
-               temp[0]='\0';
-               snprintf(temp, (strlen(pkg->priority)+12), "Priority: %s\n", pkg->priority);
+               fprintf(fp, "Priority: %s\n", pkg->priority);
 	  } else if (strcasecmp(field, "Provides") == 0) {
-	       /* Provides */
-	       int i;
-
 	       if (pkg->provides_count) {
-               /* Here we check if the opkg_internal_use_only is used, and we discard it.*/
-                  for ( i=0; i < pkg->provides_count; i++ ){
-	              if (strstr(pkg->provides_str[i],"opkg_internal_use_only")!=NULL) {
-                         memset (pkg->provides_str[i],'\x0',strlen(pkg->provides_str[i])); /* Pigi clear my trick flag, just in case */
-                         flag_provide_false = 1;
-                      }
-                  }
-                  if ( !flag_provide_false ||                                             /* Pigi there is not my trick flag */
-                     ((flag_provide_false) &&  (pkg->provides_count > 1))){             /* Pigi There is, but we also have others Provides */
-                     char provstr[LINE_LEN];
-                     len = 15;
-		     for(i = 0; i < pkg->provides_count; i++) {
-                         len = len + (strlen(pkg->provides_str[i])+5);
-                     }
-                     temp = (char *)realloc(temp,len);
-                     if ( temp == NULL ){
-	                fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	                return NULL;
-                     }
-                     temp[0]='\0';
-                     strncpy(temp, "Provides:", 12);
-		     for(i = 0; i < pkg->provides_count; i++) {
-                         if (strlen(pkg->provides_str[i])>0){;
-                            snprintf(provstr, LINE_LEN, "%s %s", i == 1 ? "" : ",", pkg->provides_str[i]);
-                            strncat(temp, provstr, strlen(provstr));           
-                         }
-                     }
-                     strncat(temp, "\n", strlen("\n")); 
+                  fprintf(fp, "Provides:");
+		  for(i = 1; i < pkg->provides_count; i++) {
+                      fprintf(fp, "%s %s", i == 1 ? "" : ",",
+				      pkg->provides[i]->name);
                   }
+                  fprintf(fp, "\n");
                }
 	  } else {
 	       goto UNKNOWN_FMT_FIELD;
 	  }
-     }
 	  break;
      case 'r':
-     case 'R': {
-	  int i;
-	  /* Replaces | Recommends*/
+     case 'R':
 	  if (strcasecmp (field, "Replaces") == 0) {
 	       if (pkg->replaces_count) {
-                    char replstr[LINE_LEN];
-                    len = 14;
-		    for (i = 0; i < pkg->replaces_count; i++) {
-                        len = len + (strlen(pkg->replaces_str[i])+5);
-                    }
-                    temp = (char *)realloc(temp,len);
-                    if ( temp == NULL ){
-	               fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	               return NULL;
-                    }
-                    temp[0]='\0';
-                    strncpy(temp, "Replaces:", 12);
+                    fprintf(fp, "Replaces:");
 		    for (i = 0; i < pkg->replaces_count; i++) {
-                        snprintf(replstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->replaces_str[i]);
-                        strncat(temp, replstr, strlen(replstr));           
+                        fprintf(fp, "%s %s", i == 0 ? "" : ",",
+					pkg->replaces[i]->name);
                     }
-                    strncat(temp, "\n", strlen("\n")); 
+                    fprintf(fp, "\n");
 	       }
 	  } else if (strcasecmp (field, "Recommends") == 0) {
 	       if (pkg->recommends_count) {
-                    char recstr[LINE_LEN];
-                    len = 15;
+                    fprintf(fp, "Recommends:");
 		    for(i = 0; i < pkg->recommends_count; i++) {
-                         len = len + (strlen( pkg->recommends_str[i])+5);
+                        fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->recommends_str[i]);
                     }
-                    temp = (char *)realloc(temp,len);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                    temp[0]='\0';
-                    strncpy(temp, "Recommends:", 13);
-		    for(i = 0; i < pkg->recommends_count; i++) {
-                        snprintf(recstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->recommends_str[i]);
-                        strncat(temp, recstr, strlen(recstr));           
-                    }
-                    strncat(temp, "\n", strlen("\n")); 
+                    fprintf(fp, "\n");
 	       }
 	  } else {
 	       goto UNKNOWN_FMT_FIELD;
 	  }
-     }
 	  break;
      case 's':
-     case 'S': {
-	  /* Section | Size | Source | Status | Suggests */
+     case 'S':
 	  if (strcasecmp(field, "Section") == 0) {
-	       /* Section */
 	       if (pkg->section) {
-                   temp = (char *)realloc(temp,strlen(pkg->section)+11);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->section)+11), "Section: %s\n", pkg->section);
+                   fprintf(fp, "Section: %s\n", pkg->section);
+	       }
+#if defined HAVE_SHA256
+	  } else if (strcasecmp(field, "SHA256sum") == 0) {
+	       if (pkg->sha256sum) {
+                   fprintf(fp, "SHA256sum: %s\n", pkg->sha256sum);
 	       }
+#endif
 	  } else if (strcasecmp(field, "Size") == 0) {
-	       /* Size */
 	       if (pkg->size) {
-                   temp = (char *)realloc(temp,strlen(pkg->size)+8);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->size)+8), "Size: %s\n", pkg->size);
+                   fprintf(fp, "Size: %s\n", pkg->size);
 	       }
 	  } else if (strcasecmp(field, "Source") == 0) {
-	       /* Source */
 	       if (pkg->source) {
-                   temp = (char *)realloc(temp,strlen(pkg->source)+10);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->source)+10), "Source: %s\n", pkg->source);
+                   fprintf(fp, "Source: %s\n", pkg->source);
                }
 	  } else if (strcasecmp(field, "Status") == 0) {
-	       /* Status */
-               /* Benjamin Pineau note: we should avoid direct usage of 
-                * strlen(arg) without keeping "arg" for later free()
-                */
-               char *pflag=pkg_state_flag_to_str(pkg->state_flag);
-               char *pstat=pkg_state_status_to_str(pkg->state_status);
-               char *pwant=pkg_state_want_to_str(pkg->state_want);
-
-               size_t sum_of_sizes = (size_t) ( strlen(pwant)+ strlen(pflag)+ strlen(pstat) + 12 );
-               temp = (char *)realloc(temp,sum_of_sizes);
-               if ( temp == NULL ){
-                   fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-                   return NULL;
-                }
-                temp[0]='\0';
-                snprintf(temp, sum_of_sizes , "Status: %s %s %s\n", pwant, pflag, pstat);
-                free(pflag);
-                free(pwant);
-               if(pstat) /* pfstat can be NULL if ENOMEM */
-                   free(pstat);
+               char *pflag = pkg_state_flag_to_str(pkg->state_flag);
+               char *pstat = pkg_state_status_to_str(pkg->state_status);
+               char *pwant = pkg_state_want_to_str(pkg->state_want);
+
+	       if (pflag == NULL || pstat == NULL || pwant == NULL)
+		       return;
+
+               fprintf(fp, "Status: %s %s %s\n", pwant, pflag, pstat);
+
+               free(pflag);
+               free(pwant);
+               free(pstat);
 	  } else if (strcasecmp(field, "Suggests") == 0) {
 	       if (pkg->suggests_count) {
-		    int i;
-                    char sugstr[LINE_LEN];
-                    len = 13;
+                    fprintf(fp, "Suggests:");
 		    for(i = 0; i < pkg->suggests_count; i++) {
-                        len = len + (strlen(pkg->suggests_str[i])+5);
-                    }
-                    temp = (char *)realloc(temp,len);
-                    if ( temp == NULL ){
-	               fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	               return NULL;
+                        fprintf(fp, "%s %s", i == 0 ? "" : ",", pkg->suggests_str[i]);
                     }
-                    temp[0]='\0';
-                    strncpy(temp, "Suggests:", 10);
-		    for(i = 0; i < pkg->suggests_count; i++) {
-                        snprintf(sugstr, LINE_LEN, "%s %s", i == 0 ? "" : ",", pkg->suggests_str[i]);
-                        strncat(temp, sugstr, strlen(sugstr));           
-                    }
-                    strncat(temp, "\n", strlen("\n")); 
+                    fprintf(fp, "\n");
 	       }
 	  } else {
 	       goto UNKNOWN_FMT_FIELD;
 	  }
-     }
 	  break;
      case 't':
      case 'T':
 	  if (strcasecmp(field, "Tags") == 0) {
-	       /* Tags */
 	       if (pkg->tags) {
-                   temp = (char *)realloc(temp,strlen(pkg->tags)+8);
-                   if ( temp == NULL ){
-	              fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	              return NULL;
-                   }
-                   temp[0]='\0';
-                   snprintf(temp, (strlen(pkg->tags)+8), "Tags: %s\n", pkg->tags);
+                   fprintf(fp, "Tags: %s\n", pkg->tags);
 	       }
 	  }
 	  break;
      case 'v':
-     case 'V': {
-	  /* Version */
-	  char *version = pkg_version_str_alloc(pkg);
-          temp = (char *)realloc(temp,strlen(version)+14);
-          if ( temp == NULL ){
-	      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	      return NULL;
+     case 'V':
+	  {
+	       char *version = pkg_version_str_alloc(pkg);
+	       if (version == NULL)
+	            return;
+               fprintf(fp, "Version: %s\n", version);
+	       free(version);
           }
-          temp[0]='\0';
-          snprintf(temp, (strlen(version)+12), "Version: %s\n", version);
-	  free(version);
-     }
 	  break;
      default:
 	  goto UNKNOWN_FMT_FIELD;
      }
 
-     if ( strlen(temp)<2 ) {
-          temp[0]='\0';
-     }
-     return temp;
+     return;
 
- UNKNOWN_FMT_FIELD:
+UNKNOWN_FMT_FIELD:
      fprintf(stderr, "%s: ERROR: Unknown field name: %s\n", __FUNCTION__, field);
-     if ( strlen(temp)<2 ) {
-          temp[0]='\0';
-     }
-
-     return temp;
 }
 
-void pkg_print_info(pkg_t *pkg, FILE *file)
+void pkg_formatted_info(FILE *fp, pkg_t *pkg)
 {
-  int t=0;
-     char * buff;
-     if (pkg == NULL) {
-	return;
-     }
-
-     buff = pkg_formatted_info(pkg);
-     if ( buff == NULL ) 
-         return;
-     if (strlen(buff)>2){
-       t = fwrite(buff, 1, strlen(buff), file); //#~rzr:TODO
-     } 
-     free(buff);
+	pkg_formatted_field(fp, pkg, "Package");
+	pkg_formatted_field(fp, pkg, "Version");
+	pkg_formatted_field(fp, pkg, "Depends");
+	pkg_formatted_field(fp, pkg, "Recommends");
+	pkg_formatted_field(fp, pkg, "Suggests");
+	pkg_formatted_field(fp, pkg, "Provides");
+	pkg_formatted_field(fp, pkg, "Replaces");
+	pkg_formatted_field(fp, pkg, "Conflicts");
+	pkg_formatted_field(fp, pkg, "Status");
+	pkg_formatted_field(fp, pkg, "Section");
+	pkg_formatted_field(fp, pkg, "Essential");
+	pkg_formatted_field(fp, pkg, "Architecture");
+	pkg_formatted_field(fp, pkg, "Maintainer");
+	pkg_formatted_field(fp, pkg, "MD5sum");
+	pkg_formatted_field(fp, pkg, "Size");
+	pkg_formatted_field(fp, pkg, "Filename");
+	pkg_formatted_field(fp, pkg, "Conffiles");
+	pkg_formatted_field(fp, pkg, "Source");
+	pkg_formatted_field(fp, pkg, "Description");
+	pkg_formatted_field(fp, pkg, "Installed-Time");
+	pkg_formatted_field(fp, pkg, "Tags");
+	fputs("\n", fp);
 }
 
 void pkg_print_status(pkg_t * pkg, FILE * file)
@@ -1126,39 +827,23 @@ void pkg_print_status(pkg_t * pkg, FILE * file)
 	local storage without requiring a Packages file from any feed.
 	-Jamey
      */
-     pkg_print_field(pkg, file, "Package");
-     pkg_print_field(pkg, file, "Version");
-     pkg_print_field(pkg, file, "Depends");
-     pkg_print_field(pkg, file, "Recommends");
-     pkg_print_field(pkg, file, "Suggests");
-     pkg_print_field(pkg, file, "Provides");
-     pkg_print_field(pkg, file, "Replaces");
-     pkg_print_field(pkg, file, "Conflicts");
-     pkg_print_field(pkg, file, "Status");
-     pkg_print_field(pkg, file, "Essential"); /* @@@@ should be removed in future release. */
-     pkg_print_field(pkg, file, "Architecture");
-     pkg_print_field(pkg, file, "Conffiles");
-     pkg_print_field(pkg, file, "Installed-Time");
-     pkg_print_field(pkg, file, "Auto-Installed");
+     pkg_formatted_field(file, pkg, "Package");
+     pkg_formatted_field(file, pkg, "Version");
+     pkg_formatted_field(file, pkg, "Depends");
+     pkg_formatted_field(file, pkg, "Recommends");
+     pkg_formatted_field(file, pkg, "Suggests");
+     pkg_formatted_field(file, pkg, "Provides");
+     pkg_formatted_field(file, pkg, "Replaces");
+     pkg_formatted_field(file, pkg, "Conflicts");
+     pkg_formatted_field(file, pkg, "Status");
+     pkg_formatted_field(file, pkg, "Essential");
+     pkg_formatted_field(file, pkg, "Architecture");
+     pkg_formatted_field(file, pkg, "Conffiles");
+     pkg_formatted_field(file, pkg, "Installed-Time");
+     pkg_formatted_field(file, pkg, "Auto-Installed");
      fputs("\n", file);
 }
 
-void pkg_print_field(pkg_t *pkg, FILE *file, const char *field)
-{
-     char *buff;
-     if (strlen(field) < PKG_MINIMUM_FIELD_NAME_LEN) {
-       fprintf(stderr, "%s: ERROR: Unknown field name: %s\n",
-	     __FUNCTION__, field);
-     }
-     buff = pkg_formatted_field(pkg, field);
-     if (strlen(buff)>2) {
-       fprintf(file, "%s", buff);
-       fflush(file);
-     }
-     free(buff);
-     return;
-}
-
 /*
  * libdpkg - Debian packaging suite library routines
  * vercmp.c - comparison of version numbers
@@ -1296,42 +981,40 @@ int abstract_pkg_name_compare(const void *p1, const void *p2)
 }
 
 
-char *pkg_version_str_alloc(pkg_t *pkg)
+char *
+pkg_version_str_alloc(pkg_t *pkg)
 {
-     char *complete_version;
-     char *epoch_str;
-     char *revision_str;
-
-     if (pkg->epoch) {
-	  sprintf_alloc(&epoch_str, "%d:", pkg->epoch);
-     } else {
-	  epoch_str = strdup("");
-     }
-
-     if (pkg->revision && strlen(pkg->revision)) {
-	  sprintf_alloc(&revision_str, "-%s", pkg->revision);
-     } else {
-	  revision_str = strdup("");
-     }
-
-
-     sprintf_alloc(&complete_version, "%s%s%s",
-		   epoch_str, pkg->version, revision_str);
-
-     free(epoch_str);
-     free(revision_str);
-
-     return complete_version;
+	char *version;
+
+	if (pkg->epoch) {
+		if (pkg->revision)
+			sprintf_alloc(&version, "%d:%s-%s",
+				pkg->epoch, pkg->version, pkg->revision);
+		else
+			sprintf_alloc(&version, "%d:%s",
+				pkg->epoch, pkg->version);
+	} else {
+		if (pkg->revision)
+			sprintf_alloc(&version, "%s-%s",
+				pkg->version, pkg->revision);
+		else
+			version = xstrdup(pkg->version);
+	}
+
+	return version;
 }
 
-str_list_t *pkg_get_installed_files(pkg_t *pkg)
+/*
+ * XXX: this should be broken into two functions
+ */
+str_list_t *pkg_get_installed_files(opkg_conf_t *conf, pkg_t *pkg)
 {
-     int err;
+     int err, fd;
      char *list_file_name = NULL;
      FILE *list_file = NULL;
      char *line;
      char *installed_file_name;
-     int rootdirlen;
+     int rootdirlen = 0;
 
      pkg->installed_files_ref_cnt++;
 
@@ -1340,10 +1023,6 @@ str_list_t *pkg_get_installed_files(pkg_t *pkg)
      }
 
      pkg->installed_files = str_list_alloc();
-     if (pkg->installed_files == NULL) {
-	  fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-	  return NULL;
-     }
 
      /* For uninstalled packages, get the file list directly from the package.
 	For installed packages, look at the package.list file in the database.
@@ -1356,34 +1035,51 @@ str_list_t *pkg_get_installed_files(pkg_t *pkg)
 	     file. In other words, change deb_extract so that it can
 	     simply return the file list as a char *[] rather than
 	     insisting on writing in to a FILE * as it does now. */
-	  list_file = tmpfile();
+	  sprintf_alloc(&list_file_name, "%s/%s.list.XXXXXX",
+					  conf->tmp_dir, pkg->name);
+	  fd = mkstemp(list_file_name);
+	  if (fd == -1) {
+	       opkg_message(conf, OPKG_ERROR, "%s: mkstemp(%s): %s",
+			       __FUNCTION__, list_file_name, strerror(errno));
+	       free(list_file_name);
+	       return pkg->installed_files;
+	  }
+	  list_file = fdopen(fd, "rw+");
+	  if (list_file == NULL) {
+	       opkg_message(conf, OPKG_ERROR, "%s: fdopen: %s",
+			       __FUNCTION__, strerror(errno));
+	       close(fd);
+	       unlink(list_file_name);
+	       free(list_file_name);
+	       return pkg->installed_files;
+	  }
 	  err = pkg_extract_data_file_names_to_stream(pkg, list_file);
 	  if (err) {
+	       opkg_message(conf, OPKG_ERROR, "%s: Error extracting file list "
+			       "from %s: %s\n", __FUNCTION__,
+			       pkg->local_filename, strerror(err));
 	       fclose(list_file);
-	       fprintf(stderr, "%s: Error extracting file list from %s: %s\n",
-		       __FUNCTION__, pkg->local_filename, strerror(err));
+	       unlink(list_file_name);
+	       free(list_file_name);
 	       return pkg->installed_files;
 	  }
 	  rewind(list_file);
      } else {
 	  sprintf_alloc(&list_file_name, "%s/%s.list",
 			pkg->dest->info_dir, pkg->name);
-	  if (! file_exists(list_file_name)) {
-	       free(list_file_name);
-	       return pkg->installed_files;
-	  }
-
 	  list_file = fopen(list_file_name, "r");
 	  if (list_file == NULL) {
-	       fprintf(stderr, "WARNING: Cannot open %s: %s\n",
-		       list_file_name, strerror(errno));
+	       opkg_message(conf, OPKG_ERROR, "%s: fopen(%s): %s\n",
+		       __FUNCTION__, list_file_name, strerror(errno));
 	       free(list_file_name);
 	       return pkg->installed_files;
 	  }
 	  free(list_file_name);
      }
 
-     rootdirlen = strlen( pkg->dest->root_dir );
+     if (conf->offline_root)
+          rootdirlen = strlen(conf->offline_root);
+
      while (1) {
 	  char *file_name;
 	
@@ -1394,29 +1090,37 @@ str_list_t *pkg_get_installed_files(pkg_t *pkg)
 	  str_chomp(line);
 	  file_name = line;
 
-	  /* Take pains to avoid uglies like "/./" in the middle of file_name. */
-	  if( strncmp( pkg->dest->root_dir, 
-		       file_name, 
-		       rootdirlen ) ) {
+	  if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) {
 	       if (*file_name == '.') {
 		    file_name++;
 	       }
 	       if (*file_name == '/') {
 		    file_name++;
 	       }
-
-	       /* Freed in pkg_free_installed_files */
-	       sprintf_alloc(&installed_file_name, "%s%s", pkg->dest->root_dir, file_name);
+	       sprintf_alloc(&installed_file_name, "%s%s",
+			       pkg->dest->root_dir, file_name);
 	  } else {
-	       // already contains root_dir as header -> ABSOLUTE
-	       sprintf_alloc(&installed_file_name, "%s", file_name);
+	       if (conf->offline_root &&
+	               strncmp(conf->offline_root, file_name, rootdirlen)) {
+	            sprintf_alloc(&installed_file_name, "%s%s",
+				    conf->offline_root, file_name);
+	       } else {
+	            // already contains root_dir as header -> ABSOLUTE
+	            sprintf_alloc(&installed_file_name, "%s", file_name);
+	       }
 	  }
 	  str_list_append(pkg->installed_files, installed_file_name);
+          free(installed_file_name);
 	  free(line);
      }
 
      fclose(list_file);
 
+     if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) {
+	  unlink(list_file_name);
+	  free(list_file_name);
+     }
+
      return pkg->installed_files;
 }
 
@@ -1433,7 +1137,7 @@ int pkg_free_installed_files(pkg_t *pkg)
 	  return 0;
 
      if (pkg->installed_files) {
-         str_list_deinit(pkg->installed_files);
+         str_list_purge(pkg->installed_files);
      }
 
      pkg->installed_files = NULL;
@@ -1489,6 +1193,33 @@ int pkg_run_script(opkg_conf_t *conf, pkg_t *pkg,
      char *path;
      char *cmd;
 
+     if (conf->noaction)
+	     return 0;
+
+     /* XXX: CLEANUP: There must be a better way to handle maintainer
+	scripts when running with offline_root mode and/or a dest other
+	than '/'. I've been playing around with some clever chroot
+	tricks and I might come up with something workable. */
+     /*
+      * Attempt to provide a restricted environment for offline operation
+      * Need the following set as a minimum:
+      * OPKG_OFFLINE_ROOT = absolute path to root dir
+      * D                 = absolute path to root dir (for OE generated postinst)
+      * PATH              = something safe (a restricted set of utilities)
+      */
+
+     if (conf->offline_root) {
+          if (conf->offline_root_path) {
+            setenv("PATH", conf->offline_root_path, 1);
+          } else {
+            opkg_message(conf, OPKG_NOTICE, 
+	    	"(offline root mode: not running %s.%s)\n", pkg->name, script);
+	    return 0;
+          }
+	  setenv("OPKG_OFFLINE_ROOT", conf->offline_root, 1);
+	  setenv("D", conf->offline_root, 1);
+     }
+
      /* XXX: FEATURE: When conf->offline_root is set, we should run the
 	maintainer script within a chroot environment. */
 
@@ -1511,31 +1242,6 @@ int pkg_run_script(opkg_conf_t *conf, pkg_t *pkg,
      }
 
      opkg_message(conf, OPKG_INFO, "Running script %s\n", path);
-     if (conf->noaction) return 0;
-
-     /* XXX: CLEANUP: There must be a better way to handle maintainer
-	scripts when running with offline_root mode and/or a dest other
-	than '/'. I've been playing around with some clever chroot
-	tricks and I might come up with something workable. */
-     /*
-      * Attempt to provide a restricted environment for offline operation
-      * Need the following set as a minimum:
-      * OPKG_OFFLINE_ROOT = absolute path to root dir
-      * D                 = absolute path to root dir (for OE generated postinst)
-      * PATH              = something safe (a restricted set of utilities)
-      */
-
-     bool AllowOfflineMode = false;
-     if (conf->offline_root) {
-	  setenv("OPKG_OFFLINE_ROOT", conf->offline_root, 1);
-	  setenv("D", conf->offline_root, 1);
-          if (NULL == conf->offline_root_path || '\0' == conf->offline_root_path[0]) {
-            setenv("PATH", "/dev/null", 1);
-          } else {
-            setenv("PATH", conf->offline_root_path, 1);
-            AllowOfflineMode = true;
-          }
-     }
 
      setenv("PKG_ROOT",
 	    pkg->dest ? pkg->dest->root_dir : conf->default_dest->root_dir, 1);
@@ -1545,16 +1251,12 @@ int pkg_run_script(opkg_conf_t *conf, pkg_t *pkg,
 	  return 0;
      }
 
-     if (conf->offline_root && !AllowOfflineMode) {
-	  fprintf(stderr, "(offline root mode: not running %s.%s)\n", pkg->name, script);
-	  free(path);
-	  return 0;
-     }
-
      sprintf_alloc(&cmd, "%s %s", path, args);
      free(path);
-
-     err = xsystem(cmd);
+     {
+	  const char *argv[] = {"sh", "-c", cmd, NULL};
+	  err = xsystem(argv);
+     }
      free(cmd);
 
      if (err) {
@@ -1571,13 +1273,13 @@ char *pkg_state_want_to_str(pkg_state_want_t sw)
 
      for (i=0; i < ARRAY_SIZE(pkg_state_want_map); i++) {
 	  if (pkg_state_want_map[i].value == sw) {
-	       return strdup(pkg_state_want_map[i].str);
+	       return xstrdup(pkg_state_want_map[i].str);
 	  }
      }
 
      fprintf(stderr, "%s: ERROR: Illegal value for state_want: %d\n",
 	     __FUNCTION__, sw);
-     return strdup("<STATE_WANT_UNKNOWN>");
+     return xstrdup("<STATE_WANT_UNKNOWN>");
 }
 
 pkg_state_want_t pkg_state_want_from_str(char *str)
@@ -1605,7 +1307,7 @@ char *pkg_state_flag_to_str(pkg_state_flag_t sf)
      sf &= SF_NONVOLATILE_FLAGS;
 
      if (sf == 0) {
-	  return strdup("ok");
+	  return xstrdup("ok");
      } else {
 
 	  for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
@@ -1613,11 +1315,7 @@ char *pkg_state_flag_to_str(pkg_state_flag_t sf)
 		    len += strlen(pkg_state_flag_map[i].str) + 1;
 	       }
 	  }
-	  str = malloc(len);
-          if ( str == NULL ) {
-	      fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
-              return NULL;
-          }
+	  str = xmalloc(len);
 	  str[0] = 0;
 	  for (i=0; i < ARRAY_SIZE(pkg_state_flag_map); i++) {
 	       if (sf & pkg_state_flag_map[i].value) {
@@ -1662,13 +1360,13 @@ char *pkg_state_status_to_str(pkg_state_status_t ss)
 
      for (i=0; i < ARRAY_SIZE(pkg_state_status_map); i++) {
 	  if (pkg_state_status_map[i].value == ss) {
-	       return strdup(pkg_state_status_map[i].str);
+	       return xstrdup(pkg_state_status_map[i].str);
 	  }
      }
 
      fprintf(stderr, "%s: ERROR: Illegal value for state_status: %d\n",
 	     __FUNCTION__, ss);
-     return strdup("<STATE_STATUS_UNKNOWN>");
+     return xstrdup("<STATE_STATUS_UNKNOWN>");
 }
 
 pkg_state_status_t pkg_state_status_from_str(const char *str)
@@ -1760,7 +1458,7 @@ int pkg_info_preinstall_check(opkg_conf_t *conf)
      pkg_hash_fetch_all_installed(pkg_hash, installed_pkgs);
      for (i = 0; i < installed_pkgs->len; i++) {
 	  pkg_t *pkg = installed_pkgs->pkgs[i];
-	  str_list_t *installed_files = pkg_get_installed_files(pkg); /* this causes installed_files to be cached */
+	  str_list_t *installed_files = pkg_get_installed_files(conf, pkg); /* this causes installed_files to be cached */
 	  str_list_elt_t *iter, *niter;
 	  if (installed_files == NULL) {
 	       opkg_message(conf, OPKG_ERROR, "No installed files for pkg %s\n", pkg->name);