lib/libalpm/package.c

   1 /*
   2  *  package.c
   3  *
   4  *  Copyright (c) 2002-2007 by Judd Vinet <jvinet@zeroflux.org>
   5  *  Copyright (c) 2005 by Aurelien Foret <orelien@chez.com>
   6  *  Copyright (c) 2005, 2006 by Christian Hamar <krics@linuxforum.hu>
   7  *  Copyright (c) 2005, 2006 by Miklos Vajna <vmiklos@frugalware.org>
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "config.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <limits.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30 #include <errno.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <unistd.h>
  34
  35 /* libarchive */
  36 #include <archive.h>
  37 #include <archive_entry.h>
  38
  39 /* libalpm */
  40 #include "package.h"
  41 #include "alpm_list.h"
  42 #include "log.h"
  43 #include "util.h"
  44 #include "db.h"
  45 #include "cache.h"
  46 #include "delta.h"
  47 #include "handle.h"
  48 #include "deps.h"
  49
  50 /** \addtogroup alpm_packages Package Functions
  51  * @brief Functions to manipulate libalpm packages
  52  * @{
  53  */
  54
  55 /** Free a package.
  56  * @param pkg package pointer to free
  57  * @return 0 on success, -1 on error (pm_errno is set accordingly)
  58  */
  59 int SYMEXPORT alpm_pkg_free(pmpkg_t *pkg)
  60 {
  61         ALPM_LOG_FUNC;
  62
  63         ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
  64
  65         /* Only free packages loaded in user space */
  66         if(pkg->origin != PKG_FROM_CACHE) {
  67                 _alpm_pkg_free(pkg);
  68         }
  69
  70         return(0);
  71 }
  72
  73 /** Check the integrity (with md5) of a package from the sync cache.
  74  * @param pkg package pointer
  75  * @return 0 on success, -1 on error (pm_errno is set accordingly)
  76  */
  77 int SYMEXPORT alpm_pkg_checkmd5sum(pmpkg_t *pkg)
  78 {
  79         char *fpath;
  80         int retval;
  81
  82         ALPM_LOG_FUNC;
  83
  84         ASSERT(pkg != NULL, RET_ERR(PM_ERR_WRONG_ARGS, -1));
  85         /* We only inspect packages from sync repositories */
  86         ASSERT(pkg->origin == PKG_FROM_CACHE, RET_ERR(PM_ERR_PKG_INVALID, -1));
  87         ASSERT(pkg->origin_data.db != handle->db_local, RET_ERR(PM_ERR_PKG_INVALID, -1));
  88
  89         fpath = _alpm_filecache_find(alpm_pkg_get_filename(pkg));
  90
  91         retval = _alpm_test_md5sum(fpath, alpm_pkg_get_md5sum(pkg));
  92
  93         if(retval == 0) {
  94                 return(0);
  95         } else if (retval == 1) {
  96                 pm_errno = PM_ERR_PKG_INVALID;
  97                 retval = -1;
  98         }
  99
 100         return(retval);
 101 }
 102
 103 /** Compare versions.
 104  * @param ver1 first version
 105  * @param ver2 secont version
 106  * @return postive, 0 or negative if ver1 is less, equal or more
 107  * than ver2, respectively.
 108  */
 109 int SYMEXPORT alpm_pkg_vercmp(const char *ver1, const char *ver2)
 110 {
 111         ALPM_LOG_FUNC;
 112
 113         return(_alpm_versioncmp(ver1, ver2));
 114 }
 115
 116 const char SYMEXPORT *alpm_pkg_get_filename(pmpkg_t *pkg)
 117 {
 118         ALPM_LOG_FUNC;
 119
 120         /* Sanity checks */
 121         ASSERT(handle != NULL, return(NULL));
 122         ASSERT(pkg != NULL, return(NULL));
 123
 124         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 125                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 126         }
 127
 128         return pkg->filename;
 129 }
 130
 131 const char SYMEXPORT *alpm_pkg_get_name(pmpkg_t *pkg)
 132 {
 133         ALPM_LOG_FUNC;
 134
 135         /* Sanity checks */
 136         ASSERT(handle != NULL, return(NULL));
 137         ASSERT(pkg != NULL, return(NULL));
 138
 139         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_BASE)) {
 140                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_BASE);
 141         }
 142         return pkg->name;
 143 }
 144
 145 const char SYMEXPORT *alpm_pkg_get_version(pmpkg_t *pkg)
 146 {
 147         ALPM_LOG_FUNC;
 148
 149         /* Sanity checks */
 150         ASSERT(handle != NULL, return(NULL));
 151         ASSERT(pkg != NULL, return(NULL));
 152
 153         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_BASE)) {
 154                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_BASE);
 155         }
 156         return pkg->version;
 157 }
 158
 159 const char SYMEXPORT *alpm_pkg_get_desc(pmpkg_t *pkg)
 160 {
 161         ALPM_LOG_FUNC;
 162
 163         /* Sanity checks */
 164         ASSERT(handle != NULL, return(NULL));
 165         ASSERT(pkg != NULL, return(NULL));
 166
 167         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 168                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 169         }
 170         return pkg->desc;
 171 }
 172
 173 const char SYMEXPORT *alpm_pkg_get_url(pmpkg_t *pkg)
 174 {
 175         ALPM_LOG_FUNC;
 176
 177         /* Sanity checks */
 178         ASSERT(handle != NULL, return(NULL));
 179         ASSERT(pkg != NULL, return(NULL));
 180
 181         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 182                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 183         }
 184         return pkg->url;
 185 }
 186
 187 time_t SYMEXPORT alpm_pkg_get_builddate(pmpkg_t *pkg)
 188 {
 189         ALPM_LOG_FUNC;
 190
 191         /* Sanity checks */
 192         ASSERT(handle != NULL, return(0));
 193         ASSERT(pkg != NULL, return(0));
 194
 195         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 196                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 197         }
 198         return pkg->builddate;
 199 }
 200
 201 time_t SYMEXPORT alpm_pkg_get_installdate(pmpkg_t *pkg)
 202 {
 203         ALPM_LOG_FUNC;
 204
 205         /* Sanity checks */
 206         ASSERT(handle != NULL, return(0));
 207         ASSERT(pkg != NULL, return(0));
 208
 209         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 210                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 211         }
 212         return pkg->installdate;
 213 }
 214
 215 const char SYMEXPORT *alpm_pkg_get_packager(pmpkg_t *pkg)
 216 {
 217         ALPM_LOG_FUNC;
 218
 219         /* Sanity checks */
 220         ASSERT(handle != NULL, return(NULL));
 221         ASSERT(pkg != NULL, return(NULL));
 222
 223         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 224                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 225         }
 226         return pkg->packager;
 227 }
 228
 229 const char SYMEXPORT *alpm_pkg_get_md5sum(pmpkg_t *pkg)
 230 {
 231         ALPM_LOG_FUNC;
 232
 233         /* Sanity checks */
 234         ASSERT(handle != NULL, return(NULL));
 235         ASSERT(pkg != NULL, return(NULL));
 236
 237         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 238                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 239         }
 240         return pkg->md5sum;
 241 }
 242
 243 const char SYMEXPORT *alpm_pkg_get_arch(pmpkg_t *pkg)
 244 {
 245         ALPM_LOG_FUNC;
 246
 247         /* Sanity checks */
 248         ASSERT(handle != NULL, return(NULL));
 249         ASSERT(pkg != NULL, return(NULL));
 250
 251         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 252                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 253         }
 254         return pkg->arch;
 255 }
 256
 257 unsigned long SYMEXPORT alpm_pkg_get_size(pmpkg_t *pkg)
 258 {
 259         ALPM_LOG_FUNC;
 260
 261         /* Sanity checks */
 262         ASSERT(handle != NULL, return(-1));
 263         ASSERT(pkg != NULL, return(-1));
 264
 265         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 266                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 267         }
 268         return pkg->size;
 269 }
 270
 271 unsigned long SYMEXPORT alpm_pkg_get_isize(pmpkg_t *pkg)
 272 {
 273         ALPM_LOG_FUNC;
 274
 275         /* Sanity checks */
 276         ASSERT(handle != NULL, return(-1));
 277         ASSERT(pkg != NULL, return(-1));
 278
 279         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 280                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 281         }
 282         return pkg->isize;
 283 }
 284
 285 pmpkgreason_t SYMEXPORT alpm_pkg_get_reason(pmpkg_t *pkg)
 286 {
 287         ALPM_LOG_FUNC;
 288
 289         /* Sanity checks */
 290         ASSERT(handle != NULL, return(-1));
 291         ASSERT(pkg != NULL, return(-1));
 292
 293         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 294                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 295         }
 296         return pkg->reason;
 297 }
 298
 299 alpm_list_t SYMEXPORT *alpm_pkg_get_licenses(pmpkg_t *pkg)
 300 {
 301         ALPM_LOG_FUNC;
 302
 303         /* Sanity checks */
 304         ASSERT(handle != NULL, return(NULL));
 305         ASSERT(pkg != NULL, return(NULL));
 306
 307         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 308                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 309         }
 310         return pkg->licenses;
 311 }
 312
 313 alpm_list_t SYMEXPORT *alpm_pkg_get_groups(pmpkg_t *pkg)
 314 {
 315         ALPM_LOG_FUNC;
 316
 317         /* Sanity checks */
 318         ASSERT(handle != NULL, return(NULL));
 319         ASSERT(pkg != NULL, return(NULL));
 320
 321         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 322                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 323         }
 324         return pkg->groups;
 325 }
 326
 327 alpm_list_t SYMEXPORT *alpm_pkg_get_depends(pmpkg_t *pkg)
 328 {
 329         ALPM_LOG_FUNC;
 330
 331         /* Sanity checks */
 332         ASSERT(handle != NULL, return(NULL));
 333         ASSERT(pkg != NULL, return(NULL));
 334
 335         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
 336                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
 337         }
 338         return pkg->depends;
 339 }
 340
 341 alpm_list_t SYMEXPORT *alpm_pkg_get_optdepends(pmpkg_t *pkg)
 342 {
 343         ALPM_LOG_FUNC;
 344
 345         /* Sanity checks */
 346         ASSERT(handle != NULL, return(NULL));
 347         ASSERT(pkg != NULL, return(NULL));
 348
 349         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
 350                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
 351         }
 352         return pkg->optdepends;
 353 }
 354
 355 alpm_list_t SYMEXPORT *alpm_pkg_get_conflicts(pmpkg_t *pkg)
 356 {
 357         ALPM_LOG_FUNC;
 358
 359         /* Sanity checks */
 360         ASSERT(handle != NULL, return(NULL));
 361         ASSERT(pkg != NULL, return(NULL));
 362
 363         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
 364                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
 365         }
 366         return pkg->conflicts;
 367 }
 368
 369 alpm_list_t SYMEXPORT *alpm_pkg_get_provides(pmpkg_t *pkg)
 370 {
 371         ALPM_LOG_FUNC;
 372
 373         /* Sanity checks */
 374         ASSERT(handle != NULL, return(NULL));
 375         ASSERT(pkg != NULL, return(NULL));
 376
 377         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DEPENDS)) {
 378                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DEPENDS);
 379         }
 380         return pkg->provides;
 381 }
 382
 383 alpm_list_t SYMEXPORT *alpm_pkg_get_deltas(pmpkg_t *pkg)
 384 {
 385         ALPM_LOG_FUNC;
 386
 387         /* Sanity checks */
 388         ASSERT(handle != NULL, return(NULL));
 389         ASSERT(pkg != NULL, return(NULL));
 390
 391         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DELTAS)) {
 392                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DELTAS);
 393         }
 394         return pkg->deltas;
 395 }
 396
 397 alpm_list_t SYMEXPORT *alpm_pkg_get_replaces(pmpkg_t *pkg)
 398 {
 399         ALPM_LOG_FUNC;
 400
 401         /* Sanity checks */
 402         ASSERT(handle != NULL, return(NULL));
 403         ASSERT(pkg != NULL, return(NULL));
 404
 405         if(pkg->origin == PKG_FROM_CACHE && !(pkg->infolevel & INFRQ_DESC)) {
 406                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 407         }
 408         return pkg->replaces;
 409 }
 410
 411 alpm_list_t SYMEXPORT *alpm_pkg_get_files(pmpkg_t *pkg)
 412 {
 413         ALPM_LOG_FUNC;
 414
 415         /* Sanity checks */
 416         ASSERT(handle != NULL, return(NULL));
 417         ASSERT(pkg != NULL, return(NULL));
 418
 419         if(pkg->origin == PKG_FROM_CACHE && pkg->origin_data.db == handle->db_local
 420                  && !(pkg->infolevel & INFRQ_FILES)) {
 421                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
 422         }
 423         return pkg->files;
 424 }
 425
 426 alpm_list_t SYMEXPORT *alpm_pkg_get_backup(pmpkg_t *pkg)
 427 {
 428         ALPM_LOG_FUNC;
 429
 430         /* Sanity checks */
 431         ASSERT(handle != NULL, return(NULL));
 432         ASSERT(pkg != NULL, return(NULL));
 433
 434         if(pkg->origin == PKG_FROM_CACHE && pkg->origin_data.db == handle->db_local
 435                  && !(pkg->infolevel & INFRQ_FILES)) {
 436                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_FILES);
 437         }
 438         return pkg->backup;
 439 }
 440
 441 /**
 442  * Open a package changelog for reading. Similar to fopen in functionality,
 443  * except that the returned 'file stream' could really be from an archive
 444  * as well as from the database.
 445  * @param pkg the package to read the changelog of (either file or db)
 446  * @return a 'file stream' to the package changelog
 447  */
 448 void SYMEXPORT *alpm_pkg_changelog_open(pmpkg_t *pkg)
 449 {
 450         ALPM_LOG_FUNC;
 451
 452         /* Sanity checks */
 453         ASSERT(handle != NULL, return(NULL));
 454         ASSERT(pkg != NULL, return(NULL));
 455
 456         if(pkg->origin == PKG_FROM_CACHE) {
 457                 char clfile[PATH_MAX];
 458                 snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog",
 459                                 alpm_option_get_dbpath(),
 460                                 alpm_db_get_name(handle->db_local),
 461                                 alpm_pkg_get_name(pkg),
 462                                 alpm_pkg_get_version(pkg));
 463                 return fopen(clfile, "r");
 464         } else if(pkg->origin == PKG_FROM_FILE) {
 465                 struct archive *archive = NULL;
 466                 struct archive_entry *entry;
 467                 const char *pkgfile = pkg->origin_data.file;
 468                 int ret = ARCHIVE_OK;
 469
 470                 if((archive = archive_read_new()) == NULL) {
 471                         RET_ERR(PM_ERR_LIBARCHIVE, NULL);
 472                 }
 473
 474                 archive_read_support_compression_all(archive);
 475                 archive_read_support_format_all(archive);
 476
 477                 if (archive_read_open_filename(archive, pkgfile,
 478                                         ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
 479                         RET_ERR(PM_ERR_PKG_OPEN, NULL);
 480                 }
 481
 482                 while((ret = archive_read_next_header(archive, &entry)) == ARCHIVE_OK) {
 483                         const char *entry_name = archive_entry_pathname(entry);
 484
 485                         if(strcmp(entry_name, ".CHANGELOG") == 0) {
 486                                 return(archive);
 487                         }
 488                 }
 489                 /* we didn't find a changelog */
 490                 archive_read_finish(archive);
 491                 errno = ENOENT;
 492         }
 493         return(NULL);
 494 }
 495
 496 /**
 497  * Read data from an open changelog 'file stream'. Similar to fread in
 498  * functionality, this function takes a buffer and amount of data to read.
 499  * @param ptr a buffer to fill with raw changelog data
 500  * @param size the size of the buffer
 501  * @param pkg the package that the changelog is being read from
 502  * @param fp a 'file stream' to the package changelog
 503  * @return the number of characters read, or 0 if there is no more data
 504  */
 505 size_t SYMEXPORT alpm_pkg_changelog_read(void *ptr, size_t size,
 506                 const pmpkg_t *pkg, const void *fp)
 507 {
 508         size_t ret = 0;
 509         if(pkg->origin == PKG_FROM_CACHE) {
 510                 ret = fread(ptr, 1, size, (FILE*)fp);
 511         } else if(pkg->origin == PKG_FROM_FILE) {
 512                 ret = archive_read_data((struct archive*)fp, ptr, size);
 513         }
 514         return(ret);
 515 }
 516
 517 /*
 518 int SYMEXPORT alpm_pkg_changelog_feof(const pmpkg_t *pkg, void *fp)
 519 {
 520         int ret = 0;
 521         if(pkg->origin == PKG_FROM_CACHE) {
 522                 ret = feof((FILE*)fp);
 523         } else if(pkg->origin == PKG_FROM_FILE) {
 524                 // note: this doesn't quite work, no feof in libarchive
 525                 ret = archive_read_data((struct archive*)fp, NULL, 0);
 526         }
 527         return(ret);
 528 }
 529 */
 530
 531 /**
 532  * Close a package changelog for reading. Similar to fclose in functionality,
 533  * except that the 'file stream' could really be from an archive as well as
 534  * from the database.
 535  * @param pkg the package that the changelog was read from
 536  * @param fp a 'file stream' to the package changelog
 537  * @return whether closing the package changelog stream was successful
 538  */
 539 int SYMEXPORT alpm_pkg_changelog_close(const pmpkg_t *pkg, void *fp)
 540 {
 541         int ret = 0;
 542         if(pkg->origin == PKG_FROM_CACHE) {
 543                 ret = fclose((FILE*)fp);
 544         } else if(pkg->origin == PKG_FROM_FILE) {
 545                 ret = archive_read_finish((struct archive *)fp);
 546         }
 547         return(ret);
 548 }
 549
 550 unsigned short SYMEXPORT alpm_pkg_has_scriptlet(pmpkg_t *pkg)
 551 {
 552         ALPM_LOG_FUNC;
 553
 554         /* Sanity checks */
 555         ASSERT(handle != NULL, return(-1));
 556         ASSERT(pkg != NULL, return(-1));
 557
 558         if(pkg->origin == PKG_FROM_CACHE && pkg->origin_data.db == handle->db_local
 559                  && !(pkg->infolevel & INFRQ_SCRIPTLET)) {
 560                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_SCRIPTLET);
 561         }
 562         return pkg->scriptlet;
 563 }
 564
 565 /**
 566  * @brief Compute the packages requiring a given package.
 567  * @param pkg a package
 568  * @return the list of packages requiring pkg
 569  *
 570  * A depends on B through n depends <=> A listed in B's requiredby n times
 571  * n == 0 or 1 in almost all cases */
 572 alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(pmpkg_t *pkg)
 573 {
 574         const alpm_list_t *i, *j;
 575         alpm_list_t *reqs = NULL;
 576
 577         pmdb_t *localdb = alpm_option_get_localdb();
 578         for(i = _alpm_db_get_pkgcache(localdb); i; i = i->next) {
 579                 if(!i->data) {
 580                         continue;
 581                 }
 582                 pmpkg_t *cachepkg = i->data;
 583                 const char *cachepkgname = alpm_pkg_get_name(cachepkg);
 584
 585                 for(j = alpm_pkg_get_depends(cachepkg); j; j = j->next) {
 586                         pmdepend_t *dep = j->data;
 587
 588                         if(alpm_depcmp(pkg, dep)) {
 589                                 _alpm_log(PM_LOG_DEBUG, "adding '%s' in requiredby field for '%s'\n",
 590                                           cachepkgname, pkg->name);
 591                                 reqs = alpm_list_add(reqs, strdup(cachepkgname));
 592                         }
 593                 }
 594         }
 595         return(reqs);
 596 }
 597
 598 /** @} */
 599
 600 /* this function was taken from rpm 4.0.4 and rewritten */
 601 int _alpm_versioncmp(const char *a, const char *b)
 602 {
 603         char str1[64], str2[64];
 604         char *ptr1, *ptr2;
 605         char *one, *two;
 606         char *rel1 = NULL, *rel2 = NULL;
 607         char oldch1, oldch2;
 608         int is1num, is2num;
 609         int rc;
 610
 611         ALPM_LOG_FUNC;
 612
 613         if(!strcmp(a,b)) {
 614                 return(0);
 615         }
 616
 617         strncpy(str1, a, 64);
 618         str1[63] = 0;
 619         strncpy(str2, b, 64);
 620         str2[63] = 0;
 621
 622         /* lose the release number */
 623         for(one = str1; *one && *one != '-'; one++);
 624         if(one) {
 625                 *one = '\0';
 626                 rel1 = ++one;
 627         }
 628         for(two = str2; *two && *two != '-'; two++);
 629         if(two) {
 630                 *two = '\0';
 631                 rel2 = ++two;
 632         }
 633
 634         one = str1;
 635         two = str2;
 636
 637         while(*one || *two) {
 638                 while(*one && !isalnum((int)*one)) one++;
 639                 while(*two && !isalnum((int)*two)) two++;
 640
 641                 ptr1 = one;
 642                 ptr2 = two;
 643
 644                 /* find the next segment for each string */
 645                 if(isdigit((int)*ptr1)) {
 646                         is1num = 1;
 647                         while(*ptr1 && isdigit((int)*ptr1)) ptr1++;
 648                 } else {
 649                         is1num = 0;
 650                         while(*ptr1 && isalpha((int)*ptr1)) ptr1++;
 651                 }
 652                 if(isdigit((int)*ptr2)) {
 653                         is2num = 1;
 654                         while(*ptr2 && isdigit((int)*ptr2)) ptr2++;
 655                 } else {
 656                         is2num = 0;
 657                         while(*ptr2 && isalpha((int)*ptr2)) ptr2++;
 658                 }
 659
 660                 oldch1 = *ptr1;
 661                 *ptr1 = '\0';
 662                 oldch2 = *ptr2;
 663                 *ptr2 = '\0';
 664
 665                 /* see if we ran out of segments on one string */
 666                 if(one == ptr1 && two != ptr2) {
 667                         return(is2num ? -1 : 1);
 668                 }
 669                 if(one != ptr1 && two == ptr2) {
 670                         return(is1num ? 1 : -1);
 671                 }
 672
 673                 /* see if we have a type mismatch (ie, one is alpha and one is digits) */
 674                 if(is1num && !is2num) return(1);
 675                 if(!is1num && is2num) return(-1);
 676
 677                 if(is1num) while(*one == '0') one++;
 678                 if(is2num) while(*two == '0') two++;
 679
 680                 rc = strverscmp(one, two);
 681                 if(rc) return(rc);
 682
 683                 *ptr1 = oldch1;
 684                 *ptr2 = oldch2;
 685                 one = ptr1;
 686                 two = ptr2;
 687         }
 688
 689         if((!*one) && (!*two)) {
 690                 /* compare release numbers */
 691                 if(rel1 && rel2 && strlen(rel1) && strlen(rel2)) return(_alpm_versioncmp(rel1, rel2));
 692                 return(0);
 693         }
 694
 695         return(*one ? 1 : -1);
 696 }
 697
 698
 699 pmpkg_t *_alpm_pkg_new(const char *name, const char *version)
 700 {
 701         pmpkg_t* pkg;
 702
 703         ALPM_LOG_FUNC;
 704
 705         CALLOC(pkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
 706
 707         if(name) {
 708                 STRDUP(pkg->name, name, RET_ERR(PM_ERR_MEMORY, pkg));
 709         }
 710
 711         if(version) {
 712                 STRDUP(pkg->version, version, RET_ERR(PM_ERR_MEMORY, pkg));
 713         }
 714
 715         return(pkg);
 716 }
 717
 718 pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
 719 {
 720         pmpkg_t *newpkg;
 721         alpm_list_t *i;
 722
 723         ALPM_LOG_FUNC;
 724
 725         CALLOC(newpkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
 726
 727         STRDUP(newpkg->filename, pkg->filename, RET_ERR(PM_ERR_MEMORY, newpkg));
 728         STRDUP(newpkg->name, pkg->name, RET_ERR(PM_ERR_MEMORY, newpkg));
 729         STRDUP(newpkg->version, pkg->version, RET_ERR(PM_ERR_MEMORY, newpkg));
 730         STRDUP(newpkg->desc, pkg->desc, RET_ERR(PM_ERR_MEMORY, newpkg));
 731         STRDUP(newpkg->url, pkg->url, RET_ERR(PM_ERR_MEMORY, newpkg));
 732         newpkg->builddate = pkg->builddate;
 733         newpkg->installdate = pkg->installdate;
 734         STRDUP(newpkg->packager, pkg->packager, RET_ERR(PM_ERR_MEMORY, newpkg));
 735         STRDUP(newpkg->md5sum, pkg->md5sum, RET_ERR(PM_ERR_MEMORY, newpkg));
 736         STRDUP(newpkg->arch, pkg->arch, RET_ERR(PM_ERR_MEMORY, newpkg));
 737         newpkg->size = pkg->size;
 738         newpkg->isize = pkg->isize;
 739         newpkg->scriptlet = pkg->scriptlet;
 740         newpkg->force = pkg->force;
 741         newpkg->reason = pkg->reason;
 742
 743         newpkg->licenses   = alpm_list_strdup(alpm_pkg_get_licenses(pkg));
 744         newpkg->replaces   = alpm_list_strdup(alpm_pkg_get_replaces(pkg));
 745         newpkg->groups     = alpm_list_strdup(alpm_pkg_get_groups(pkg));
 746         newpkg->files      = alpm_list_strdup(alpm_pkg_get_files(pkg));
 747         newpkg->backup     = alpm_list_strdup(alpm_pkg_get_backup(pkg));
 748         for(i = alpm_pkg_get_depends(pkg); i; i = alpm_list_next(i)) {
 749                 newpkg->depends = alpm_list_add(newpkg->depends, _alpm_dep_dup(i->data));
 750         }
 751         newpkg->optdepends = alpm_list_strdup(alpm_pkg_get_optdepends(pkg));
 752         newpkg->conflicts  = alpm_list_strdup(alpm_pkg_get_conflicts(pkg));
 753         newpkg->provides   = alpm_list_strdup(alpm_pkg_get_provides(pkg));
 754         newpkg->deltas     = alpm_list_copy_data(alpm_pkg_get_deltas(pkg),
 755                                                                                                                                                                          sizeof(pmdelta_t));
 756
 757         /* internal */
 758         newpkg->origin = pkg->origin;
 759         if(newpkg->origin == PKG_FROM_FILE) {
 760                 newpkg->origin_data.file = strdup(pkg->origin_data.file);
 761         } else {
 762                 newpkg->origin_data.db = pkg->origin_data.db;
 763         }
 764         newpkg->infolevel = pkg->infolevel;
 765
 766         return(newpkg);
 767 }
 768
 769 void _alpm_pkg_free(pmpkg_t *pkg)
 770 {
 771         ALPM_LOG_FUNC;
 772
 773         if(pkg == NULL) {
 774                 return;
 775         }
 776
 777         FREE(pkg->filename);
 778         FREE(pkg->name);
 779         FREE(pkg->version);
 780         FREE(pkg->desc);
 781         FREE(pkg->url);
 782         FREE(pkg->packager);
 783         FREE(pkg->md5sum);
 784         FREE(pkg->arch);
 785         FREELIST(pkg->licenses);
 786         FREELIST(pkg->replaces);
 787         FREELIST(pkg->groups);
 788         FREELIST(pkg->files);
 789         FREELIST(pkg->backup);
 790         alpm_list_free_inner(pkg->depends, (alpm_list_fn_free)_alpm_dep_free);
 791         alpm_list_free(pkg->depends);
 792         FREELIST(pkg->optdepends);
 793         FREELIST(pkg->conflicts);
 794         FREELIST(pkg->provides);
 795         alpm_list_free_inner(pkg->deltas, (alpm_list_fn_free)_alpm_delta_free);
 796         alpm_list_free(pkg->deltas);
 797         alpm_list_free(pkg->delta_path);
 798
 799         if(pkg->origin == PKG_FROM_FILE) {
 800                 FREE(pkg->origin_data.file);
 801         }
 802         FREE(pkg);
 803 }
 804
 805 /* Is pkgB an upgrade for pkgA ? */
 806 int _alpm_pkg_compare_versions(pmpkg_t *local_pkg, pmpkg_t *pkg)
 807 {
 808         int cmp = 0;
 809
 810         ALPM_LOG_FUNC;
 811
 812         if(pkg->origin == PKG_FROM_CACHE) {
 813                 /* ensure we have the /desc file, which contains the 'force' option */
 814                 _alpm_db_read(pkg->origin_data.db, pkg, INFRQ_DESC);
 815         }
 816
 817         /* compare versions and see if we need to upgrade */
 818         cmp = _alpm_versioncmp(alpm_pkg_get_version(pkg), alpm_pkg_get_version(local_pkg));
 819
 820         if(cmp != 0 && pkg->force) {
 821                 cmp = 1;
 822                 _alpm_log(PM_LOG_WARNING, _("%s: forcing upgrade to version %s\n"),
 823                                                         alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
 824         } else if(cmp < 0) {
 825                 /* local version is newer */
 826                 pmdb_t *db = pkg->origin_data.db;
 827                 _alpm_log(PM_LOG_WARNING, _("%s: local (%s) is newer than %s (%s)\n"),
 828                                                         alpm_pkg_get_name(local_pkg), alpm_pkg_get_version(local_pkg),
 829                                                         alpm_db_get_name(db), alpm_pkg_get_version(pkg));
 830                 cmp = 0;
 831         }
 832
 833         return(cmp);
 834 }
 835
 836 /* Helper function for comparing packages
 837  */
 838 int _alpm_pkg_cmp(const void *p1, const void *p2)
 839 {
 840         pmpkg_t *pk1 = (pmpkg_t *)p1;
 841         pmpkg_t *pk2 = (pmpkg_t *)p2;
 842
 843         return(strcmp(alpm_pkg_get_name(pk1), alpm_pkg_get_name(pk2)));
 844 }
 845
 846 int _alpm_pkgname_pkg_cmp(const void *pkgname, const void *package)
 847 {
 848         return(strcmp(alpm_pkg_get_name((pmpkg_t *) package), (char *) pkgname));
 849 }
 850
 851 /* Test for existence of a package in a alpm_list_t*
 852  * of pmpkg_t*
 853  */
 854 pmpkg_t *_alpm_pkg_find(const char *needle, alpm_list_t *haystack)
 855 {
 856         alpm_list_t *lp;
 857
 858         ALPM_LOG_FUNC;
 859
 860         if(needle == NULL || haystack == NULL) {
 861                 return(NULL);
 862         }
 863
 864         for(lp = haystack; lp; lp = lp->next) {
 865                 pmpkg_t *info = lp->data;
 866
 867                 if(info && strcmp(alpm_pkg_get_name(info), needle) == 0) {
 868                         return(info);
 869                 }
 870         }
 871         return(NULL);
 872 }
 873
 874 /** Test if a package should be ignored.
 875  *
 876  * Checks if the package is ignored via IgnorePkg, or if the package is
 877  * in a group ignored via IgnoreGrp.
 878  *
 879  * @param pkg the package to test
 880  *
 881  * @return 1 if the package should be ignored, 0 otherwise
 882  */
 883 int _alpm_pkg_should_ignore(pmpkg_t *pkg)
 884 {
 885         alpm_list_t *groups = NULL;
 886
 887         /* first see if the package is ignored */
 888         if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(pkg))) {
 889                 return(1);
 890         }
 891
 892         /* next see if the package is in a group that is ignored */
 893         for(groups = handle->ignoregrp; groups; groups = alpm_list_next(groups)) {
 894                 char *grp = (char *)alpm_list_getdata(groups);
 895                 if(alpm_list_find_str(alpm_pkg_get_groups(pkg), grp)) {
 896                         return(1);
 897                 }
 898         }
 899
 900         return(0);
 901 }
 902
 903 /* vim: set ts=2 sw=2 noet: */