lib/libalpm/db.c

   1 /*
   2  *  db.c
   3  *
   4  *  Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
   5  *  Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org>
   6  *  Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
   7  *  Copyright (c) 2005 by Christian Hamar <krics@linuxforum.hu>
   8  *  Copyright (c) 2006 by David Kimpe <dnaku@frugalware.org>
   9  *  Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23  */
  24
  25 #include "config.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <string.h>
  31 #include <sys/stat.h>
  32 #include <regex.h>
  33 #include <time.h>
  34
  35 /* libalpm */
  36 #include "db.h"
  37 #include "alpm_list.h"
  38 #include "log.h"
  39 #include "util.h"
  40 #include "handle.h"
  41 #include "alpm.h"
  42 #include "package.h"
  43 #include "group.h"
  44
  45 /** \addtogroup alpm_databases Database Functions
  46  * @brief Functions to query and manipulate the database of libalpm
  47  * @{
  48  */
  49
  50 /** Register a sync database of packages. */
  51 pmdb_t SYMEXPORT *alpm_db_register_sync(const char *treename)
  52 {
  53         ALPM_LOG_FUNC;
  54
  55         /* Sanity checks */
  56         ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, NULL));
  57         ASSERT(treename != NULL && strlen(treename) != 0, RET_ERR(PM_ERR_WRONG_ARGS, NULL));
  58         /* Do not register a database if a transaction is on-going */
  59         ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, NULL));
  60
  61         return _alpm_db_register_sync(treename);
  62 }
  63
  64 /* Helper function for alpm_db_unregister{_all} */
  65 void _alpm_db_unregister(pmdb_t *db)
  66 {
  67         if(db == NULL) {
  68                 return;
  69         }
  70
  71         _alpm_log(PM_LOG_DEBUG, "unregistering database '%s'\n", db->treename);
  72         _alpm_db_free(db);
  73 }
  74
  75 /** Unregister all package databases. */
  76 int SYMEXPORT alpm_db_unregister_all(void)
  77 {
  78         alpm_list_t *i;
  79         pmdb_t *db;
  80
  81         ALPM_LOG_FUNC;
  82
  83         /* Sanity checks */
  84         ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
  85         /* Do not unregister a database if a transaction is on-going */
  86         ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
  87
  88         /* unregister all sync dbs */
  89         for(i = handle->dbs_sync; i; i = i->next) {
  90                 db = i->data;
  91                 db->ops->unregister(db);
  92                 i->data = NULL;
  93         }
  94         FREELIST(handle->dbs_sync);
  95         return 0;
  96 }
  97
  98 /** Unregister a package database. */
  99 int SYMEXPORT alpm_db_unregister(pmdb_t *db)
 100 {
 101         int found = 0;
 102
 103         ALPM_LOG_FUNC;
 104
 105         /* Sanity checks */
 106         ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
 107         ASSERT(db != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
 108         /* Do not unregister a database if a transaction is on-going */
 109         ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, -1));
 110
 111         if(db == handle->db_local) {
 112                 handle->db_local = NULL;
 113                 found = 1;
 114         } else {
 115                 /* Warning : this function shouldn't be used to unregister all sync
 116                  * databases by walking through the list returned by
 117                  * alpm_option_get_syncdbs, because the db is removed from that list here.
 118                  */
 119                 void *data;
 120                 handle->dbs_sync = alpm_list_remove(handle->dbs_sync,
 121                                 db, _alpm_db_cmp, &data);
 122                 if(data) {
 123                         found = 1;
 124                 }
 125         }
 126
 127         if(!found) {
 128                 RET_ERR(PM_ERR_DB_NOT_FOUND, -1);
 129         }
 130
 131         db->ops->unregister(db);
 132         return 0;
 133 }
 134
 135 /** Set the serverlist of a database. */
 136 int SYMEXPORT alpm_db_setserver(pmdb_t *db, const char *url)
 137 {
 138         char *newurl;
 139         size_t len = 0;
 140
 141         ALPM_LOG_FUNC;
 142
 143         /* Sanity checks */
 144         ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
 145
 146         if(url) {
 147                 len = strlen(url);
 148         }
 149         if(len) {
 150                 newurl = strdup(url);
 151                 /* strip the trailing slash if one exists */
 152                 if(newurl[len - 1] == '/') {
 153                         newurl[len - 1] = '\0';
 154                 }
 155                 db->servers = alpm_list_add(db->servers, newurl);
 156                 _alpm_log(PM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
 157                                 db->treename, newurl);
 158         } else {
 159                 FREELIST(db->servers);
 160                 _alpm_log(PM_LOG_DEBUG, "serverlist flushed for '%s'\n", db->treename);
 161         }
 162
 163         return 0;
 164 }
 165 /** Set the verify gpg signature option for a database.
 166  * @param db database pointer
 167  * @param verify enum pgp_verify_t
 168  * @return 0 on success, -1 on error (pm_errno is set accordingly)
 169  */
 170 int SYMEXPORT alpm_db_set_pgp_verify(pmdb_t *db, pgp_verify_t verify)
 171 {
 172         ALPM_LOG_FUNC;
 173
 174         /* Sanity checks */
 175         ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
 176
 177         db->pgp_verify = verify;
 178         _alpm_log(PM_LOG_DEBUG, "adding VerifySig option to database '%s': %d\n",
 179                         db->treename, verify);
 180
 181         return(0);
 182 }
 183
 184 /** Get the name of a package database. */
 185 const char SYMEXPORT *alpm_db_get_name(const pmdb_t *db)
 186 {
 187         ALPM_LOG_FUNC;
 188
 189         /* Sanity checks */
 190         ASSERT(handle != NULL, return NULL);
 191         ASSERT(db != NULL, return NULL);
 192
 193         return db->treename;
 194 }
 195
 196 /** Get a download URL for the package database. */
 197 const char SYMEXPORT *alpm_db_get_url(const pmdb_t *db)
 198 {
 199         char *url;
 200
 201         ALPM_LOG_FUNC;
 202
 203         /* Sanity checks */
 204         ASSERT(handle != NULL, return NULL);
 205         ASSERT(db != NULL, return NULL);
 206         ASSERT(db->servers != NULL, return NULL);
 207
 208         url = (char*)db->servers->data;
 209
 210         return url;
 211 }
 212
 213
 214 /** Get a package entry from a package database. */
 215 pmpkg_t SYMEXPORT *alpm_db_get_pkg(pmdb_t *db, const char *name)
 216 {
 217         ALPM_LOG_FUNC;
 218
 219         /* Sanity checks */
 220         ASSERT(handle != NULL, return NULL);
 221         ASSERT(db != NULL, return NULL);
 222         ASSERT(name != NULL && strlen(name) != 0, return NULL);
 223
 224         return _alpm_db_get_pkgfromcache(db, name);
 225 }
 226
 227 /** Get the package cache of a package database. */
 228 alpm_list_t SYMEXPORT *alpm_db_get_pkgcache(pmdb_t *db)
 229 {
 230         ALPM_LOG_FUNC;
 231
 232         /* Sanity checks */
 233         ASSERT(handle != NULL, return NULL);
 234         ASSERT(db != NULL, return NULL);
 235
 236         return _alpm_db_get_pkgcache(db);
 237 }
 238
 239 /** Get a group entry from a package database. */
 240 pmgrp_t SYMEXPORT *alpm_db_readgrp(pmdb_t *db, const char *name)
 241 {
 242         ALPM_LOG_FUNC;
 243
 244         /* Sanity checks */
 245         ASSERT(handle != NULL, return NULL);
 246         ASSERT(db != NULL, return NULL);
 247         ASSERT(name != NULL && strlen(name) != 0, return NULL);
 248
 249         return _alpm_db_get_grpfromcache(db, name);
 250 }
 251
 252 /** Get the group cache of a package database. */
 253 alpm_list_t SYMEXPORT *alpm_db_get_grpcache(pmdb_t *db)
 254 {
 255         ALPM_LOG_FUNC;
 256
 257         /* Sanity checks */
 258         ASSERT(handle != NULL, return NULL);
 259         ASSERT(db != NULL, return NULL);
 260
 261         return _alpm_db_get_grpcache(db);
 262 }
 263
 264 /** Searches a database. */
 265 alpm_list_t SYMEXPORT *alpm_db_search(pmdb_t *db, const alpm_list_t* needles)
 266 {
 267         ALPM_LOG_FUNC;
 268
 269         /* Sanity checks */
 270         ASSERT(handle != NULL, return NULL);
 271         ASSERT(db != NULL, return NULL);
 272
 273         return _alpm_db_search(db, needles);
 274 }
 275
 276 /** Set install reason for a package in db. */
 277 int SYMEXPORT alpm_db_set_pkgreason(pmdb_t *db, const char *name, pmpkgreason_t reason)
 278 {
 279         ALPM_LOG_FUNC;
 280
 281         /* Sanity checks */
 282         ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
 283         ASSERT(db != NULL && name != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
 284
 285         pmpkg_t *pkg = _alpm_db_get_pkgfromcache(db, name);
 286         if(pkg == NULL) {
 287                 RET_ERR(PM_ERR_PKG_NOT_FOUND, -1);
 288         }
 289
 290         _alpm_log(PM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
 291         if(alpm_pkg_get_reason(pkg) == reason) {
 292                 /* we are done */
 293                 return 0;
 294         }
 295         /* set reason (in pkgcache) */
 296         pkg->reason = reason;
 297         /* write DESC */
 298         if(_alpm_local_db_write(db, pkg, INFRQ_DESC)) {
 299                 RET_ERR(PM_ERR_DB_WRITE, -1);
 300         }
 301
 302         return 0;
 303 }
 304
 305 /** @} */
 306
 307 pmdb_t *_alpm_db_new(const char *treename, int is_local)
 308 {
 309         pmdb_t *db;
 310
 311         ALPM_LOG_FUNC;
 312
 313         CALLOC(db, 1, sizeof(pmdb_t), RET_ERR(PM_ERR_MEMORY, NULL));
 314         STRDUP(db->treename, treename, RET_ERR(PM_ERR_MEMORY, NULL));
 315         db->is_local = is_local;
 316
 317         return db;
 318 }
 319
 320 const pmpgpsig_t *_alpm_db_pgpsig(pmdb_t *db)
 321 {
 322         ALPM_LOG_FUNC;
 323
 324         /* Sanity checks */
 325         ASSERT(db != NULL, return(NULL));
 326
 327         if(db->pgpsig.rawdata == NULL) {
 328                 size_t len;
 329                 const char *dbfile;
 330                 char *sigfile;
 331                 int ret;
 332
 333                 dbfile = _alpm_db_path(db);
 334                 len = strlen(dbfile) + 5;
 335                 MALLOC(sigfile, len, RET_ERR(PM_ERR_MEMORY, NULL));
 336                 sprintf(sigfile, "%s.sig", dbfile);
 337
 338                 /* TODO: do something with ret value */
 339                 ret = _alpm_load_signature(sigfile, &(db->pgpsig));
 340                 (void)ret;
 341
 342                 FREE(sigfile);
 343         }
 344
 345         return &(db->pgpsig);
 346 }
 347
 348 void _alpm_db_free(pmdb_t *db)
 349 {
 350         ALPM_LOG_FUNC;
 351
 352         /* cleanup pkgcache */
 353         _alpm_db_free_pkgcache(db);
 354         /* cleanup server list */
 355         FREELIST(db->servers);
 356         /* only need to free rawdata */
 357         FREE(db->pgpsig.rawdata);
 358         FREE(db->_path);
 359         FREE(db->treename);
 360         FREE(db);
 361
 362         return;
 363 }
 364
 365 const char *_alpm_db_path(pmdb_t *db)
 366 {
 367         if(!db) {
 368                 return NULL;
 369         }
 370         if(!db->_path) {
 371                 const char *dbpath;
 372                 size_t pathsize;
 373
 374                 dbpath = alpm_option_get_dbpath();
 375                 if(!dbpath) {
 376                         _alpm_log(PM_LOG_ERROR, _("database path is undefined\n"));
 377                         RET_ERR(PM_ERR_DB_OPEN, NULL);
 378                 }
 379
 380                 if(db->is_local) {
 381                         pathsize = strlen(dbpath) + strlen(db->treename) + 2;
 382                         CALLOC(db->_path, 1, pathsize, RET_ERR(PM_ERR_MEMORY, NULL));
 383                         sprintf(db->_path, "%s%s/", dbpath, db->treename);
 384                 } else {
 385                         pathsize = strlen(dbpath) + 5 + strlen(db->treename) + 4;
 386                         CALLOC(db->_path, 1, pathsize, RET_ERR(PM_ERR_MEMORY, NULL));
 387                         /* all sync DBs now reside in the sync/ subdir of the dbpath */
 388                         sprintf(db->_path, "%ssync/%s.db", dbpath, db->treename);
 389                 }
 390                 _alpm_log(PM_LOG_DEBUG, "database path for tree %s set to %s\n",
 391                                 db->treename, db->_path);
 392         }
 393         return db->_path;
 394 }
 395
 396 int _alpm_db_version(pmdb_t *db)
 397 {
 398         if(!db) {
 399                 return -1;
 400         }
 401         return db->ops->version(db);
 402 }
 403
 404 int _alpm_db_cmp(const void *d1, const void *d2)
 405 {
 406         pmdb_t *db1 = (pmdb_t *)d1;
 407         pmdb_t *db2 = (pmdb_t *)d2;
 408         return strcmp(db1->treename, db2->treename);
 409 }
 410
 411 alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
 412 {
 413         const alpm_list_t *i, *j, *k;
 414         alpm_list_t *ret = NULL;
 415         /* copy the pkgcache- we will free the list var after each needle */
 416         alpm_list_t *list = alpm_list_copy(_alpm_db_get_pkgcache(db));
 417
 418         ALPM_LOG_FUNC;
 419
 420         for(i = needles; i; i = i->next) {
 421                 char *targ;
 422                 regex_t reg;
 423
 424                 if(i->data == NULL) {
 425                         continue;
 426                 }
 427                 ret = NULL;
 428                 targ = i->data;
 429                 _alpm_log(PM_LOG_DEBUG, "searching for target '%s'\n", targ);
 430
 431                 if(regcomp(&reg, targ, REG_EXTENDED | REG_NOSUB | REG_ICASE | REG_NEWLINE) != 0) {
 432                         RET_ERR(PM_ERR_INVALID_REGEX, NULL);
 433                 }
 434
 435                 for(j = list; j; j = j->next) {
 436                         pmpkg_t *pkg = j->data;
 437                         const char *matched = NULL;
 438                         const char *name = alpm_pkg_get_name(pkg);
 439                         const char *desc = alpm_pkg_get_desc(pkg);
 440
 441                         /* check name as regex AND as plain text */
 442                         if(name && (regexec(&reg, name, 0, 0, 0) == 0 || strstr(name, targ))) {
 443                                 matched = name;
 444                         }
 445                         /* check desc */
 446                         else if (desc && regexec(&reg, desc, 0, 0, 0) == 0) {
 447                                 matched = desc;
 448                         }
 449                         /* TODO: should we be doing this, and should we print something
 450                          * differently when we do match it since it isn't currently printed? */
 451                         if(!matched) {
 452                                 /* check provides */
 453                                 for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
 454                                         if (regexec(&reg, k->data, 0, 0, 0) == 0) {
 455                                                 matched = k->data;
 456                                                 break;
 457                                         }
 458                                 }
 459                         }
 460                         if(!matched) {
 461                                 /* check groups */
 462                                 for(k = alpm_pkg_get_groups(pkg); k; k = k->next) {
 463                                         if (regexec(&reg, k->data, 0, 0, 0) == 0) {
 464                                                 matched = k->data;
 465                                                 break;
 466                                         }
 467                                 }
 468                         }
 469
 470                         if(matched != NULL) {
 471                                 _alpm_log(PM_LOG_DEBUG, "    search target '%s' matched '%s'\n",
 472                                           targ, matched);
 473                                 ret = alpm_list_add(ret, pkg);
 474                         }
 475                 }
 476
 477                 /* Free the existing search list, and use the returned list for the
 478                  * next needle. This allows for AND-based package searching. */
 479                 alpm_list_free(list);
 480                 list = ret;
 481                 regfree(&reg);
 482         }
 483
 484         return ret;
 485 }
 486
 487 /* Returns a new package cache from db.
 488  * It frees the cache if it already exists.
 489  */
 490 int _alpm_db_load_pkgcache(pmdb_t *db)
 491 {
 492         ALPM_LOG_FUNC;
 493
 494         if(db == NULL) {
 495                 return -1;
 496         }
 497         _alpm_db_free_pkgcache(db);
 498
 499         _alpm_log(PM_LOG_DEBUG, "loading package cache for repository '%s'\n",
 500                         db->treename);
 501         if(db->ops->populate(db) == -1) {
 502                 _alpm_log(PM_LOG_DEBUG,
 503                                 "failed to load package cache for repository '%s'\n", db->treename);
 504                 return -1;
 505         }
 506
 507         db->pkgcache_loaded = 1;
 508         return 0;
 509 }
 510
 511 void _alpm_db_free_pkgcache(pmdb_t *db)
 512 {
 513         ALPM_LOG_FUNC;
 514
 515         if(db == NULL || !db->pkgcache_loaded) {
 516                 return;
 517         }
 518
 519         _alpm_log(PM_LOG_DEBUG, "freeing package cache for repository '%s'\n",
 520                                 db->treename);
 521
 522         alpm_list_free_inner(_alpm_db_get_pkgcache(db),
 523                                 (alpm_list_fn_free)_alpm_pkg_free);
 524         _alpm_pkghash_free(db->pkgcache);
 525         db->pkgcache_loaded = 0;
 526
 527         _alpm_db_free_grpcache(db);
 528 }
 529
 530 pmpkghash_t *_alpm_db_get_pkgcache_hash(pmdb_t *db)
 531 {
 532         ALPM_LOG_FUNC;
 533
 534         if(db == NULL) {
 535                 return NULL;
 536         }
 537
 538         if(!db->pkgcache_loaded) {
 539                 _alpm_db_load_pkgcache(db);
 540         }
 541
 542         /* hmmm, still NULL ?*/
 543         if(!db->pkgcache) {
 544                 _alpm_log(PM_LOG_DEBUG, "warning: pkgcache is NULL for db '%s'\n", db->treename);
 545         }
 546
 547         return db->pkgcache;
 548 }
 549
 550 alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
 551 {
 552         ALPM_LOG_FUNC;
 553
 554         pmpkghash_t *hash = _alpm_db_get_pkgcache_hash(db);
 555
 556         if(hash == NULL) {
 557                 return NULL;
 558         }
 559
 560         return hash->list;
 561 }
 562
 563 /* "duplicate" pkg then add it to pkgcache */
 564 int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
 565 {
 566         pmpkg_t *newpkg;
 567
 568         ALPM_LOG_FUNC;
 569
 570         if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
 571                 return -1;
 572         }
 573
 574         newpkg = _alpm_pkg_dup(pkg);
 575         if(newpkg == NULL) {
 576                 return -1;
 577         }
 578
 579         _alpm_log(PM_LOG_DEBUG, "adding entry '%s' in '%s' cache\n",
 580                                                 alpm_pkg_get_name(newpkg), db->treename);
 581         db->pkgcache = _alpm_pkghash_add_sorted(db->pkgcache, newpkg);
 582
 583         _alpm_db_free_grpcache(db);
 584
 585         return 0;
 586 }
 587
 588 int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
 589 {
 590         pmpkg_t *data = NULL;
 591
 592         ALPM_LOG_FUNC;
 593
 594         if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
 595                 return -1;
 596         }
 597
 598         _alpm_log(PM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
 599                                                 alpm_pkg_get_name(pkg), db->treename);
 600
 601         db->pkgcache = _alpm_pkghash_remove(db->pkgcache, pkg, &data);
 602         if(data == NULL) {
 603                 /* package not found */
 604                 _alpm_log(PM_LOG_DEBUG, "cannot remove entry '%s' from '%s' cache: not found\n",
 605                                                         alpm_pkg_get_name(pkg), db->treename);
 606                 return -1;
 607         }
 608
 609         _alpm_pkg_free(data);
 610
 611         _alpm_db_free_grpcache(db);
 612
 613         return 0;
 614 }
 615
 616 pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
 617 {
 618         ALPM_LOG_FUNC;
 619
 620         if(db == NULL) {
 621                 return NULL;
 622         }
 623
 624         pmpkghash_t *pkgcache = _alpm_db_get_pkgcache_hash(db);
 625         if(!pkgcache) {
 626                 _alpm_log(PM_LOG_DEBUG, "warning: failed to get '%s' from NULL pkgcache\n",
 627                                 target);
 628                 return NULL;
 629         }
 630
 631         return _alpm_pkghash_find(pkgcache, target);
 632 }
 633
 634 /* Returns a new group cache from db.
 635  */
 636 int _alpm_db_load_grpcache(pmdb_t *db)
 637 {
 638         alpm_list_t *lp;
 639
 640         ALPM_LOG_FUNC;
 641
 642         if(db == NULL) {
 643                 return -1;
 644         }
 645
 646         _alpm_log(PM_LOG_DEBUG, "loading group cache for repository '%s'\n",
 647                         db->treename);
 648
 649         for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
 650                 const alpm_list_t *i;
 651                 pmpkg_t *pkg = lp->data;
 652
 653                 for(i = alpm_pkg_get_groups(pkg); i; i = i->next) {
 654                         const char *grpname = i->data;
 655                         alpm_list_t *j;
 656                         pmgrp_t *grp = NULL;
 657                         int found = 0;
 658
 659                         /* first look through the group cache for a group with this name */
 660                         for(j = db->grpcache; j; j = j->next) {
 661                                 grp = j->data;
 662
 663                                 if(strcmp(grp->name, grpname) == 0
 664                                                 && !alpm_list_find_ptr(grp->packages, pkg)) {
 665                                         grp->packages = alpm_list_add(grp->packages, pkg);
 666                                         found = 1;
 667                                         break;
 668                                 }
 669                         }
 670                         if(found) {
 671                                 continue;
 672                         }
 673                         /* we didn't find the group, so create a new one with this name */
 674                         grp = _alpm_grp_new(grpname);
 675                         grp->packages = alpm_list_add(grp->packages, pkg);
 676                         db->grpcache = alpm_list_add(db->grpcache, grp);
 677                 }
 678         }
 679
 680         db->grpcache_loaded = 1;
 681         return 0;
 682 }
 683
 684 void _alpm_db_free_grpcache(pmdb_t *db)
 685 {
 686         alpm_list_t *lg;
 687
 688         ALPM_LOG_FUNC;
 689
 690         if(db == NULL || !db->grpcache_loaded) {
 691                 return;
 692         }
 693
 694         _alpm_log(PM_LOG_DEBUG, "freeing group cache for repository '%s'\n",
 695                                 db->treename);
 696
 697         for(lg = db->grpcache; lg; lg = lg->next) {
 698                 _alpm_grp_free(lg->data);
 699                 lg->data = NULL;
 700         }
 701         FREELIST(db->grpcache);
 702         db->grpcache_loaded = 0;
 703 }
 704
 705 alpm_list_t *_alpm_db_get_grpcache(pmdb_t *db)
 706 {
 707         ALPM_LOG_FUNC;
 708
 709         if(db == NULL) {
 710                 return NULL;
 711         }
 712
 713         if(!db->grpcache_loaded) {
 714                 _alpm_db_load_grpcache(db);
 715         }
 716
 717         return db->grpcache;
 718 }
 719
 720 pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target)
 721 {
 722         alpm_list_t *i;
 723
 724         ALPM_LOG_FUNC;
 725
 726         if(db == NULL || target == NULL || strlen(target) == 0) {
 727                 return NULL;
 728         }
 729
 730         for(i = _alpm_db_get_grpcache(db); i; i = i->next) {
 731                 pmgrp_t *info = i->data;
 732
 733                 if(strcmp(info->name, target) == 0) {
 734                         return info;
 735                 }
 736         }
 737
 738         return NULL;
 739 }
 740
 741 /* vim: set ts=2 sw=2 noet: */