lib/libalpm/package.c

   1 /*
   2  *  package.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, 2006 by Christian Hamar <krics@linuxforum.hu>
   8  *  Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sys/types.h>
  29
  30 /* libalpm */
  31 #include "package.h"
  32 #include "alpm_list.h"
  33 #include "log.h"
  34 #include "util.h"
  35 #include "db.h"
  36 #include "delta.h"
  37 #include "handle.h"
  38 #include "deps.h"
  39
  40 /** \addtogroup alpm_packages Package Functions
  41  * @brief Functions to manipulate libalpm packages
  42  * @{
  43  */
  44
  45 /** Free a package. */
  46 int SYMEXPORT alpm_pkg_free(pmpkg_t *pkg)
  47 {
  48         ALPM_LOG_FUNC;
  49
  50         ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
  51
  52         /* Only free packages loaded in user space */
  53         if(pkg->origin == PKG_FROM_FILE) {
  54                 _alpm_pkg_free(pkg);
  55         }
  56
  57         return 0;
  58 }
  59
  60 /** Check the integrity (with md5) of a package from the sync cache. */
  61 int SYMEXPORT alpm_pkg_checkmd5sum(pmpkg_t *pkg)
  62 {
  63         char *fpath;
  64         int retval;
  65
  66         ALPM_LOG_FUNC;
  67
  68         ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
  69         /* We only inspect packages from sync repositories */
  70         ASSERT(pkg->origin == PKG_FROM_SYNCDB, RET_ERR(PM_ERR_PKG_INVALID, -1));
  71
  72         fpath = _alpm_filecache_find(alpm_pkg_get_filename(pkg));
  73
  74         retval = _alpm_test_md5sum(fpath, alpm_pkg_get_md5sum(pkg));
  75
  76         if(retval == 0) {
  77                 return 0;
  78         } else if(retval == 1) {
  79                 pm_errno = PM_ERR_PKG_INVALID;
  80                 retval = -1;
  81         }
  82
  83         return retval;
  84 }
  85
  86 /* Default package accessor functions. These will get overridden by any
  87  * backend logic that needs lazy access, such as the local database through
  88  * a lazy-load cache. However, the defaults will work just fine for fully-
  89  * populated package structures. */
  90 static const char *_pkg_get_filename(pmpkg_t *pkg)    { return pkg->filename; }
  91 static const char *_pkg_get_desc(pmpkg_t *pkg)        { return pkg->desc; }
  92 static const char *_pkg_get_url(pmpkg_t *pkg)         { return pkg->url; }
  93 static time_t _pkg_get_builddate(pmpkg_t *pkg)        { return pkg->builddate; }
  94 static time_t _pkg_get_installdate(pmpkg_t *pkg)      { return pkg->installdate; }
  95 static const char *_pkg_get_packager(pmpkg_t *pkg)    { return pkg->packager; }
  96 static const char *_pkg_get_md5sum(pmpkg_t *pkg)      { return pkg->md5sum; }
  97 static const char *_pkg_get_arch(pmpkg_t *pkg)        { return pkg->arch; }
  98 static off_t _pkg_get_size(pmpkg_t *pkg)              { return pkg->size; }
  99 static off_t _pkg_get_isize(pmpkg_t *pkg)             { return pkg->isize; }
 100 static pmpkgreason_t _pkg_get_reason(pmpkg_t *pkg)    { return pkg->reason; }
 101 static int _pkg_has_scriptlet(pmpkg_t *pkg)           { return pkg->scriptlet; }
 102
 103 static alpm_list_t *_pkg_get_licenses(pmpkg_t *pkg)   { return pkg->licenses; }
 104 static alpm_list_t *_pkg_get_groups(pmpkg_t *pkg)     { return pkg->groups; }
 105 static alpm_list_t *_pkg_get_depends(pmpkg_t *pkg)    { return pkg->depends; }
 106 static alpm_list_t *_pkg_get_optdepends(pmpkg_t *pkg) { return pkg->optdepends; }
 107 static alpm_list_t *_pkg_get_conflicts(pmpkg_t *pkg)  { return pkg->conflicts; }
 108 static alpm_list_t *_pkg_get_provides(pmpkg_t *pkg)   { return pkg->provides; }
 109 static alpm_list_t *_pkg_get_replaces(pmpkg_t *pkg)   { return pkg->replaces; }
 110 static alpm_list_t *_pkg_get_deltas(pmpkg_t *pkg)     { return pkg->deltas; }
 111 static alpm_list_t *_pkg_get_files(pmpkg_t *pkg)      { return pkg->files; }
 112 static alpm_list_t *_pkg_get_backup(pmpkg_t *pkg)     { return pkg->backup; }
 113
 114 static void *_pkg_changelog_open(pmpkg_t UNUSED *pkg)
 115 {
 116         return NULL;
 117 }
 118
 119 static size_t _pkg_changelog_read(void UNUSED *ptr, size_t UNUSED size,
 120                 const pmpkg_t UNUSED *pkg, const UNUSED void *fp)
 121 {
 122         return 0;
 123 }
 124
 125 static int _pkg_changelog_close(const pmpkg_t UNUSED *pkg,
 126                 void UNUSED *fp)
 127 {
 128         return EOF;
 129 }
 130
 131 /** The standard package operations struct. Get fields directly from the
 132  * struct itself with no abstraction layer or any type of lazy loading.
 133  */
 134 struct pkg_operations default_pkg_ops = {
 135         .get_filename    = _pkg_get_filename,
 136         .get_desc        = _pkg_get_desc,
 137         .get_url         = _pkg_get_url,
 138         .get_builddate   = _pkg_get_builddate,
 139         .get_installdate = _pkg_get_installdate,
 140         .get_packager    = _pkg_get_packager,
 141         .get_md5sum      = _pkg_get_md5sum,
 142         .get_arch        = _pkg_get_arch,
 143         .get_size        = _pkg_get_size,
 144         .get_isize       = _pkg_get_isize,
 145         .get_reason      = _pkg_get_reason,
 146         .has_scriptlet   = _pkg_has_scriptlet,
 147
 148         .get_licenses    = _pkg_get_licenses,
 149         .get_groups      = _pkg_get_groups,
 150         .get_depends     = _pkg_get_depends,
 151         .get_optdepends  = _pkg_get_optdepends,
 152         .get_conflicts   = _pkg_get_conflicts,
 153         .get_provides    = _pkg_get_provides,
 154         .get_replaces    = _pkg_get_replaces,
 155         .get_deltas      = _pkg_get_deltas,
 156         .get_files       = _pkg_get_files,
 157         .get_backup      = _pkg_get_backup,
 158
 159         .changelog_open  = _pkg_changelog_open,
 160         .changelog_read  = _pkg_changelog_read,
 161         .changelog_close = _pkg_changelog_close,
 162 };
 163
 164 /* Public functions for getting package information. These functions
 165  * delegate the hard work to the function callbacks attached to each
 166  * package, which depend on where the package was loaded from. */
 167 const char SYMEXPORT *alpm_pkg_get_filename(pmpkg_t *pkg)
 168 {
 169         return pkg->ops->get_filename(pkg);
 170 }
 171
 172 const char SYMEXPORT *alpm_pkg_get_name(pmpkg_t *pkg)
 173 {
 174         return pkg->name;
 175 }
 176
 177 const char SYMEXPORT *alpm_pkg_get_version(pmpkg_t *pkg)
 178 {
 179         return pkg->version;
 180 }
 181
 182 const char SYMEXPORT *alpm_pkg_get_desc(pmpkg_t *pkg)
 183 {
 184         return pkg->ops->get_desc(pkg);
 185 }
 186
 187 const char SYMEXPORT *alpm_pkg_get_url(pmpkg_t *pkg)
 188 {
 189         return pkg->ops->get_url(pkg);
 190 }
 191
 192 time_t SYMEXPORT alpm_pkg_get_builddate(pmpkg_t *pkg)
 193 {
 194         return pkg->ops->get_builddate(pkg);
 195 }
 196
 197 time_t SYMEXPORT alpm_pkg_get_installdate(pmpkg_t *pkg)
 198 {
 199         return pkg->ops->get_installdate(pkg);
 200 }
 201
 202 const char SYMEXPORT *alpm_pkg_get_packager(pmpkg_t *pkg)
 203 {
 204         return pkg->ops->get_packager(pkg);
 205 }
 206
 207 const char SYMEXPORT *alpm_pkg_get_md5sum(pmpkg_t *pkg)
 208 {
 209         return pkg->ops->get_md5sum(pkg);
 210 }
 211
 212 const char SYMEXPORT *alpm_pkg_get_arch(pmpkg_t *pkg)
 213 {
 214         return pkg->ops->get_arch(pkg);
 215 }
 216
 217 off_t SYMEXPORT alpm_pkg_get_size(pmpkg_t *pkg)
 218 {
 219         return pkg->ops->get_size(pkg);
 220 }
 221
 222 off_t SYMEXPORT alpm_pkg_get_isize(pmpkg_t *pkg)
 223 {
 224         return pkg->ops->get_isize(pkg);
 225 }
 226
 227 pmpkgreason_t SYMEXPORT alpm_pkg_get_reason(pmpkg_t *pkg)
 228 {
 229         return pkg->ops->get_reason(pkg);
 230 }
 231
 232 alpm_list_t SYMEXPORT *alpm_pkg_get_licenses(pmpkg_t *pkg)
 233 {
 234         return pkg->ops->get_licenses(pkg);
 235 }
 236
 237 alpm_list_t SYMEXPORT *alpm_pkg_get_groups(pmpkg_t *pkg)
 238 {
 239         return pkg->ops->get_groups(pkg);
 240 }
 241
 242 alpm_list_t SYMEXPORT *alpm_pkg_get_depends(pmpkg_t *pkg)
 243 {
 244         return pkg->ops->get_depends(pkg);
 245 }
 246
 247 alpm_list_t SYMEXPORT *alpm_pkg_get_optdepends(pmpkg_t *pkg)
 248 {
 249         return pkg->ops->get_optdepends(pkg);
 250 }
 251
 252 alpm_list_t SYMEXPORT *alpm_pkg_get_conflicts(pmpkg_t *pkg)
 253 {
 254         return pkg->ops->get_conflicts(pkg);
 255 }
 256
 257 alpm_list_t SYMEXPORT *alpm_pkg_get_provides(pmpkg_t *pkg)
 258 {
 259         return pkg->ops->get_provides(pkg);
 260 }
 261
 262 alpm_list_t SYMEXPORT *alpm_pkg_get_replaces(pmpkg_t *pkg)
 263 {
 264         return pkg->ops->get_replaces(pkg);
 265 }
 266
 267 alpm_list_t SYMEXPORT *alpm_pkg_get_deltas(pmpkg_t *pkg)
 268 {
 269         return pkg->ops->get_deltas(pkg);
 270 }
 271
 272 alpm_list_t SYMEXPORT *alpm_pkg_get_files(pmpkg_t *pkg)
 273 {
 274         return pkg->ops->get_files(pkg);
 275 }
 276
 277 alpm_list_t SYMEXPORT *alpm_pkg_get_backup(pmpkg_t *pkg)
 278 {
 279         return pkg->ops->get_backup(pkg);
 280 }
 281
 282 pmdb_t SYMEXPORT *alpm_pkg_get_db(pmpkg_t *pkg)
 283 {
 284         /* Sanity checks */
 285         ASSERT(pkg != NULL, return NULL);
 286         ASSERT(pkg->origin != PKG_FROM_FILE, return NULL);
 287
 288         return pkg->origin_data.db;
 289 }
 290
 291 /** Open a package changelog for reading. */
 292 void SYMEXPORT *alpm_pkg_changelog_open(pmpkg_t *pkg)
 293 {
 294         return pkg->ops->changelog_open(pkg);
 295 }
 296
 297 /** Read data from an open changelog 'file stream'. */
 298 size_t SYMEXPORT alpm_pkg_changelog_read(void *ptr, size_t size,
 299                 const pmpkg_t *pkg, const void *fp)
 300 {
 301         return pkg->ops->changelog_read(ptr, size, pkg, fp);
 302 }
 303
 304 /*
 305 int SYMEXPORT alpm_pkg_changelog_feof(const pmpkg_t *pkg, void *fp)
 306 {
 307         return pkg->ops->changelog_feof(pkg, fp);
 308 }
 309 */
 310
 311 /** Close a package changelog for reading. */
 312 int SYMEXPORT alpm_pkg_changelog_close(const pmpkg_t *pkg, void *fp)
 313 {
 314         return pkg->ops->changelog_close(pkg, fp);
 315 }
 316
 317 int SYMEXPORT alpm_pkg_has_scriptlet(pmpkg_t *pkg)
 318 {
 319         return pkg->ops->has_scriptlet(pkg);
 320 }
 321
 322 static void find_requiredby(pmpkg_t *pkg, pmdb_t *db, alpm_list_t **reqs)
 323 {
 324         const alpm_list_t *i;
 325         for(i = _alpm_db_get_pkgcache(db); i; i = i->next) {
 326                 pmpkg_t *cachepkg = i->data;
 327                 alpm_list_t *i;
 328                 for(i = alpm_pkg_get_depends(cachepkg); i; i = i->next) {
 329                         if(_alpm_depcmp(pkg, i->data)) {
 330                                 const char *cachepkgname = cachepkg->name;
 331                                 if(alpm_list_find_str(*reqs, cachepkgname) == NULL) {
 332                                         *reqs = alpm_list_add(*reqs, strdup(cachepkgname));
 333                                 }
 334                         }
 335                 }
 336         }
 337 }
 338
 339 /** Compute the packages requiring a given package. */
 340 alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(pmpkg_t *pkg)
 341 {
 342         const alpm_list_t *i;
 343         alpm_list_t *reqs = NULL;
 344         pmdb_t *db;
 345
 346         if(pkg->origin == PKG_FROM_FILE) {
 347                 /* The sane option; search locally for things that require this. */
 348                 db = alpm_option_get_localdb();
 349                 find_requiredby(pkg, db, &reqs);
 350         } else {
 351                 /* We have a DB package. if it is a local package, then we should
 352                  * only search the local DB; else search all known sync databases. */
 353                 db = pkg->origin_data.db;
 354                 if(db->is_local) {
 355                         find_requiredby(pkg, db, &reqs);
 356                 } else {
 357                         for(i = handle->dbs_sync; i; i = i->next) {
 358                                 db = i->data;
 359                                 find_requiredby(pkg, db, &reqs);
 360                         }
 361                         reqs = alpm_list_msort(reqs, alpm_list_count(reqs), _alpm_str_cmp);
 362                 }
 363         }
 364         return reqs;
 365 }
 366
 367 /** @} */
 368
 369 pmpkg_t *_alpm_pkg_new(void)
 370 {
 371         pmpkg_t* pkg;
 372
 373         ALPM_LOG_FUNC;
 374
 375         CALLOC(pkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
 376
 377         return pkg;
 378 }
 379
 380 pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
 381 {
 382         pmpkg_t *newpkg;
 383         alpm_list_t *i;
 384
 385         ALPM_LOG_FUNC;
 386
 387         CALLOC(newpkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
 388
 389         newpkg->name_hash = pkg->name_hash;
 390         STRDUP(newpkg->filename, pkg->filename, RET_ERR(PM_ERR_MEMORY, newpkg));
 391         STRDUP(newpkg->name, pkg->name, RET_ERR(PM_ERR_MEMORY, newpkg));
 392         STRDUP(newpkg->version, pkg->version, RET_ERR(PM_ERR_MEMORY, newpkg));
 393         STRDUP(newpkg->desc, pkg->desc, RET_ERR(PM_ERR_MEMORY, newpkg));
 394         STRDUP(newpkg->url, pkg->url, RET_ERR(PM_ERR_MEMORY, newpkg));
 395         newpkg->builddate = pkg->builddate;
 396         newpkg->installdate = pkg->installdate;
 397         STRDUP(newpkg->packager, pkg->packager, RET_ERR(PM_ERR_MEMORY, newpkg));
 398         STRDUP(newpkg->md5sum, pkg->md5sum, RET_ERR(PM_ERR_MEMORY, newpkg));
 399         STRDUP(newpkg->arch, pkg->arch, RET_ERR(PM_ERR_MEMORY, newpkg));
 400         newpkg->size = pkg->size;
 401         newpkg->isize = pkg->isize;
 402         newpkg->scriptlet = pkg->scriptlet;
 403         newpkg->reason = pkg->reason;
 404
 405         newpkg->licenses   = alpm_list_strdup(pkg->licenses);
 406         newpkg->replaces   = alpm_list_strdup(pkg->replaces);
 407         newpkg->groups     = alpm_list_strdup(pkg->groups);
 408         newpkg->files      = alpm_list_strdup(pkg->files);
 409         newpkg->backup     = alpm_list_strdup(pkg->backup);
 410         for(i = pkg->depends; i; i = alpm_list_next(i)) {
 411                 newpkg->depends = alpm_list_add(newpkg->depends, _alpm_dep_dup(i->data));
 412         }
 413         newpkg->optdepends = alpm_list_strdup(pkg->optdepends);
 414         newpkg->conflicts  = alpm_list_strdup(pkg->conflicts);
 415         newpkg->provides   = alpm_list_strdup(pkg->provides);
 416         newpkg->deltas     = alpm_list_copy_data(pkg->deltas, sizeof(pmdelta_t));
 417
 418         /* internal */
 419         newpkg->origin = pkg->origin;
 420         newpkg->ops = pkg->ops;
 421         if(newpkg->origin == PKG_FROM_FILE) {
 422                 newpkg->origin_data.file = strdup(pkg->origin_data.file);
 423         } else {
 424                 newpkg->origin_data.db = pkg->origin_data.db;
 425         }
 426         newpkg->infolevel = pkg->infolevel;
 427
 428         return newpkg;
 429 }
 430
 431 void _alpm_pkg_free(pmpkg_t *pkg)
 432 {
 433         ALPM_LOG_FUNC;
 434
 435         if(pkg == NULL) {
 436                 return;
 437         }
 438
 439         FREE(pkg->filename);
 440         FREE(pkg->name);
 441         FREE(pkg->version);
 442         FREE(pkg->desc);
 443         FREE(pkg->url);
 444         FREE(pkg->packager);
 445         FREE(pkg->md5sum);
 446         FREE(pkg->base64_sig);
 447         FREE(pkg->arch);
 448         FREELIST(pkg->licenses);
 449         FREELIST(pkg->replaces);
 450         FREELIST(pkg->groups);
 451         FREELIST(pkg->files);
 452         FREELIST(pkg->backup);
 453         alpm_list_free_inner(pkg->depends, (alpm_list_fn_free)_alpm_dep_free);
 454         alpm_list_free(pkg->depends);
 455         FREELIST(pkg->optdepends);
 456         FREELIST(pkg->conflicts);
 457         FREELIST(pkg->provides);
 458         alpm_list_free_inner(pkg->deltas, (alpm_list_fn_free)_alpm_delta_free);
 459         alpm_list_free(pkg->deltas);
 460         alpm_list_free(pkg->delta_path);
 461         alpm_list_free(pkg->removes);
 462
 463         if(pkg->origin == PKG_FROM_FILE) {
 464                 FREE(pkg->origin_data.file);
 465         }
 466         FREE(pkg);
 467 }
 468
 469 /* This function should be used when removing a target from upgrade/sync target list
 470  * Case 1: If pkg is a loaded package file (PKG_FROM_FILE), it will be freed.
 471  * Case 2: If pkg is a pkgcache entry (PKG_FROM_CACHE), it won't be freed,
 472  *         only the transaction specific fields of pkg will be freed.
 473  */
 474 void _alpm_pkg_free_trans(pmpkg_t *pkg)
 475 {
 476         ALPM_LOG_FUNC;
 477
 478         if(pkg == NULL) {
 479                 return;
 480         }
 481
 482         if(pkg->origin == PKG_FROM_FILE) {
 483                 _alpm_pkg_free(pkg);
 484                 return;
 485         }
 486
 487         alpm_list_free(pkg->removes);
 488         pkg->removes = NULL;
 489 }
 490
 491 /* Is spkg an upgrade for localpkg? */
 492 int _alpm_pkg_compare_versions(pmpkg_t *spkg, pmpkg_t *localpkg)
 493 {
 494         ALPM_LOG_FUNC;
 495
 496         return alpm_pkg_vercmp(alpm_pkg_get_version(spkg),
 497                         alpm_pkg_get_version(localpkg));
 498 }
 499
 500 /* Helper function for comparing packages
 501  */
 502 int _alpm_pkg_cmp(const void *p1, const void *p2)
 503 {
 504         pmpkg_t *pkg1 = (pmpkg_t *)p1;
 505         pmpkg_t *pkg2 = (pmpkg_t *)p2;
 506         return strcoll(pkg1->name, pkg2->name);
 507 }
 508
 509 /* Test for existence of a package in a alpm_list_t*
 510  * of pmpkg_t*
 511  */
 512 pmpkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle)
 513 {
 514         alpm_list_t *lp;
 515         unsigned long needle_hash;
 516
 517         ALPM_LOG_FUNC;
 518
 519         if(needle == NULL || haystack == NULL) {
 520                 return NULL;
 521         }
 522
 523         needle_hash = _alpm_hash_sdbm(needle);
 524
 525         for(lp = haystack; lp; lp = lp->next) {
 526                 pmpkg_t *info = lp->data;
 527
 528                 if(info) {
 529                         /* a zero hash will cause a fall-through just in case */
 530                         if(info->name_hash && info->name_hash != needle_hash) {
 531                                 continue;
 532                         }
 533
 534                         /* finally: we had hash match, verify string match */
 535                         if(strcmp(info->name, needle) == 0) {
 536                                 return info;
 537                         }
 538                 }
 539         }
 540         return NULL;
 541 }
 542
 543 /** Test if a package should be ignored.
 544  *
 545  * Checks if the package is ignored via IgnorePkg, or if the package is
 546  * in a group ignored via IgnoreGrp.
 547  *
 548  * @param pkg the package to test
 549  *
 550  * @return 1 if the package should be ignored, 0 otherwise
 551  */
 552 int _alpm_pkg_should_ignore(pmpkg_t *pkg)
 553 {
 554         alpm_list_t *groups = NULL;
 555
 556         /* first see if the package is ignored */
 557         if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(pkg))) {
 558                 return 1;
 559         }
 560
 561         /* next see if the package is in a group that is ignored */
 562         for(groups = handle->ignoregrp; groups; groups = alpm_list_next(groups)) {
 563                 char *grp = (char *)alpm_list_getdata(groups);
 564                 if(alpm_list_find_str(alpm_pkg_get_groups(pkg), grp)) {
 565                         return 1;
 566                 }
 567         }
 568
 569         return 0;
 570 }
 571
 572 /* vim: set ts=2 sw=2 noet: */