lib/libalpm/cache.c

   1 /*
   2  *  cache.c
   3  *
   4  *  Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19  *  USA.
  20  */
  21
  22 #include "config.h"
  23
  24 #include <unistd.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <sys/stat.h>
  30 #include <libintl.h>
  31
  32 /* libalpm */
  33 #include "cache.h"
  34 #include "alpm_list.h"
  35 #include "log.h"
  36 #include "alpm.h"
  37 #include "util.h"
  38 #include "error.h"
  39 #include "package.h"
  40 #include "group.h"
  41 #include "db.h"
  42
  43 /* Returns a new package cache from db.
  44  * It frees the cache if it already exists.
  45  */
  46 int _alpm_db_load_pkgcache(pmdb_t *db)
  47 {
  48         pmpkg_t *info;
  49         int count = 0;
  50
  51         ALPM_LOG_FUNC;
  52
  53         if(db == NULL) {
  54                 return(-1);
  55         }
  56
  57         _alpm_db_free_pkgcache(db);
  58
  59         _alpm_log(PM_LOG_DEBUG, _("loading package cache for repository '%s'"),
  60                   db->treename);
  61
  62         _alpm_db_rewind(db);
  63         while((info = _alpm_db_scan(db, NULL)) != NULL) {
  64                 _alpm_log(PM_LOG_FUNCTION, _("adding '%s' to package cache for db '%s'"),
  65                                                         alpm_pkg_get_name(info), db->treename);
  66                 info->origin = PKG_FROM_CACHE;
  67                 info->data = db;
  68                 /* add to the collection */
  69                 db->pkgcache = alpm_list_add(db->pkgcache, info);
  70                 count++;
  71         }
  72
  73         db->pkgcache = alpm_list_msort(db->pkgcache, count, _alpm_pkg_cmp);
  74         return(0);
  75 }
  76
  77 void _alpm_db_free_pkgcache(pmdb_t *db)
  78 {
  79         ALPM_LOG_FUNC;
  80
  81         if(db == NULL || db->pkgcache == NULL) {
  82                 return;
  83         }
  84
  85         _alpm_log(PM_LOG_DEBUG, _("freeing package cache for repository '%s'"),
  86                                 db->treename);
  87
  88         FREELISTPKGS(db->pkgcache);
  89
  90         if(db->grpcache) {
  91                 _alpm_db_free_grpcache(db);
  92         }
  93 }
  94
  95 alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
  96 {
  97         ALPM_LOG_FUNC;
  98
  99         if(db == NULL) {
 100                 return(NULL);
 101         }
 102
 103         if(!db->pkgcache) {
 104                 _alpm_db_load_pkgcache(db);
 105         }
 106
 107         /* hmmm, still NULL ?*/
 108         if(!db->pkgcache) {
 109                 _alpm_log(PM_LOG_DEBUG, _("error: pkgcache is NULL for db '%s'"), db->treename);
 110         }
 111
 112         return(db->pkgcache);
 113 }
 114
 115 int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
 116 {
 117         pmpkg_t *newpkg;
 118
 119         ALPM_LOG_FUNC;
 120
 121         if(db == NULL || pkg == NULL) {
 122                 return(-1);
 123         }
 124
 125         newpkg = _alpm_pkg_dup(pkg);
 126         if(newpkg == NULL) {
 127                 return(-1);
 128         }
 129         _alpm_log(PM_LOG_DEBUG, _("adding entry '%s' in '%s' cache"),
 130                                                 alpm_pkg_get_name(newpkg), db->treename);
 131         db->pkgcache = alpm_list_add_sorted(db->pkgcache, newpkg, _alpm_pkg_cmp);
 132
 133         _alpm_db_free_grpcache(db);
 134
 135         return(0);
 136 }
 137
 138 int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
 139 {
 140         void *vdata;
 141         pmpkg_t *data;
 142
 143         ALPM_LOG_FUNC;
 144
 145         if(db == NULL || pkg == NULL) {
 146                 return(-1);
 147         }
 148
 149         _alpm_log(PM_LOG_DEBUG, _("removing entry '%s' from '%s' cache"),
 150                                                 alpm_pkg_get_name(pkg), db->treename);
 151
 152         db->pkgcache = alpm_list_remove(db->pkgcache, pkg, _alpm_pkg_cmp, &vdata);
 153         data = vdata;
 154         if(data == NULL) {
 155                 /* package not found */
 156                 _alpm_log(PM_LOG_DEBUG, _("cannot remove entry '%s' from '%s' cache: not found"),
 157                                                         alpm_pkg_get_name(pkg), db->treename);
 158                 return(-1);
 159         }
 160
 161         FREEPKG(data);
 162
 163         _alpm_db_free_grpcache(db);
 164
 165         return(0);
 166 }
 167
 168 pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
 169 {
 170         ALPM_LOG_FUNC;
 171
 172         if(db == NULL) {
 173                 return(NULL);
 174         }
 175
 176         alpm_list_t *pkgcache = _alpm_db_get_pkgcache(db);
 177         if(!pkgcache) {
 178                 _alpm_log(PM_LOG_DEBUG, _("error: failed to get '%s' from NULL pkgcache"), target);
 179                 return(NULL);
 180         }
 181
 182         return(_alpm_pkg_find(target, pkgcache));
 183 }
 184
 185 /* Returns a new group cache from db.
 186  */
 187 int _alpm_db_load_grpcache(pmdb_t *db)
 188 {
 189         alpm_list_t *lp;
 190
 191         ALPM_LOG_FUNC;
 192
 193         if(db == NULL) {
 194                 return(-1);
 195         }
 196
 197         if(db->pkgcache == NULL) {
 198                 _alpm_db_load_pkgcache(db);
 199         }
 200
 201         _alpm_log(PM_LOG_DEBUG, _("loading group cache for repository '%s'"), db->treename);
 202
 203         for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
 204                 alpm_list_t *i;
 205                 pmpkg_t *pkg = lp->data;
 206
 207                 for(i = alpm_pkg_get_groups(pkg); i; i = i->next) {
 208                         if(!alpm_list_find_str(db->grpcache, i->data)) {
 209                                 pmgrp_t *grp = _alpm_grp_new();
 210
 211                                 strncpy(grp->name, i->data, GRP_NAME_LEN);
 212                                 grp->name[GRP_NAME_LEN-1] = '\0';
 213                                 grp->packages = alpm_list_add_sorted(grp->packages,
 214                                                                                                                                                                                  /* gross signature forces us to
 215                                                                                                                                                                                         * discard const */
 216                                                                                                                                                                                  (void*)alpm_pkg_get_name(pkg),
 217                                                                                                                                                                                  _alpm_str_cmp);
 218                                 db->grpcache = alpm_list_add_sorted(db->grpcache, grp, _alpm_grp_cmp);
 219                         } else {
 220                                 alpm_list_t *j;
 221
 222                                 for(j = db->grpcache; j; j = j->next) {
 223                                         pmgrp_t *grp = j->data;
 224
 225                                         if(strcmp(grp->name, i->data) == 0) {
 226                                                 const char *pkgname = alpm_pkg_get_name(pkg);
 227                                                 if(!alpm_list_find_str(grp->packages, pkgname)) {
 228                                                         grp->packages = alpm_list_add_sorted(grp->packages,
 229                                                                                              (void*)pkgname,
 230                                                                                                                                                                                                          _alpm_str_cmp);
 231                                                 }
 232                                         }
 233                                 }
 234                         }
 235                 }
 236         }
 237
 238         return(0);
 239 }
 240
 241 void _alpm_db_free_grpcache(pmdb_t *db)
 242 {
 243         alpm_list_t *lg;
 244
 245         ALPM_LOG_FUNC;
 246
 247         if(db == NULL || db->grpcache == NULL) {
 248                 return;
 249         }
 250
 251         for(lg = db->grpcache; lg; lg = lg->next) {
 252                 pmgrp_t *grp = lg->data;
 253
 254                 FREELISTPTR(grp->packages);
 255                 FREEGRP(lg->data);
 256         }
 257         FREELIST(db->grpcache);
 258 }
 259
 260 alpm_list_t *_alpm_db_get_grpcache(pmdb_t *db)
 261 {
 262         ALPM_LOG_FUNC;
 263
 264         if(db == NULL) {
 265                 return(NULL);
 266         }
 267
 268         if(db->grpcache == NULL) {
 269                 _alpm_db_load_grpcache(db);
 270         }
 271
 272         return(db->grpcache);
 273 }
 274
 275 pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target)
 276 {
 277         alpm_list_t *i;
 278
 279         ALPM_LOG_FUNC;
 280
 281         if(db == NULL || target == NULL || strlen(target) == 0) {
 282                 return(NULL);
 283         }
 284
 285         for(i = _alpm_db_get_grpcache(db); i; i = i->next) {
 286                 pmgrp_t *info = i->data;
 287
 288                 if(strcmp(info->name, target) == 0) {
 289                         return(info);
 290                 }
 291         }
 292
 293         return(NULL);
 294 }
 295
 296 /* vim: set ts=2 sw=2 noet: */