pkg_vec.c

   1 /* pkg_vec.c - the itsy package management system
   2
   3    Steven M. Ayer
   4
   5    Copyright (C) 2002 Compaq Computer Corporation
   6
   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.
  11
  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.
  16 */
  17
  18 #include <stdlib.h>
  19 #include <fnmatch.h>
  20 #include "xregex.h"
  21 #include "opkg.h"
  22 #include "pkg.h"
  23
  24 pkg_vec_t * pkg_vec_alloc(void)
  25 {
  26     pkg_vec_t * vec = (pkg_vec_t *)malloc(sizeof(pkg_vec_t));
  27     if (!vec) {
  28       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
  29       return NULL;
  30     }
  31     vec->pkgs = NULL;
  32     vec->len = 0;
  33
  34     return vec;
  35 }
  36
  37 void pkg_vec_free(pkg_vec_t *vec)
  38 {
  39     free(vec->pkgs);
  40     free(vec);
  41 }
  42
  43 /*
  44  * assumption: all names in a vector are identical
  45  * assumption: all version strings are trimmed,
  46  *             so identical versions have identical version strings,
  47  *             implying identical packages; let's marry these
  48  */
  49 pkg_t *pkg_vec_insert_merge(pkg_vec_t *vec, pkg_t *pkg, int set_status,opkg_conf_t *conf)
  50 {
  51      int i;
  52      int found = 0;
  53
  54      /* look for a duplicate pkg by name, version, and architecture */
  55      for (i = 0; i < vec->len; i++){
  56          opkg_message(conf, OPKG_DEBUG2, "Function: %s. Found pkg=%s version=%s arch=%s cmp=%s version=%s arch=%s \n",
  57                       __FUNCTION__, pkg->name, pkg->version, pkg->architecture,
  58                        vec->pkgs[i]->name, vec->pkgs[i]->version,vec->pkgs[i]->architecture );
  59           if ((strcmp(pkg->name, vec->pkgs[i]->name) == 0)
  60               && (pkg_compare_versions(pkg, vec->pkgs[i]) == 0)
  61               && (strcmp(pkg->architecture, vec->pkgs[i]->architecture) == 0)) {
  62                found  = 1;
  63                opkg_message(conf, OPKG_DEBUG2, "Function: %s. Found duplicate for pkg=%s version=%s arch=%s\n",
  64                              __FUNCTION__, pkg->name, pkg->version, pkg->architecture);
  65                break;
  66           }
  67      }
  68
  69      /* we didn't find one, add it */
  70      if (!found){
  71          opkg_message(conf, OPKG_DEBUG2, "Function: %s. Adding new pkg=%s version=%s arch=%s\n",
  72                       __FUNCTION__, pkg->name, pkg->version, pkg->architecture);
  73
  74           vec->pkgs = (pkg_t **)realloc(vec->pkgs, (vec->len + 1) * sizeof(pkg_t *));
  75           vec->pkgs[vec->len] = pkg;
  76           vec->len++;
  77           return pkg;
  78      }
  79      /* update the one that we have */
  80      else {
  81           opkg_message(conf, OPKG_DEBUG2, "Function: %s. calling pkg_merge for pkg=%s version=%s arch=%s",
  82                         __FUNCTION__, pkg->name, pkg->version, pkg->architecture);
  83           if (set_status) {
  84                /* this is from the status file, so need to merge with existing database */
  85                opkg_message(conf, OPKG_DEBUG2, " with set_status\n");
  86                pkg_merge(vec->pkgs[i], pkg, set_status);
  87                /* XXX: CLEANUP: It's not so polite to free something here
  88                   that was passed in from above. */
  89                pkg_deinit(pkg);
  90                free(pkg);
  91           } else {
  92                opkg_message(conf, OPKG_DEBUG2, " WITHOUT set_status\n");
  93                /* just overwrite the old one */
  94                pkg_deinit(vec->pkgs[i]);
  95                free(vec->pkgs[i]);
  96                vec->pkgs[i] = pkg;
  97           }
  98           return vec->pkgs[i];
  99      }
 100 }
 101
 102 void pkg_vec_insert(pkg_vec_t *vec, const pkg_t *pkg)
 103 {
 104      int i;
 105      int found = 0;
 106
 107 #if 0
 108      /* look for a duplicate pkg by name, version, and architecture */
 109      for (i = 0; i < vec->len; i++)
 110           if ((strcmp(pkg->name, vec->pkgs[i]->name) == 0)
 111               && (pkg_compare_versions(pkg, vec->pkgs[i]) == 0)
 112               && (strcmp(pkg->architecture, vec->pkgs[i]->name) == 0)) {
 113                found = 1;
 114                break;
 115           }
 116 #endif
 117
 118      /* we didn't find one, add it */
 119      if(!found){
 120           vec->pkgs = (pkg_t **)realloc(vec->pkgs, (vec->len + 1) * sizeof(pkg_t *));
 121           *(const pkg_t **)&vec->pkgs[vec->len] = pkg;
 122           vec->len++;
 123      }
 124 }
 125
 126 int pkg_vec_contains(pkg_vec_t *vec, pkg_t *apkg)
 127 {
 128      int i;
 129      for (i = 0; i < vec->len; i++)
 130           if (vec->pkgs[i] == apkg)
 131                return 1;
 132      return 0;
 133 }
 134
 135 typedef int (*compare_fcn_t)(const void *, const void *);
 136 void pkg_vec_sort(pkg_vec_t *vec, int (*compar)(pkg_t *, pkg_t *))
 137 {
 138      qsort(vec->pkgs, vec->len, sizeof(pkg_t *), (compare_fcn_t)compar);
 139 }
 140
 141 int pkg_vec_clear_marks(pkg_vec_t *vec)
 142 {
 143      int npkgs = vec->len;
 144      int i;
 145      for (i = 0; i < npkgs; i++) {
 146           pkg_t *pkg = vec->pkgs[i];
 147           pkg->state_flag &= ~SF_MARKED;
 148      }
 149      return 0;
 150 }
 151
 152 int pkg_vec_mark_if_matches(pkg_vec_t *vec, const char *pattern)
 153 {
 154      int matching_count = 0;
 155      pkg_t **pkgs = vec->pkgs;
 156      int npkgs = vec->len;
 157      int i;
 158      for (i = 0; i < npkgs; i++) {
 159           pkg_t *pkg = pkgs[i];
 160           if (fnmatch(pattern, pkg->name, 0)==0) {
 161                pkg->state_flag |= SF_MARKED;
 162                matching_count++;
 163           }
 164      }
 165      return matching_count;
 166 }
 167
 168
 169 abstract_pkg_vec_t * abstract_pkg_vec_alloc(void)
 170 {
 171     abstract_pkg_vec_t * vec ;
 172     vec = (abstract_pkg_vec_t *)malloc(sizeof(abstract_pkg_vec_t));
 173     if (!vec) {
 174       fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
 175       return NULL;
 176     }
 177     vec->pkgs = NULL;
 178     vec->len = 0;
 179
 180     return vec;
 181 }
 182
 183 void abstract_pkg_vec_free(abstract_pkg_vec_t *vec)
 184 {
 185     free(vec->pkgs);
 186     free(vec);
 187 }
 188
 189 /*
 190  * assumption: all names in a vector are unique
 191  */
 192 void abstract_pkg_vec_insert(abstract_pkg_vec_t *vec, abstract_pkg_t *pkg)
 193 {
 194     int i;
 195
 196 #if 0
 197     /* look for a duplicate pkg by name */
 198     for(i = 0; i < vec->len; i++)
 199         if (strcmp(pkg->name, vec->pkgs[i]->name) == 0)
 200             break;
 201
 202     /* we didn't find one, add it */
 203     if(i == vec->len){
 204 #endif
 205         vec->pkgs =
 206           (abstract_pkg_t **)
 207             realloc(vec->pkgs, (vec->len + 1) * sizeof(abstract_pkg_t *));
 208         vec->pkgs[vec->len] = pkg;
 209         vec->len++;
 210 #if 0
 211     }
 212 #endif
 213 }
 214
 215 abstract_pkg_t * abstract_pkg_vec_get(abstract_pkg_vec_t *vec, int i)
 216 {
 217     if (vec->len > i)
 218         return vec->pkgs[i];
 219     else
 220         return NULL;
 221 }
 222
 223 int abstract_pkg_vec_contains(abstract_pkg_vec_t *vec, abstract_pkg_t *apkg)
 224 {
 225      int i;
 226      for (i = 0; i < vec->len; i++)
 227           if (vec->pkgs[i] == apkg)
 228                return 1;
 229      return 0;
 230 }
 231
 232 void abstract_pkg_vec_sort(pkg_vec_t *vec, int (*compar)(abstract_pkg_t *, abstract_pkg_t *))
 233 {
 234      qsort(vec->pkgs, vec->len, sizeof(pkg_t *), (compare_fcn_t)compar);
 235 }
 236