4 * Copyright (c) 2006-2013 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/>.
32 #include "alpm_list.h"
40 /** \addtogroup alpm_databases Database Functions
41 * @brief Functions to query and manipulate the database of libalpm
45 /** Register a sync database of packages. */
46 alpm_db_t SYMEXPORT
*alpm_register_syncdb(alpm_handle_t
*handle
,
47 const char *treename
, alpm_siglevel_t level
)
50 CHECK_HANDLE(handle
, return NULL
);
51 ASSERT(treename
!= NULL
&& strlen(treename
) != 0,
52 RET_ERR(handle
, ALPM_ERR_WRONG_ARGS
, NULL
));
53 /* Do not register a database if a transaction is on-going */
54 ASSERT(handle
->trans
== NULL
, RET_ERR(handle
, ALPM_ERR_TRANS_NOT_NULL
, NULL
));
56 return _alpm_db_register_sync(handle
, treename
, level
);
59 /* Helper function for alpm_db_unregister{_all} */
60 void _alpm_db_unregister(alpm_db_t
*db
)
66 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "unregistering database '%s'\n", db
->treename
);
70 /** Unregister all package databases. */
71 int SYMEXPORT
alpm_unregister_all_syncdbs(alpm_handle_t
*handle
)
77 CHECK_HANDLE(handle
, return -1);
78 /* Do not unregister a database if a transaction is on-going */
79 ASSERT(handle
->trans
== NULL
, RET_ERR(handle
, ALPM_ERR_TRANS_NOT_NULL
, -1));
81 /* unregister all sync dbs */
82 for(i
= handle
->dbs_sync
; i
; i
= i
->next
) {
84 db
->ops
->unregister(db
);
87 FREELIST(handle
->dbs_sync
);
91 /** Unregister a package database. */
92 int SYMEXPORT
alpm_db_unregister(alpm_db_t
*db
)
95 alpm_handle_t
*handle
;
98 ASSERT(db
!= NULL
, return -1);
99 /* Do not unregister a database if a transaction is on-going */
101 handle
->pm_errno
= 0;
102 ASSERT(handle
->trans
== NULL
, RET_ERR(handle
, ALPM_ERR_TRANS_NOT_NULL
, -1));
104 if(db
== handle
->db_local
) {
105 handle
->db_local
= NULL
;
108 /* Warning : this function shouldn't be used to unregister all sync
109 * databases by walking through the list returned by
110 * alpm_get_syncdbs, because the db is removed from that list here.
113 handle
->dbs_sync
= alpm_list_remove(handle
->dbs_sync
,
114 db
, _alpm_db_cmp
, &data
);
121 RET_ERR(handle
, ALPM_ERR_DB_NOT_FOUND
, -1);
124 db
->ops
->unregister(db
);
128 /** Get the serverlist of a database. */
129 alpm_list_t SYMEXPORT
*alpm_db_get_servers(const alpm_db_t
*db
)
131 ASSERT(db
!= NULL
, return NULL
);
135 /** Set the serverlist of a database. */
136 int SYMEXPORT
alpm_db_set_servers(alpm_db_t
*db
, alpm_list_t
*servers
)
138 ASSERT(db
!= NULL
, return -1);
139 FREELIST(db
->servers
);
140 db
->servers
= servers
;
144 static char *sanitize_url(const char *url
)
147 size_t len
= strlen(url
);
149 STRDUP(newurl
, url
, return NULL
);
150 /* strip the trailing slash if one exists */
151 if(newurl
[len
- 1] == '/') {
152 newurl
[len
- 1] = '\0';
157 /** Add a download server to a database.
158 * @param db database pointer
159 * @param url url of the server
160 * @return 0 on success, -1 on error (pm_errno is set accordingly)
162 int SYMEXPORT
alpm_db_add_server(alpm_db_t
*db
, const char *url
)
167 ASSERT(db
!= NULL
, return -1);
168 db
->handle
->pm_errno
= 0;
169 ASSERT(url
!= NULL
&& strlen(url
) != 0, RET_ERR(db
->handle
, ALPM_ERR_WRONG_ARGS
, -1));
171 newurl
= sanitize_url(url
);
175 db
->servers
= alpm_list_add(db
->servers
, newurl
);
176 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "adding new server URL to database '%s': %s\n",
177 db
->treename
, newurl
);
182 /** Remove a download server from a database.
183 * @param db database pointer
184 * @param url url of the server
185 * @return 0 on success, 1 on server not present,
186 * -1 on error (pm_errno is set accordingly)
188 int SYMEXPORT
alpm_db_remove_server(alpm_db_t
*db
, const char *url
)
190 char *newurl
, *vdata
= NULL
;
194 ASSERT(db
!= NULL
, return -1);
195 db
->handle
->pm_errno
= 0;
196 ASSERT(url
!= NULL
&& strlen(url
) != 0, RET_ERR(db
->handle
, ALPM_ERR_WRONG_ARGS
, -1));
198 newurl
= sanitize_url(url
);
203 db
->servers
= alpm_list_remove_str(db
->servers
, newurl
, &vdata
);
206 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "removed server URL from database '%s': %s\n",
207 db
->treename
, newurl
);
216 /** Get the name of a package database. */
217 const char SYMEXPORT
*alpm_db_get_name(const alpm_db_t
*db
)
219 ASSERT(db
!= NULL
, return NULL
);
223 /** Get the signature verification level for a database. */
224 alpm_siglevel_t SYMEXPORT
alpm_db_get_siglevel(alpm_db_t
*db
)
226 ASSERT(db
!= NULL
, return -1);
227 if(db
->siglevel
& ALPM_SIG_USE_DEFAULT
) {
228 return db
->handle
->siglevel
;
234 /** Check the validity of a database. */
235 int SYMEXPORT
alpm_db_get_valid(alpm_db_t
*db
)
237 ASSERT(db
!= NULL
, return -1);
238 db
->handle
->pm_errno
= 0;
239 return db
->ops
->validate(db
);
242 /** Get a package entry from a package database. */
243 alpm_pkg_t SYMEXPORT
*alpm_db_get_pkg(alpm_db_t
*db
, const char *name
)
246 ASSERT(db
!= NULL
, return NULL
);
247 db
->handle
->pm_errno
= 0;
248 ASSERT(name
!= NULL
&& strlen(name
) != 0,
249 RET_ERR(db
->handle
, ALPM_ERR_WRONG_ARGS
, NULL
));
251 pkg
= _alpm_db_get_pkgfromcache(db
, name
);
253 RET_ERR(db
->handle
, ALPM_ERR_PKG_NOT_FOUND
, NULL
);
258 /** Get the package cache of a package database. */
259 alpm_list_t SYMEXPORT
*alpm_db_get_pkgcache(alpm_db_t
*db
)
261 ASSERT(db
!= NULL
, return NULL
);
262 db
->handle
->pm_errno
= 0;
263 return _alpm_db_get_pkgcache(db
);
266 /** Get a group entry from a package database. */
267 alpm_group_t SYMEXPORT
*alpm_db_get_group(alpm_db_t
*db
, const char *name
)
269 ASSERT(db
!= NULL
, return NULL
);
270 db
->handle
->pm_errno
= 0;
271 ASSERT(name
!= NULL
&& strlen(name
) != 0,
272 RET_ERR(db
->handle
, ALPM_ERR_WRONG_ARGS
, NULL
));
274 return _alpm_db_get_groupfromcache(db
, name
);
277 /** Get the group cache of a package database. */
278 alpm_list_t SYMEXPORT
*alpm_db_get_groupcache(alpm_db_t
*db
)
280 ASSERT(db
!= NULL
, return NULL
);
281 db
->handle
->pm_errno
= 0;
283 return _alpm_db_get_groupcache(db
);
286 /** Searches a database. */
287 alpm_list_t SYMEXPORT
*alpm_db_search(alpm_db_t
*db
, const alpm_list_t
*needles
)
289 ASSERT(db
!= NULL
, return NULL
);
290 db
->handle
->pm_errno
= 0;
292 return _alpm_db_search(db
, needles
);
298 alpm_db_t
*_alpm_db_new(const char *treename
, int is_local
)
302 CALLOC(db
, 1, sizeof(alpm_db_t
), return NULL
);
303 STRDUP(db
->treename
, treename
, return NULL
);
305 db
->status
|= DB_STATUS_LOCAL
;
307 db
->status
&= ~DB_STATUS_LOCAL
;
313 void _alpm_db_free(alpm_db_t
*db
)
315 /* cleanup pkgcache */
316 _alpm_db_free_pkgcache(db
);
317 /* cleanup server list */
318 FREELIST(db
->servers
);
326 const char *_alpm_db_path(alpm_db_t
*db
)
335 dbpath
= db
->handle
->dbpath
;
337 _alpm_log(db
->handle
, ALPM_LOG_ERROR
, _("database path is undefined\n"));
338 RET_ERR(db
->handle
, ALPM_ERR_DB_OPEN
, NULL
);
341 if(db
->status
& DB_STATUS_LOCAL
) {
342 pathsize
= strlen(dbpath
) + strlen(db
->treename
) + 2;
343 CALLOC(db
->_path
, 1, pathsize
, RET_ERR(db
->handle
, ALPM_ERR_MEMORY
, NULL
));
344 sprintf(db
->_path
, "%s%s/", dbpath
, db
->treename
);
346 pathsize
= strlen(dbpath
) + 5 + strlen(db
->treename
) + 4;
347 CALLOC(db
->_path
, 1, pathsize
, RET_ERR(db
->handle
, ALPM_ERR_MEMORY
, NULL
));
348 /* all sync DBs now reside in the sync/ subdir of the dbpath */
349 sprintf(db
->_path
, "%ssync/%s.db", dbpath
, db
->treename
);
351 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "database path for tree %s set to %s\n",
352 db
->treename
, db
->_path
);
357 int _alpm_db_cmp(const void *d1
, const void *d2
)
359 const alpm_db_t
*db1
= d1
;
360 const alpm_db_t
*db2
= d2
;
361 return strcmp(db1
->treename
, db2
->treename
);
364 alpm_list_t
*_alpm_db_search(alpm_db_t
*db
, const alpm_list_t
*needles
)
366 const alpm_list_t
*i
, *j
, *k
;
367 alpm_list_t
*ret
= NULL
;
368 /* copy the pkgcache- we will free the list var after each needle */
369 alpm_list_t
*list
= alpm_list_copy(_alpm_db_get_pkgcache(db
));
371 for(i
= needles
; i
; i
= i
->next
) {
375 if(i
->data
== NULL
) {
380 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "searching for target '%s'\n", targ
);
382 if(regcomp(®
, targ
, REG_EXTENDED
| REG_NOSUB
| REG_ICASE
| REG_NEWLINE
) != 0) {
383 RET_ERR(db
->handle
, ALPM_ERR_INVALID_REGEX
, NULL
);
386 for(j
= list
; j
; j
= j
->next
) {
387 alpm_pkg_t
*pkg
= j
->data
;
388 const char *matched
= NULL
;
389 const char *name
= pkg
->name
;
390 const char *desc
= alpm_pkg_get_desc(pkg
);
392 /* check name as regex AND as plain text */
393 if(name
&& (regexec(®
, name
, 0, 0, 0) == 0 || strstr(name
, targ
))) {
397 else if(desc
&& regexec(®
, desc
, 0, 0, 0) == 0) {
400 /* TODO: should we be doing this, and should we print something
401 * differently when we do match it since it isn't currently printed? */
404 for(k
= alpm_pkg_get_provides(pkg
); k
; k
= k
->next
) {
405 alpm_depend_t
*provide
= k
->data
;
406 if(regexec(®
, provide
->name
, 0, 0, 0) == 0) {
407 matched
= provide
->name
;
414 for(k
= alpm_pkg_get_groups(pkg
); k
; k
= k
->next
) {
415 if(regexec(®
, k
->data
, 0, 0, 0) == 0) {
422 if(matched
!= NULL
) {
423 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
,
424 "search target '%s' matched '%s'\n", targ
, matched
);
425 ret
= alpm_list_add(ret
, pkg
);
429 /* Free the existing search list, and use the returned list for the
430 * next needle. This allows for AND-based package searching. */
431 alpm_list_free(list
);
439 /* Returns a new package cache from db.
440 * It frees the cache if it already exists.
442 static int load_pkgcache(alpm_db_t
*db
)
444 _alpm_db_free_pkgcache(db
);
446 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "loading package cache for repository '%s'\n",
448 if(db
->ops
->populate(db
) == -1) {
449 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
,
450 "failed to load package cache for repository '%s'\n", db
->treename
);
454 db
->status
|= DB_STATUS_PKGCACHE
;
458 static void free_groupcache(alpm_db_t
*db
)
462 if(db
== NULL
|| !(db
->status
& DB_STATUS_GRPCACHE
)) {
466 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
,
467 "freeing group cache for repository '%s'\n", db
->treename
);
469 for(lg
= db
->grpcache
; lg
; lg
= lg
->next
) {
470 _alpm_group_free(lg
->data
);
473 FREELIST(db
->grpcache
);
474 db
->status
&= ~DB_STATUS_GRPCACHE
;
477 void _alpm_db_free_pkgcache(alpm_db_t
*db
)
479 if(db
== NULL
|| !(db
->status
& DB_STATUS_PKGCACHE
)) {
483 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
,
484 "freeing package cache for repository '%s'\n", db
->treename
);
487 alpm_list_free_inner(db
->pkgcache
->list
,
488 (alpm_list_fn_free
)_alpm_pkg_free
);
489 _alpm_pkghash_free(db
->pkgcache
);
491 db
->status
&= ~DB_STATUS_PKGCACHE
;
496 alpm_pkghash_t
*_alpm_db_get_pkgcache_hash(alpm_db_t
*db
)
502 if(!(db
->status
& DB_STATUS_VALID
)) {
503 RET_ERR(db
->handle
, ALPM_ERR_DB_INVALID
, NULL
);
506 if(!(db
->status
& DB_STATUS_PKGCACHE
)) {
513 alpm_list_t
*_alpm_db_get_pkgcache(alpm_db_t
*db
)
515 alpm_pkghash_t
*hash
= _alpm_db_get_pkgcache_hash(db
);
524 /* "duplicate" pkg then add it to pkgcache */
525 int _alpm_db_add_pkgincache(alpm_db_t
*db
, alpm_pkg_t
*pkg
)
529 if(db
== NULL
|| pkg
== NULL
|| !(db
->status
& DB_STATUS_PKGCACHE
)) {
533 if(_alpm_pkg_dup(pkg
, &newpkg
)) {
537 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "adding entry '%s' in '%s' cache\n",
538 newpkg
->name
, db
->treename
);
539 db
->pkgcache
= _alpm_pkghash_add_sorted(db
->pkgcache
, newpkg
);
546 int _alpm_db_remove_pkgfromcache(alpm_db_t
*db
, alpm_pkg_t
*pkg
)
548 alpm_pkg_t
*data
= NULL
;
550 if(db
== NULL
|| pkg
== NULL
|| !(db
->status
& DB_STATUS_PKGCACHE
)) {
554 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "removing entry '%s' from '%s' cache\n",
555 pkg
->name
, db
->treename
);
557 db
->pkgcache
= _alpm_pkghash_remove(db
->pkgcache
, pkg
, &data
);
559 /* package not found */
560 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "cannot remove entry '%s' from '%s' cache: not found\n",
561 pkg
->name
, db
->treename
);
565 _alpm_pkg_free(data
);
572 alpm_pkg_t
*_alpm_db_get_pkgfromcache(alpm_db_t
*db
, const char *target
)
578 alpm_pkghash_t
*pkgcache
= _alpm_db_get_pkgcache_hash(db
);
583 return _alpm_pkghash_find(pkgcache
, target
);
586 /* Returns a new group cache from db.
588 static int load_grpcache(alpm_db_t
*db
)
596 _alpm_log(db
->handle
, ALPM_LOG_DEBUG
, "loading group cache for repository '%s'\n",
599 for(lp
= _alpm_db_get_pkgcache(db
); lp
; lp
= lp
->next
) {
600 const alpm_list_t
*i
;
601 alpm_pkg_t
*pkg
= lp
->data
;
603 for(i
= alpm_pkg_get_groups(pkg
); i
; i
= i
->next
) {
604 const char *grpname
= i
->data
;
606 alpm_group_t
*grp
= NULL
;
609 /* first look through the group cache for a group with this name */
610 for(j
= db
->grpcache
; j
; j
= j
->next
) {
613 if(strcmp(grp
->name
, grpname
) == 0
614 && !alpm_list_find_ptr(grp
->packages
, pkg
)) {
615 grp
->packages
= alpm_list_add(grp
->packages
, pkg
);
623 /* we didn't find the group, so create a new one with this name */
624 grp
= _alpm_group_new(grpname
);
629 grp
->packages
= alpm_list_add(grp
->packages
, pkg
);
630 db
->grpcache
= alpm_list_add(db
->grpcache
, grp
);
634 db
->status
|= DB_STATUS_GRPCACHE
;
638 alpm_list_t
*_alpm_db_get_groupcache(alpm_db_t
*db
)
644 if(!(db
->status
& DB_STATUS_VALID
)) {
645 RET_ERR(db
->handle
, ALPM_ERR_DB_INVALID
, NULL
);
648 if(!(db
->status
& DB_STATUS_GRPCACHE
)) {
655 alpm_group_t
*_alpm_db_get_groupfromcache(alpm_db_t
*db
, const char *target
)
659 if(db
== NULL
|| target
== NULL
|| strlen(target
) == 0) {
663 for(i
= _alpm_db_get_groupcache(db
); i
; i
= i
->next
) {
664 alpm_group_t
*info
= i
->data
;
666 if(strcmp(info
->name
, target
) == 0) {
674 /* vim: set ts=2 sw=2 noet: */