4 * Copyright (c) 2006-2012 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>
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.
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.
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/>.
26 #include <sys/types.h>
30 #include "alpm_list.h"
38 /** \addtogroup alpm_packages Package Functions
39 * @brief Functions to manipulate libalpm packages
43 /** Free a package. */
44 int SYMEXPORT
alpm_pkg_free(alpm_pkg_t
*pkg
)
46 ASSERT(pkg
!= NULL
, return -1);
48 /* Only free packages loaded in user space */
49 if(pkg
->origin
== PKG_FROM_FILE
) {
56 /** Check the integrity (with md5) of a package from the sync cache. */
57 int SYMEXPORT
alpm_pkg_checkmd5sum(alpm_pkg_t
*pkg
)
62 ASSERT(pkg
!= NULL
, return -1);
63 pkg
->handle
->pm_errno
= 0;
64 /* We only inspect packages from sync repositories */
65 ASSERT(pkg
->origin
== PKG_FROM_SYNCDB
,
66 RET_ERR(pkg
->handle
, ALPM_ERR_WRONG_ARGS
, -1));
68 fpath
= _alpm_filecache_find(pkg
->handle
, pkg
->filename
);
70 retval
= _alpm_test_checksum(fpath
, pkg
->md5sum
, ALPM_CSUM_MD5
);
74 } else if(retval
== 1) {
75 pkg
->handle
->pm_errno
= ALPM_ERR_PKG_INVALID
;
82 /* Default package accessor functions. These will get overridden by any
83 * backend logic that needs lazy access, such as the local database through
84 * a lazy-load cache. However, the defaults will work just fine for fully-
85 * populated package structures. */
86 static const char *_pkg_get_desc(alpm_pkg_t
*pkg
) { return pkg
->desc
; }
87 static const char *_pkg_get_url(alpm_pkg_t
*pkg
) { return pkg
->url
; }
88 static alpm_time_t
_pkg_get_builddate(alpm_pkg_t
*pkg
) { return pkg
->builddate
; }
89 static alpm_time_t
_pkg_get_installdate(alpm_pkg_t
*pkg
) { return pkg
->installdate
; }
90 static const char *_pkg_get_packager(alpm_pkg_t
*pkg
) { return pkg
->packager
; }
91 static const char *_pkg_get_arch(alpm_pkg_t
*pkg
) { return pkg
->arch
; }
92 static off_t
_pkg_get_isize(alpm_pkg_t
*pkg
) { return pkg
->isize
; }
93 static alpm_pkgreason_t
_pkg_get_reason(alpm_pkg_t
*pkg
) { return pkg
->reason
; }
94 static int _pkg_has_scriptlet(alpm_pkg_t
*pkg
) { return pkg
->scriptlet
; }
96 static alpm_list_t
*_pkg_get_licenses(alpm_pkg_t
*pkg
) { return pkg
->licenses
; }
97 static alpm_list_t
*_pkg_get_groups(alpm_pkg_t
*pkg
) { return pkg
->groups
; }
98 static alpm_list_t
*_pkg_get_depends(alpm_pkg_t
*pkg
) { return pkg
->depends
; }
99 static alpm_list_t
*_pkg_get_optdepends(alpm_pkg_t
*pkg
) { return pkg
->optdepends
; }
100 static alpm_list_t
*_pkg_get_conflicts(alpm_pkg_t
*pkg
) { return pkg
->conflicts
; }
101 static alpm_list_t
*_pkg_get_provides(alpm_pkg_t
*pkg
) { return pkg
->provides
; }
102 static alpm_list_t
*_pkg_get_replaces(alpm_pkg_t
*pkg
) { return pkg
->replaces
; }
103 static alpm_filelist_t
*_pkg_get_files(alpm_pkg_t
*pkg
) { return &(pkg
->files
); }
104 static alpm_list_t
*_pkg_get_backup(alpm_pkg_t
*pkg
) { return pkg
->backup
; }
106 static void *_pkg_changelog_open(alpm_pkg_t UNUSED
*pkg
)
111 static size_t _pkg_changelog_read(void UNUSED
*ptr
, size_t UNUSED size
,
112 const alpm_pkg_t UNUSED
*pkg
, UNUSED
void *fp
)
117 static int _pkg_changelog_close(const alpm_pkg_t UNUSED
*pkg
,
123 static int _pkg_force_load(alpm_pkg_t UNUSED
*pkg
) { return 0; }
125 /** The standard package operations struct. Get fields directly from the
126 * struct itself with no abstraction layer or any type of lazy loading.
128 struct pkg_operations default_pkg_ops
= {
129 .get_desc
= _pkg_get_desc
,
130 .get_url
= _pkg_get_url
,
131 .get_builddate
= _pkg_get_builddate
,
132 .get_installdate
= _pkg_get_installdate
,
133 .get_packager
= _pkg_get_packager
,
134 .get_arch
= _pkg_get_arch
,
135 .get_isize
= _pkg_get_isize
,
136 .get_reason
= _pkg_get_reason
,
137 .has_scriptlet
= _pkg_has_scriptlet
,
139 .get_licenses
= _pkg_get_licenses
,
140 .get_groups
= _pkg_get_groups
,
141 .get_depends
= _pkg_get_depends
,
142 .get_optdepends
= _pkg_get_optdepends
,
143 .get_conflicts
= _pkg_get_conflicts
,
144 .get_provides
= _pkg_get_provides
,
145 .get_replaces
= _pkg_get_replaces
,
146 .get_files
= _pkg_get_files
,
147 .get_backup
= _pkg_get_backup
,
149 .changelog_open
= _pkg_changelog_open
,
150 .changelog_read
= _pkg_changelog_read
,
151 .changelog_close
= _pkg_changelog_close
,
153 .force_load
= _pkg_force_load
,
156 /* Public functions for getting package information. These functions
157 * delegate the hard work to the function callbacks attached to each
158 * package, which depend on where the package was loaded from. */
159 const char SYMEXPORT
*alpm_pkg_get_filename(alpm_pkg_t
*pkg
)
161 ASSERT(pkg
!= NULL
, return NULL
);
162 pkg
->handle
->pm_errno
= 0;
163 return pkg
->filename
;
166 const char SYMEXPORT
*alpm_pkg_get_name(alpm_pkg_t
*pkg
)
168 ASSERT(pkg
!= NULL
, return NULL
);
169 pkg
->handle
->pm_errno
= 0;
173 const char SYMEXPORT
*alpm_pkg_get_version(alpm_pkg_t
*pkg
)
175 ASSERT(pkg
!= NULL
, return NULL
);
176 pkg
->handle
->pm_errno
= 0;
180 alpm_pkgfrom_t SYMEXPORT
alpm_pkg_get_origin(alpm_pkg_t
*pkg
)
182 ASSERT(pkg
!= NULL
, return -1);
183 pkg
->handle
->pm_errno
= 0;
187 const char SYMEXPORT
*alpm_pkg_get_desc(alpm_pkg_t
*pkg
)
189 ASSERT(pkg
!= NULL
, return NULL
);
190 pkg
->handle
->pm_errno
= 0;
191 return pkg
->ops
->get_desc(pkg
);
194 const char SYMEXPORT
*alpm_pkg_get_url(alpm_pkg_t
*pkg
)
196 ASSERT(pkg
!= NULL
, return NULL
);
197 pkg
->handle
->pm_errno
= 0;
198 return pkg
->ops
->get_url(pkg
);
201 alpm_time_t SYMEXPORT
alpm_pkg_get_builddate(alpm_pkg_t
*pkg
)
203 ASSERT(pkg
!= NULL
, return -1);
204 pkg
->handle
->pm_errno
= 0;
205 return pkg
->ops
->get_builddate(pkg
);
208 alpm_time_t SYMEXPORT
alpm_pkg_get_installdate(alpm_pkg_t
*pkg
)
210 ASSERT(pkg
!= NULL
, return -1);
211 pkg
->handle
->pm_errno
= 0;
212 return pkg
->ops
->get_installdate(pkg
);
215 const char SYMEXPORT
*alpm_pkg_get_packager(alpm_pkg_t
*pkg
)
217 ASSERT(pkg
!= NULL
, return NULL
);
218 pkg
->handle
->pm_errno
= 0;
219 return pkg
->ops
->get_packager(pkg
);
222 const char SYMEXPORT
*alpm_pkg_get_md5sum(alpm_pkg_t
*pkg
)
224 ASSERT(pkg
!= NULL
, return NULL
);
225 pkg
->handle
->pm_errno
= 0;
229 const char SYMEXPORT
*alpm_pkg_get_sha256sum(alpm_pkg_t
*pkg
)
231 ASSERT(pkg
!= NULL
, return NULL
);
232 pkg
->handle
->pm_errno
= 0;
233 return pkg
->sha256sum
;
236 const char SYMEXPORT
*alpm_pkg_get_base64_sig(alpm_pkg_t
*pkg
)
238 ASSERT(pkg
!= NULL
, return NULL
);
239 pkg
->handle
->pm_errno
= 0;
240 return pkg
->base64_sig
;
243 const char SYMEXPORT
*alpm_pkg_get_arch(alpm_pkg_t
*pkg
)
245 ASSERT(pkg
!= NULL
, return NULL
);
246 pkg
->handle
->pm_errno
= 0;
247 return pkg
->ops
->get_arch(pkg
);
250 off_t SYMEXPORT
alpm_pkg_get_size(alpm_pkg_t
*pkg
)
252 ASSERT(pkg
!= NULL
, return -1);
253 pkg
->handle
->pm_errno
= 0;
257 off_t SYMEXPORT
alpm_pkg_get_isize(alpm_pkg_t
*pkg
)
259 ASSERT(pkg
!= NULL
, return -1);
260 pkg
->handle
->pm_errno
= 0;
261 return pkg
->ops
->get_isize(pkg
);
264 alpm_pkgreason_t SYMEXPORT
alpm_pkg_get_reason(alpm_pkg_t
*pkg
)
266 ASSERT(pkg
!= NULL
, return -1);
267 pkg
->handle
->pm_errno
= 0;
268 return pkg
->ops
->get_reason(pkg
);
271 alpm_list_t SYMEXPORT
*alpm_pkg_get_licenses(alpm_pkg_t
*pkg
)
273 ASSERT(pkg
!= NULL
, return NULL
);
274 pkg
->handle
->pm_errno
= 0;
275 return pkg
->ops
->get_licenses(pkg
);
278 alpm_list_t SYMEXPORT
*alpm_pkg_get_groups(alpm_pkg_t
*pkg
)
280 ASSERT(pkg
!= NULL
, return NULL
);
281 pkg
->handle
->pm_errno
= 0;
282 return pkg
->ops
->get_groups(pkg
);
285 alpm_list_t SYMEXPORT
*alpm_pkg_get_depends(alpm_pkg_t
*pkg
)
287 ASSERT(pkg
!= NULL
, return NULL
);
288 pkg
->handle
->pm_errno
= 0;
289 return pkg
->ops
->get_depends(pkg
);
292 alpm_list_t SYMEXPORT
*alpm_pkg_get_optdepends(alpm_pkg_t
*pkg
)
294 ASSERT(pkg
!= NULL
, return NULL
);
295 pkg
->handle
->pm_errno
= 0;
296 return pkg
->ops
->get_optdepends(pkg
);
299 alpm_list_t SYMEXPORT
*alpm_pkg_get_conflicts(alpm_pkg_t
*pkg
)
301 ASSERT(pkg
!= NULL
, return NULL
);
302 pkg
->handle
->pm_errno
= 0;
303 return pkg
->ops
->get_conflicts(pkg
);
306 alpm_list_t SYMEXPORT
*alpm_pkg_get_provides(alpm_pkg_t
*pkg
)
308 ASSERT(pkg
!= NULL
, return NULL
);
309 pkg
->handle
->pm_errno
= 0;
310 return pkg
->ops
->get_provides(pkg
);
313 alpm_list_t SYMEXPORT
*alpm_pkg_get_replaces(alpm_pkg_t
*pkg
)
315 ASSERT(pkg
!= NULL
, return NULL
);
316 pkg
->handle
->pm_errno
= 0;
317 return pkg
->ops
->get_replaces(pkg
);
320 alpm_list_t SYMEXPORT
*alpm_pkg_get_deltas(alpm_pkg_t
*pkg
)
322 ASSERT(pkg
!= NULL
, return NULL
);
323 pkg
->handle
->pm_errno
= 0;
327 alpm_filelist_t SYMEXPORT
*alpm_pkg_get_files(alpm_pkg_t
*pkg
)
329 ASSERT(pkg
!= NULL
, return NULL
);
330 pkg
->handle
->pm_errno
= 0;
331 return pkg
->ops
->get_files(pkg
);
334 alpm_list_t SYMEXPORT
*alpm_pkg_get_backup(alpm_pkg_t
*pkg
)
336 ASSERT(pkg
!= NULL
, return NULL
);
337 pkg
->handle
->pm_errno
= 0;
338 return pkg
->ops
->get_backup(pkg
);
341 alpm_db_t SYMEXPORT
*alpm_pkg_get_db(alpm_pkg_t
*pkg
)
344 ASSERT(pkg
!= NULL
, return NULL
);
345 ASSERT(pkg
->origin
!= PKG_FROM_FILE
, return NULL
);
346 pkg
->handle
->pm_errno
= 0;
348 return pkg
->origin_data
.db
;
351 /** Open a package changelog for reading. */
352 void SYMEXPORT
*alpm_pkg_changelog_open(alpm_pkg_t
*pkg
)
354 ASSERT(pkg
!= NULL
, return NULL
);
355 pkg
->handle
->pm_errno
= 0;
356 return pkg
->ops
->changelog_open(pkg
);
359 /** Read data from an open changelog 'file stream'. */
360 size_t SYMEXPORT
alpm_pkg_changelog_read(void *ptr
, size_t size
,
361 const alpm_pkg_t
*pkg
, void *fp
)
363 ASSERT(pkg
!= NULL
, return 0);
364 pkg
->handle
->pm_errno
= 0;
365 return pkg
->ops
->changelog_read(ptr
, size
, pkg
, fp
);
368 /** Close a package changelog for reading. */
369 int SYMEXPORT
alpm_pkg_changelog_close(const alpm_pkg_t
*pkg
, void *fp
)
371 ASSERT(pkg
!= NULL
, return -1);
372 pkg
->handle
->pm_errno
= 0;
373 return pkg
->ops
->changelog_close(pkg
, fp
);
376 int SYMEXPORT
alpm_pkg_has_scriptlet(alpm_pkg_t
*pkg
)
378 ASSERT(pkg
!= NULL
, return -1);
379 pkg
->handle
->pm_errno
= 0;
380 return pkg
->ops
->has_scriptlet(pkg
);
383 static void find_requiredby(alpm_pkg_t
*pkg
, alpm_db_t
*db
, alpm_list_t
**reqs
)
385 const alpm_list_t
*i
;
386 pkg
->handle
->pm_errno
= 0;
388 for(i
= _alpm_db_get_pkgcache(db
); i
; i
= i
->next
) {
389 alpm_pkg_t
*cachepkg
= i
->data
;
391 for(j
= alpm_pkg_get_depends(cachepkg
); j
; j
= j
->next
) {
392 if(_alpm_depcmp(pkg
, j
->data
)) {
393 const char *cachepkgname
= cachepkg
->name
;
394 if(alpm_list_find_str(*reqs
, cachepkgname
) == NULL
) {
395 *reqs
= alpm_list_add(*reqs
, strdup(cachepkgname
));
402 /** Compute the packages requiring a given package. */
403 alpm_list_t SYMEXPORT
*alpm_pkg_compute_requiredby(alpm_pkg_t
*pkg
)
405 const alpm_list_t
*i
;
406 alpm_list_t
*reqs
= NULL
;
409 ASSERT(pkg
!= NULL
, return NULL
);
410 pkg
->handle
->pm_errno
= 0;
412 if(pkg
->origin
== PKG_FROM_FILE
) {
413 /* The sane option; search locally for things that require this. */
414 find_requiredby(pkg
, pkg
->handle
->db_local
, &reqs
);
416 /* We have a DB package. if it is a local package, then we should
417 * only search the local DB; else search all known sync databases. */
418 db
= pkg
->origin_data
.db
;
419 if(db
->status
& DB_STATUS_LOCAL
) {
420 find_requiredby(pkg
, db
, &reqs
);
422 for(i
= pkg
->handle
->dbs_sync
; i
; i
= i
->next
) {
424 find_requiredby(pkg
, db
, &reqs
);
426 reqs
= alpm_list_msort(reqs
, alpm_list_count(reqs
), _alpm_str_cmp
);
434 alpm_file_t
*_alpm_file_copy(alpm_file_t
*dest
,
435 const alpm_file_t
*src
)
437 STRDUP(dest
->name
, src
->name
, return NULL
);
438 dest
->size
= src
->size
;
439 dest
->mode
= src
->mode
;
444 /* Helper function for comparing files list entries
446 int _alpm_files_cmp(const void *f1
, const void *f2
)
448 const alpm_file_t
*file1
= f1
;
449 const alpm_file_t
*file2
= f2
;
450 return strcmp(file1
->name
, file2
->name
);
453 alpm_pkg_t
*_alpm_pkg_new(void)
457 CALLOC(pkg
, 1, sizeof(alpm_pkg_t
), return NULL
);
462 static alpm_list_t
*list_depdup(alpm_list_t
*old
)
464 alpm_list_t
*i
, *new = NULL
;
465 for(i
= old
; i
; i
= i
->next
) {
466 new = alpm_list_add(new, _alpm_dep_dup(i
->data
));
472 * Duplicate a package data struct.
473 * @param pkg the package to duplicate
474 * @param new_ptr location to store duplicated package pointer
475 * @return 0 on success, -1 on fatal error, 1 on non-fatal error
477 int _alpm_pkg_dup(alpm_pkg_t
*pkg
, alpm_pkg_t
**new_ptr
)
483 if(!pkg
|| !pkg
->handle
) {
488 RET_ERR(pkg
->handle
, ALPM_ERR_WRONG_ARGS
, -1);
491 if(pkg
->ops
->force_load(pkg
)) {
492 _alpm_log(pkg
->handle
, ALPM_LOG_WARNING
,
493 _("could not fully load metadata for package %s-%s\n"),
494 pkg
->name
, pkg
->version
);
496 pkg
->handle
->pm_errno
= ALPM_ERR_PKG_INVALID
;
499 CALLOC(newpkg
, 1, sizeof(alpm_pkg_t
), goto cleanup
);
501 newpkg
->name_hash
= pkg
->name_hash
;
502 STRDUP(newpkg
->filename
, pkg
->filename
, goto cleanup
);
503 STRDUP(newpkg
->name
, pkg
->name
, goto cleanup
);
504 STRDUP(newpkg
->version
, pkg
->version
, goto cleanup
);
505 STRDUP(newpkg
->desc
, pkg
->desc
, goto cleanup
);
506 STRDUP(newpkg
->url
, pkg
->url
, goto cleanup
);
507 newpkg
->builddate
= pkg
->builddate
;
508 newpkg
->installdate
= pkg
->installdate
;
509 STRDUP(newpkg
->packager
, pkg
->packager
, goto cleanup
);
510 STRDUP(newpkg
->md5sum
, pkg
->md5sum
, goto cleanup
);
511 STRDUP(newpkg
->sha256sum
, pkg
->md5sum
, goto cleanup
);
512 STRDUP(newpkg
->arch
, pkg
->arch
, goto cleanup
);
513 newpkg
->size
= pkg
->size
;
514 newpkg
->isize
= pkg
->isize
;
515 newpkg
->scriptlet
= pkg
->scriptlet
;
516 newpkg
->reason
= pkg
->reason
;
518 newpkg
->licenses
= alpm_list_strdup(pkg
->licenses
);
519 newpkg
->replaces
= list_depdup(pkg
->replaces
);
520 newpkg
->groups
= alpm_list_strdup(pkg
->groups
);
521 for(i
= pkg
->backup
; i
; i
= i
->next
) {
522 newpkg
->backup
= alpm_list_add(newpkg
->backup
, _alpm_backup_dup(i
->data
));
524 newpkg
->depends
= list_depdup(pkg
->depends
);
525 newpkg
->optdepends
= list_depdup(pkg
->optdepends
);
526 newpkg
->conflicts
= list_depdup(pkg
->conflicts
);
527 newpkg
->provides
= list_depdup(pkg
->provides
);
528 for(i
= pkg
->deltas
; i
; i
= i
->next
) {
529 newpkg
->deltas
= alpm_list_add(newpkg
->deltas
, _alpm_delta_dup(i
->data
));
532 if(pkg
->files
.count
) {
534 size_t len
= sizeof(alpm_file_t
) * pkg
->files
.count
;
535 MALLOC(newpkg
->files
.files
, len
, goto cleanup
);
536 for(filenum
= 0; filenum
< pkg
->files
.count
; filenum
++) {
537 if(!_alpm_file_copy(newpkg
->files
.files
+ filenum
,
538 pkg
->files
.files
+ filenum
)) {
542 newpkg
->files
.count
= pkg
->files
.count
;
546 newpkg
->infolevel
= pkg
->infolevel
;
547 newpkg
->origin
= pkg
->origin
;
548 if(newpkg
->origin
== PKG_FROM_FILE
) {
549 newpkg
->origin_data
.file
= strdup(pkg
->origin_data
.file
);
551 newpkg
->origin_data
.db
= pkg
->origin_data
.db
;
553 newpkg
->ops
= pkg
->ops
;
554 newpkg
->handle
= pkg
->handle
;
560 _alpm_pkg_free(newpkg
);
561 RET_ERR(pkg
->handle
, ALPM_ERR_MEMORY
, -1);
564 static void free_deplist(alpm_list_t
*deps
)
566 alpm_list_free_inner(deps
, (alpm_list_fn_free
)_alpm_dep_free
);
567 alpm_list_free(deps
);
570 void _alpm_pkg_free(alpm_pkg_t
*pkg
)
583 FREE(pkg
->sha256sum
);
584 FREE(pkg
->base64_sig
);
587 FREELIST(pkg
->licenses
);
588 free_deplist(pkg
->replaces
);
589 FREELIST(pkg
->groups
);
590 if(pkg
->files
.count
) {
592 for(i
= 0; i
< pkg
->files
.count
; i
++) {
593 free(pkg
->files
.files
[i
].name
);
595 free(pkg
->files
.files
);
597 alpm_list_free_inner(pkg
->backup
, (alpm_list_fn_free
)_alpm_backup_free
);
598 alpm_list_free(pkg
->backup
);
599 free_deplist(pkg
->depends
);
600 free_deplist(pkg
->optdepends
);
601 free_deplist(pkg
->conflicts
);
602 free_deplist(pkg
->provides
);
603 alpm_list_free_inner(pkg
->deltas
, (alpm_list_fn_free
)_alpm_delta_free
);
604 alpm_list_free(pkg
->deltas
);
605 alpm_list_free(pkg
->delta_path
);
606 alpm_list_free(pkg
->removes
);
608 if(pkg
->origin
== PKG_FROM_FILE
) {
609 FREE(pkg
->origin_data
.file
);
614 /* This function should be used when removing a target from upgrade/sync target list
615 * Case 1: If pkg is a loaded package file (PKG_FROM_FILE), it will be freed.
616 * Case 2: If pkg is a pkgcache entry (PKG_FROM_CACHE), it won't be freed,
617 * only the transaction specific fields of pkg will be freed.
619 void _alpm_pkg_free_trans(alpm_pkg_t
*pkg
)
625 if(pkg
->origin
== PKG_FROM_FILE
) {
630 alpm_list_free(pkg
->removes
);
634 /* Is spkg an upgrade for localpkg? */
635 int _alpm_pkg_compare_versions(alpm_pkg_t
*spkg
, alpm_pkg_t
*localpkg
)
637 return alpm_pkg_vercmp(spkg
->version
, localpkg
->version
);
640 /* Helper function for comparing packages
642 int _alpm_pkg_cmp(const void *p1
, const void *p2
)
644 const alpm_pkg_t
*pkg1
= p1
;
645 const alpm_pkg_t
*pkg2
= p2
;
646 return strcmp(pkg1
->name
, pkg2
->name
);
649 /* Test for existence of a package in a alpm_list_t*
652 alpm_pkg_t
*_alpm_pkg_find(alpm_list_t
*haystack
, const char *needle
)
655 unsigned long needle_hash
;
657 if(needle
== NULL
|| haystack
== NULL
) {
661 needle_hash
= _alpm_hash_sdbm(needle
);
663 for(lp
= haystack
; lp
; lp
= lp
->next
) {
664 alpm_pkg_t
*info
= lp
->data
;
667 if(info
->name_hash
!= needle_hash
) {
671 /* finally: we had hash match, verify string match */
672 if(strcmp(info
->name
, needle
) == 0) {
680 /** Test if a package should be ignored.
682 * Checks if the package is ignored via IgnorePkg, or if the package is
683 * in a group ignored via IgnoreGroup.
685 * @param handle the context handle
686 * @param pkg the package to test
688 * @return 1 if the package should be ignored, 0 otherwise
690 int _alpm_pkg_should_ignore(alpm_handle_t
*handle
, alpm_pkg_t
*pkg
)
692 alpm_list_t
*groups
= NULL
;
694 /* first see if the package is ignored */
695 if(alpm_list_find(handle
->ignorepkg
, pkg
->name
, _alpm_fnmatch
)) {
699 /* next see if the package is in a group that is ignored */
700 for(groups
= alpm_pkg_get_groups(pkg
); groups
; groups
= groups
->next
) {
701 char *grp
= groups
->data
;
702 if(alpm_list_find(handle
->ignoregroup
, grp
, _alpm_fnmatch
)) {
710 /* vim: set ts=2 sw=2 noet: */