pkg.c

this is the pkg installer for linux

                   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);
               }
	  } 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);
	  } else if (strcasecmp(field, "Suggests") == 0) {
	       if (pkg->suggests_count) {
		    int i;
                    char sugstr[LINE_LEN];
                    len = 13;
		    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;
                    }
                    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")); 
	       }
	  } else {
	       goto UNKNOWN_FMT_FIELD;
	  }
     }
	  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;
          }
          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;

 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)
{
     char * buff;
     if (pkg == NULL) {
	return;
     }

     buff = pkg_formatted_info(pkg);
     if ( buff == NULL ) 
         return;
     if (strlen(buff)>2){
         fwrite(buff, 1, strlen(buff), file);
     } 
     free(buff);
}

void pkg_print_status(pkg_t * pkg, FILE * file)
{
     if (pkg == NULL) {
	  return;
     }

     /* XXX: QUESTION: Do we actually want more fields here? The
	original idea was to save space by installing only what was
	needed for actual computation, (package, version, status,
	essential, conffiles). The assumption is that all other fields
	can be found in th available file.

	But, someone proposed the idea to make it possible to
	reconstruct a .ipk from an installed package, (ie. for beaming
	from one handheld to another). So, maybe we actually want a few
	more fields here, (depends, suggests, etc.), so that that would
	be guaranteed to work even in the absence of more information
	from the available file.

	28-MAR-03: kergoth and I discussed this yesterday.  We think
	the essential info needs to be here for all installed packages
	because they may not appear in the Packages files on various
	feeds.  Furthermore, one should be able to install from URL or
	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");
     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
 *
 * Copyright (C) 1995 Ian Jackson <[e-mail]>
 */
int pkg_compare_versions(const pkg_t *pkg, const pkg_t *ref_pkg)
{
     int r;

     if (pkg->epoch > ref_pkg->epoch) {
	  return 1;
     }

     if (pkg->epoch < ref_pkg->epoch) {
	  return -1;
     }

     r = verrevcmp(pkg->version, ref_pkg->version);
     if (r) {
	  return r;
     }

#ifdef USE_DEBVERSION
     r = verrevcmp(pkg->revision, ref_pkg->revision);
     if (r) {
	  return r;
     }

     r = verrevcmp(pkg->familiar_revision, ref_pkg->familiar_revision);
#endif

     return r;
}

int verrevcmp(const char *val, const char *ref)
{
     int vc, rc;
     long vl, rl;
     const char *vp, *rp;
     const char *vsep, *rsep;
    
     if (!val) val= "";
     if (!ref) ref= "";
     for (;;) {
	  vp= val;  while (*vp && !isdigit(*vp)) vp++;
	  rp= ref;  while (*rp && !isdigit(*rp)) rp++;
	  for (;;) {
	       vc= (val == vp) ? 0 : *val++;
	       rc= (ref == rp) ? 0 : *ref++;
	       if (!rc && !vc) break;
	       if (vc && !isalpha(vc)) vc += 256; /* assumes ASCII character set */
	       if (rc && !isalpha(rc)) rc += 256;
	       if (vc != rc) return vc - rc;
	  }
	  val= vp;
	  ref= rp;
	  vl=0;  if (isdigit(*vp)) vl= strtol(val,(char**)&val,10);
	  rl=0;  if (isdigit(*rp)) rl= strtol(ref,(char**)&ref,10);
	  if (vl != rl) return vl - rl;

	  vc = *val;
	  rc = *ref;
	  vsep = strchr(".-", vc);
	  rsep = strchr(".-", rc);
	  if (vsep && !rsep) return -1;
	  if (!vsep && rsep) return +1;

	  if (!*val && !*ref) return 0;
	  if (!*val) return -1;
	  if (!*ref) return +1;
     }
}

int pkg_version_satisfied(pkg_t *it, pkg_t *ref, const char *op)
{
     int r;

     r = pkg_compare_versions(it, ref);

     if (strcmp(op, "<=") == 0 || strcmp(op, "<") == 0) {
	  return r <= 0;
     }

     if (strcmp(op, ">=") == 0 || strcmp(op, ">") == 0) {
	  return r >= 0;
     }

     if (strcmp(op, "<<") == 0) {
	  return r < 0;
     }

     if (strcmp(op, ">>") == 0) {
	  return r > 0;
     }

     if (strcmp(op, "=") == 0) {
	  return r == 0;
     }

     fprintf(stderr, "unknown operator: %s", op);
     return 0;
}

int pkg_name_version_and_architecture_compare(void *p1, void *p2)
{
     const pkg_t *a = *(const pkg_t **)p1;
     const pkg_t *b = *(const pkg_t **)p2;
     int namecmp;
     int vercmp;
     if (!a->name || !b->name) {
       fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->name=%p b=%p b->name=%p\n",
	       a, a->name, b, b->name);
       return 0;
     }
       
     namecmp = strcmp(a->name, b->name);
     if (namecmp)
	  return namecmp;
     vercmp = pkg_compare_versions(a, b);
     if (vercmp)
	  return vercmp;
     if (!a->arch_priority || !b->arch_priority) {
       fprintf(stderr, "pkg_name_version_and_architecture_compare: a=%p a->arch_priority=%i b=%p b->arch_priority=%i\n",
	       a, a->arch_priority, b, b->arch_priority);
       return 0;
     }
     if (a->arch_priority > b->arch_priority)
	  return 1;
     if (a->arch_priority < b->arch_priority)
	  return -1;
     return 0;
}

int abstract_pkg_name_compare(void *p1, void *p2)
{
     const abstract_pkg_t *a = *(const abstract_pkg_t **)p1;
     const abstract_pkg_t *b = *(const abstract_pkg_t **)p2;
     if (!a->name || !b->name) {
       fprintf(stderr, "abstract_pkg_name_compare: a=%p a->name=%p b=%p b->name=%p\n",
	       a, a->name, b, b->name);
       return 0;
     }
     return strcmp(a->name, b->name);
}


char *pkg_version_str_alloc(pkg_t *pkg)
{
     char *complete_version;
     char *epoch_str;
#ifdef USE_DEBVERSION
     char *revision_str;
     char *familiar_revision_str;
#endif

     if (pkg->epoch) {
	  sprintf_alloc(&epoch_str, "%d:", pkg->epoch);
     } else {
	  epoch_str = strdup("");
     }

#ifdef USE_DEBVERSION
     if (pkg->revision && strlen(pkg->revision)) {
	  sprintf_alloc(&revision_str, "-%s", pkg->revision);
     } else {
	  revision_str = strdup("");
     }

     if (pkg->familiar_revision && strlen(pkg->familiar_revision)) {
	  sprintf_alloc(&familiar_revision_str, "-fam%s", pkg->familiar_revision);
     } else {
	  familiar_revision_str = strdup("");
     }
#endif

#ifdef USE_DEBVERSION
     sprintf_alloc(&complete_version, "%s%s%s%s",
		   epoch_str, pkg->version, revision_str, familiar_revision_str);
#else
     sprintf_alloc(&complete_version, "%s%s",
		   epoch_str, pkg->version);
#endif

     free(epoch_str);
#ifdef USE_DEBVERSION
     free(revision_str);
     free(familiar_revision_str);
#endif

     return complete_version;
}

str_list_t *pkg_get_installed_files(pkg_t *pkg)
{
     int err;
     char *list_file_name = NULL;
     FILE *list_file = NULL;
     char *line;
     char *installed_file_name;
     int rootdirlen;

     pkg->installed_files_ref_cnt++;

     if (pkg->installed_files) {
	  return pkg->installed_files;
     }

     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 firectly from the package.
	For installed packages, look at the package.list file in the database.
     */
     if (pkg->state_status == SS_NOT_INSTALLED || pkg->dest == NULL) {
	  if (pkg->local_filename == NULL) {
	       return pkg->installed_files;
	  }
	  /* XXX: CLEANUP: Maybe rewrite this to avoid using a temporary
	     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();
	  err = pkg_extract_data_file_names_to_stream(pkg, list_file);
	  if (err) {
	       fclose(list_file);
	       fprintf(stderr, "%s: Error extracting file list from %s: %s\n",
		       __FUNCTION__, pkg->local_filename, strerror(err));
	       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));
	       free(list_file_name);
	       return pkg->installed_files;
	  }
	  free(list_file_name);
     }

     rootdirlen = strlen( pkg->dest->root_dir );
     while (1) {
	  char *file_name;
	
	  line = file_read_line_alloc(list_file);
	  if (line == NULL) {
	       break;
	  }
	  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 (*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);
	  } else {
	       // already contains root_dir as header -> ABSOLUTE
	       sprintf_alloc(&installed_file_name, "%s", file_name);