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>
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.
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.
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/>.
34 #include "alpm_list.h"
42 /** \addtogroup alpm_databases Database Functions
43 * @brief Functions to query and manipulate the database of libalpm
47 /** Register a sync database of packages. */
48 pmdb_t SYMEXPORT
*alpm_db_register_sync(alpm_handle_t
*handle
, const char *treename
,
49 pgp_verify_t check_sig
)
52 CHECK_HANDLE(handle
, return NULL
);
53 ASSERT(treename
!= NULL
&& strlen(treename
) != 0,
54 RET_ERR(handle
, PM_ERR_WRONG_ARGS
, NULL
));
55 /* Do not register a database if a transaction is on-going */
56 ASSERT(handle
->trans
== NULL
, RET_ERR(handle
, PM_ERR_TRANS_NOT_NULL
, NULL
));
58 return _alpm_db_register_sync(handle
, treename
, check_sig
);
61 /* Helper function for alpm_db_unregister{_all} */
62 void _alpm_db_unregister(pmdb_t
*db
)
68 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "unregistering database '%s'\n", db
->treename
);
72 /** Unregister all package databases. */
73 int SYMEXPORT
alpm_db_unregister_all(alpm_handle_t
*handle
)
79 CHECK_HANDLE(handle
, return -1);
80 /* Do not unregister a database if a transaction is on-going */
81 ASSERT(handle
->trans
== NULL
, RET_ERR(handle
, PM_ERR_TRANS_NOT_NULL
, -1));
83 /* unregister all sync dbs */
84 for(i
= handle
->dbs_sync
; i
; i
= i
->next
) {
86 db
->ops
->unregister(db
);
89 FREELIST(handle
->dbs_sync
);
93 /** Unregister a package database. */
94 int SYMEXPORT
alpm_db_unregister(pmdb_t
*db
)
97 alpm_handle_t
*handle
;
100 ASSERT(db
!= NULL
, return -1);
101 /* Do not unregister a database if a transaction is on-going */
103 handle
->pm_errno
= 0;
104 ASSERT(handle
->trans
== NULL
, RET_ERR(handle
, PM_ERR_TRANS_NOT_NULL
, -1));
106 if(db
== handle
->db_local
) {
107 handle
->db_local
= NULL
;
110 /* Warning : this function shouldn't be used to unregister all sync
111 * databases by walking through the list returned by
112 * alpm_option_get_syncdbs, because the db is removed from that list here.
115 handle
->dbs_sync
= alpm_list_remove(handle
->dbs_sync
,
116 db
, _alpm_db_cmp
, &data
);
123 RET_ERR(handle
, PM_ERR_DB_NOT_FOUND
, -1);
126 db
->ops
->unregister(db
);
130 /** Get the serverlist of a database. */
131 alpm_list_t SYMEXPORT
*alpm_db_get_servers(const pmdb_t
*db
)
133 ASSERT(db
!= NULL
, return NULL
);
137 /** Set the serverlist of a database. */
138 int SYMEXPORT
alpm_db_set_servers(pmdb_t
*db
, alpm_list_t
*servers
)
140 ASSERT(db
!= NULL
, return -1);
141 if(db
->servers
) FREELIST(db
->servers
);
142 db
->servers
= servers
;
146 static char *sanitize_url(const char *url
)
149 size_t len
= strlen(url
);
151 STRDUP(newurl
, url
, return NULL
);
152 /* strip the trailing slash if one exists */
153 if(newurl
[len
- 1] == '/') {
154 newurl
[len
- 1] = '\0';
159 /** Add a download server to a database.
160 * @param db database pointer
161 * @param url url of the server
162 * @return 0 on success, -1 on error (pm_errno is set accordingly)
164 int SYMEXPORT
alpm_db_add_server(pmdb_t
*db
, const char *url
)
169 ASSERT(db
!= NULL
, return -1);
170 db
->handle
->pm_errno
= 0;
171 ASSERT(url
!= NULL
&& strlen(url
) != 0, RET_ERR(db
->handle
, PM_ERR_WRONG_ARGS
, -1));
173 newurl
= sanitize_url(url
);
177 db
->servers
= alpm_list_add(db
->servers
, newurl
);
178 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "adding new server URL to database '%s': %s\n",
179 db
->treename
, newurl
);
184 /** Remove a download server from a database.
185 * @param db database pointer
186 * @param url url of the server
187 * @return 0 on success, 1 on server not present,
188 * -1 on error (pm_errno is set accordingly)
190 int SYMEXPORT
alpm_db_remove_server(pmdb_t
*db
, const char *url
)
192 char *newurl
, *vdata
= NULL
;
195 ASSERT(db
!= NULL
, return -1);
196 db
->handle
->pm_errno
= 0;
197 ASSERT(url
!= NULL
&& strlen(url
) != 0, RET_ERR(db
->handle
, PM_ERR_WRONG_ARGS
, -1));
199 newurl
= sanitize_url(url
);
203 db
->servers
= alpm_list_remove_str(db
->servers
, newurl
, &vdata
);
206 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "removed server URL from database '%s': %s\n",
207 db
->treename
, newurl
);
215 /** Get the name of a package database. */
216 const char SYMEXPORT
*alpm_db_get_name(const pmdb_t
*db
)
218 ASSERT(db
!= NULL
, return NULL
);
222 /** Get a package entry from a package database. */
223 pmpkg_t SYMEXPORT
*alpm_db_get_pkg(pmdb_t
*db
, const char *name
)
225 ASSERT(db
!= NULL
, return NULL
);
226 db
->handle
->pm_errno
= 0;
227 ASSERT(name
!= NULL
&& strlen(name
) != 0,
228 RET_ERR(db
->handle
, PM_ERR_WRONG_ARGS
, NULL
));
230 return _alpm_db_get_pkgfromcache(db
, name
);
233 /** Get the package cache of a package database. */
234 alpm_list_t SYMEXPORT
*alpm_db_get_pkgcache(pmdb_t
*db
)
236 ASSERT(db
!= NULL
, return NULL
);
237 db
->handle
->pm_errno
= 0;
238 return _alpm_db_get_pkgcache(db
);
241 /** Get a group entry from a package database. */
242 pmgrp_t SYMEXPORT
*alpm_db_readgrp(pmdb_t
*db
, const char *name
)
244 ASSERT(db
!= NULL
, return NULL
);
245 db
->handle
->pm_errno
= 0;
246 ASSERT(name
!= NULL
&& strlen(name
) != 0,
247 RET_ERR(db
->handle
, PM_ERR_WRONG_ARGS
, NULL
));
249 return _alpm_db_get_grpfromcache(db
, name
);
252 /** Get the group cache of a package database. */
253 alpm_list_t SYMEXPORT
*alpm_db_get_grpcache(pmdb_t
*db
)
255 ASSERT(db
!= NULL
, return NULL
);
256 db
->handle
->pm_errno
= 0;
258 return _alpm_db_get_grpcache(db
);
261 /** Searches a database. */
262 alpm_list_t SYMEXPORT
*alpm_db_search(pmdb_t
*db
, const alpm_list_t
* needles
)
264 ASSERT(db
!= NULL
, return NULL
);
265 db
->handle
->pm_errno
= 0;
267 return _alpm_db_search(db
, needles
);
270 /** Set install reason for a package in db. */
271 int SYMEXPORT
alpm_db_set_pkgreason(pmdb_t
*db
, const char *name
, alpm_pkgreason_t reason
)
273 ASSERT(db
!= NULL
, return -1);
274 db
->handle
->pm_errno
= 0;
275 /* TODO assert db == db_local ? shouldn't need a db param at all here... */
276 ASSERT(name
!= NULL
, RET_ERR(db
->handle
, PM_ERR_WRONG_ARGS
, -1));
278 pmpkg_t
*pkg
= _alpm_db_get_pkgfromcache(db
, name
);
280 RET_ERR(db
->handle
, PM_ERR_PKG_NOT_FOUND
, -1);
283 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "setting install reason %u for %s/%s\n", reason
, db
->treename
, name
);
284 if(alpm_pkg_get_reason(pkg
) == reason
) {
288 /* set reason (in pkgcache) */
289 pkg
->reason
= reason
;
291 if(_alpm_local_db_write(db
, pkg
, INFRQ_DESC
)) {
292 RET_ERR(db
->handle
, PM_ERR_DB_WRITE
, -1);
300 pmdb_t
*_alpm_db_new(const char *treename
, int is_local
)
304 CALLOC(db
, 1, sizeof(pmdb_t
), return NULL
);
305 STRDUP(db
->treename
, treename
, return NULL
);
306 db
->is_local
= is_local
;
307 db
->pgp_verify
= PM_PGP_VERIFY_UNKNOWN
;
312 void _alpm_db_free(pmdb_t
*db
)
314 /* cleanup pkgcache */
315 _alpm_db_free_pkgcache(db
);
316 /* cleanup server list */
317 FREELIST(db
->servers
);
325 const char *_alpm_db_path(pmdb_t
*db
)
334 dbpath
= alpm_option_get_dbpath(db
->handle
);
336 _alpm_log(db
->handle
, PM_LOG_ERROR
, _("database path is undefined\n"));
337 RET_ERR(db
->handle
, PM_ERR_DB_OPEN
, NULL
);
341 pathsize
= strlen(dbpath
) + strlen(db
->treename
) + 2;
342 CALLOC(db
->_path
, 1, pathsize
, RET_ERR(db
->handle
, PM_ERR_MEMORY
, NULL
));
343 sprintf(db
->_path
, "%s%s/", dbpath
, db
->treename
);
345 pathsize
= strlen(dbpath
) + 5 + strlen(db
->treename
) + 4;
346 CALLOC(db
->_path
, 1, pathsize
, RET_ERR(db
->handle
, PM_ERR_MEMORY
, NULL
));
347 /* all sync DBs now reside in the sync/ subdir of the dbpath */
348 sprintf(db
->_path
, "%ssync/%s.db", dbpath
, db
->treename
);
350 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "database path for tree %s set to %s\n",
351 db
->treename
, db
->_path
);
356 char *_alpm_db_sig_path(pmdb_t
*db
)
360 const char *dbfile
= _alpm_db_path(db
);
364 len
= strlen(dbfile
) + strlen(".sig") + 1;
365 CALLOC(sigpath
, len
, sizeof(char), RET_ERR(db
->handle
, PM_ERR_MEMORY
, NULL
));
366 sprintf(sigpath
, "%s.sig", dbfile
);
370 int _alpm_db_cmp(const void *d1
, const void *d2
)
372 pmdb_t
*db1
= (pmdb_t
*)d1
;
373 pmdb_t
*db2
= (pmdb_t
*)d2
;
374 return strcmp(db1
->treename
, db2
->treename
);
377 alpm_list_t
*_alpm_db_search(pmdb_t
*db
, const alpm_list_t
*needles
)
379 const alpm_list_t
*i
, *j
, *k
;
380 alpm_list_t
*ret
= NULL
;
381 /* copy the pkgcache- we will free the list var after each needle */
382 alpm_list_t
*list
= alpm_list_copy(_alpm_db_get_pkgcache(db
));
384 for(i
= needles
; i
; i
= i
->next
) {
388 if(i
->data
== NULL
) {
393 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "searching for target '%s'\n", targ
);
395 if(regcomp(®
, targ
, REG_EXTENDED
| REG_NOSUB
| REG_ICASE
| REG_NEWLINE
) != 0) {
396 RET_ERR(db
->handle
, PM_ERR_INVALID_REGEX
, NULL
);
399 for(j
= list
; j
; j
= j
->next
) {
400 pmpkg_t
*pkg
= j
->data
;
401 const char *matched
= NULL
;
402 const char *name
= alpm_pkg_get_name(pkg
);
403 const char *desc
= alpm_pkg_get_desc(pkg
);
405 /* check name as regex AND as plain text */
406 if(name
&& (regexec(®
, name
, 0, 0, 0) == 0 || strstr(name
, targ
))) {
410 else if(desc
&& regexec(®
, desc
, 0, 0, 0) == 0) {
413 /* TODO: should we be doing this, and should we print something
414 * differently when we do match it since it isn't currently printed? */
417 for(k
= alpm_pkg_get_provides(pkg
); k
; k
= k
->next
) {
418 if(regexec(®
, k
->data
, 0, 0, 0) == 0) {
426 for(k
= alpm_pkg_get_groups(pkg
); k
; k
= k
->next
) {
427 if(regexec(®
, k
->data
, 0, 0, 0) == 0) {
434 if(matched
!= NULL
) {
435 _alpm_log(db
->handle
, PM_LOG_DEBUG
, " search target '%s' matched '%s'\n",
437 ret
= alpm_list_add(ret
, pkg
);
441 /* Free the existing search list, and use the returned list for the
442 * next needle. This allows for AND-based package searching. */
443 alpm_list_free(list
);
451 /* Returns a new package cache from db.
452 * It frees the cache if it already exists.
454 static int load_pkgcache(pmdb_t
*db
)
456 _alpm_db_free_pkgcache(db
);
458 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "loading package cache for repository '%s'\n",
460 if(db
->ops
->populate(db
) == -1) {
461 _alpm_log(db
->handle
, PM_LOG_DEBUG
,
462 "failed to load package cache for repository '%s'\n", db
->treename
);
466 db
->status
|= DB_STATUS_PKGCACHE
;
470 void _alpm_db_free_pkgcache(pmdb_t
*db
)
472 if(db
== NULL
|| !(db
->status
& DB_STATUS_PKGCACHE
)) {
476 _alpm_log(db
->handle
, PM_LOG_DEBUG
,
477 "freeing package cache for repository '%s'\n", db
->treename
);
479 alpm_list_free_inner(_alpm_db_get_pkgcache(db
),
480 (alpm_list_fn_free
)_alpm_pkg_free
);
481 _alpm_pkghash_free(db
->pkgcache
);
482 db
->status
&= ~DB_STATUS_PKGCACHE
;
484 _alpm_db_free_grpcache(db
);
487 pmpkghash_t
*_alpm_db_get_pkgcache_hash(pmdb_t
*db
)
493 if(!(db
->status
& DB_STATUS_VALID
)) {
494 RET_ERR(db
->handle
, PM_ERR_DB_INVALID
, NULL
);
497 if(!(db
->status
& DB_STATUS_PKGCACHE
)) {
504 alpm_list_t
*_alpm_db_get_pkgcache(pmdb_t
*db
)
506 pmpkghash_t
*hash
= _alpm_db_get_pkgcache_hash(db
);
515 /* "duplicate" pkg then add it to pkgcache */
516 int _alpm_db_add_pkgincache(pmdb_t
*db
, pmpkg_t
*pkg
)
520 if(db
== NULL
|| pkg
== NULL
|| !(db
->status
& DB_STATUS_PKGCACHE
)) {
524 newpkg
= _alpm_pkg_dup(pkg
);
529 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "adding entry '%s' in '%s' cache\n",
530 alpm_pkg_get_name(newpkg
), db
->treename
);
531 db
->pkgcache
= _alpm_pkghash_add_sorted(db
->pkgcache
, newpkg
);
533 _alpm_db_free_grpcache(db
);
538 int _alpm_db_remove_pkgfromcache(pmdb_t
*db
, pmpkg_t
*pkg
)
540 pmpkg_t
*data
= NULL
;
542 if(db
== NULL
|| pkg
== NULL
|| !(db
->status
& DB_STATUS_PKGCACHE
)) {
546 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "removing entry '%s' from '%s' cache\n",
547 alpm_pkg_get_name(pkg
), db
->treename
);
549 db
->pkgcache
= _alpm_pkghash_remove(db
->pkgcache
, pkg
, &data
);
551 /* package not found */
552 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "cannot remove entry '%s' from '%s' cache: not found\n",
553 alpm_pkg_get_name(pkg
), db
->treename
);
557 _alpm_pkg_free(data
);
559 _alpm_db_free_grpcache(db
);
564 pmpkg_t
*_alpm_db_get_pkgfromcache(pmdb_t
*db
, const char *target
)
570 pmpkghash_t
*pkgcache
= _alpm_db_get_pkgcache_hash(db
);
575 return _alpm_pkghash_find(pkgcache
, target
);
578 /* Returns a new group cache from db.
580 static int load_grpcache(pmdb_t
*db
)
588 _alpm_log(db
->handle
, PM_LOG_DEBUG
, "loading group cache for repository '%s'\n",
591 for(lp
= _alpm_db_get_pkgcache(db
); lp
; lp
= lp
->next
) {
592 const alpm_list_t
*i
;
593 pmpkg_t
*pkg
= lp
->data
;
595 for(i
= alpm_pkg_get_groups(pkg
); i
; i
= i
->next
) {
596 const char *grpname
= i
->data
;
601 /* first look through the group cache for a group with this name */
602 for(j
= db
->grpcache
; j
; j
= j
->next
) {
605 if(strcmp(grp
->name
, grpname
) == 0
606 && !alpm_list_find_ptr(grp
->packages
, pkg
)) {
607 grp
->packages
= alpm_list_add(grp
->packages
, pkg
);
615 /* we didn't find the group, so create a new one with this name */
616 grp
= _alpm_grp_new(grpname
);
618 _alpm_db_free_grpcache(db
);
621 grp
->packages
= alpm_list_add(grp
->packages
, pkg
);
622 db
->grpcache
= alpm_list_add(db
->grpcache
, grp
);
626 db
->status
|= DB_STATUS_GRPCACHE
;
630 void _alpm_db_free_grpcache(pmdb_t
*db
)
634 if(db
== NULL
|| !(db
->status
& DB_STATUS_GRPCACHE
)) {
638 _alpm_log(db
->handle
, PM_LOG_DEBUG
,
639 "freeing group cache for repository '%s'\n", db
->treename
);
641 for(lg
= db
->grpcache
; lg
; lg
= lg
->next
) {
642 _alpm_grp_free(lg
->data
);
645 FREELIST(db
->grpcache
);
646 db
->status
&= ~DB_STATUS_GRPCACHE
;
649 alpm_list_t
*_alpm_db_get_grpcache(pmdb_t
*db
)
655 if(!(db
->status
& DB_STATUS_VALID
)) {
656 RET_ERR(db
->handle
, PM_ERR_DB_INVALID
, NULL
);
659 if(!(db
->status
& DB_STATUS_GRPCACHE
)) {
666 pmgrp_t
*_alpm_db_get_grpfromcache(pmdb_t
*db
, const char *target
)
670 if(db
== NULL
|| target
== NULL
|| strlen(target
) == 0) {
674 for(i
= _alpm_db_get_grpcache(db
); i
; i
= i
->next
) {
675 pmgrp_t
*info
= i
->data
;
677 if(strcmp(info
->name
, target
) == 0) {
685 /* vim: set ts=2 sw=2 noet: */