?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Prefix alpm_loglevel_t members with ALPM
[pacman-ng.git] / lib / libalpm / db.c
blobb7f0c9a36b3605e0c7bdabc36c1bcfed588e6633
1 /*
2 * db.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 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>
10 *
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.
15 *
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.
20 *
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/>.
23 */
24
25 #include "config.h"
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <regex.h>
31
32 /* libalpm */
33 #include "db.h"
34 #include "alpm_list.h"
35 #include "log.h"
36 #include "util.h"
37 #include "handle.h"
38 #include "alpm.h"
39 #include "package.h"
40 #include "group.h"
41
42 /** \addtogroup alpm_databases Database Functions
43 * @brief Functions to query and manipulate the database of libalpm
44 * @{
45 */
46
47 /** Register a sync database of packages. */
48 alpm_db_t SYMEXPORT *alpm_db_register_sync(alpm_handle_t *handle, const char *treename,
49 pgp_verify_t check_sig)
50 {
51 /* Sanity checks */
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));
57
58 return _alpm_db_register_sync(handle, treename, check_sig);
59 }
60
61 /* Helper function for alpm_db_unregister{_all} */
62 void _alpm_db_unregister(alpm_db_t *db)
63 {
64 if(db == NULL) {
65 return;
66 }
67
68 _alpm_log(db->handle, ALPM_LOG_DEBUG, "unregistering database '%s'\n", db->treename);
69 _alpm_db_free(db);
70 }
71
72 /** Unregister all package databases. */
73 int SYMEXPORT alpm_db_unregister_all(alpm_handle_t *handle)
74 {
75 alpm_list_t *i;
76 alpm_db_t *db;
77
78 /* Sanity checks */
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));
82
83 /* unregister all sync dbs */
84 for(i = handle->dbs_sync; i; i = i->next) {
85 db = i->data;
86 db->ops->unregister(db);
87 i->data = NULL;
88 }
89 FREELIST(handle->dbs_sync);
90 return 0;
91 }
92
93 /** Unregister a package database. */
94 int SYMEXPORT alpm_db_unregister(alpm_db_t *db)
95 {
96 int found = 0;
97 alpm_handle_t *handle;
98
99 /* Sanity checks */
100 ASSERT(db != NULL, return -1);
101 /* Do not unregister a database if a transaction is on-going */
102 handle = db->handle;
103 handle->pm_errno = 0;
104 ASSERT(handle->trans == NULL, RET_ERR(handle, PM_ERR_TRANS_NOT_NULL, -1));
105
106 if(db == handle->db_local) {
107 handle->db_local = NULL;
108 found = 1;
109 } else {
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.
113 */
114 void *data;
115 handle->dbs_sync = alpm_list_remove(handle->dbs_sync,
116 db, _alpm_db_cmp, &data);
117 if(data) {
118 found = 1;
119 }
120 }
121
122 if(!found) {
123 RET_ERR(handle, PM_ERR_DB_NOT_FOUND, -1);
124 }
125
126 db->ops->unregister(db);
127 return 0;
128 }
129
130 /** Get the serverlist of a database. */
131 alpm_list_t SYMEXPORT *alpm_db_get_servers(const alpm_db_t *db)
132 {
133 ASSERT(db != NULL, return NULL);
134 return db->servers;
135 }
136
137 /** Set the serverlist of a database. */
138 int SYMEXPORT alpm_db_set_servers(alpm_db_t *db, alpm_list_t *servers)
139 {
140 ASSERT(db != NULL, return -1);
141 if(db->servers) FREELIST(db->servers);
142 db->servers = servers;
143 return 0;
144 }
145
146 static char *sanitize_url(const char *url)
147 {
148 char *newurl;
149 size_t len = strlen(url);
150
151 STRDUP(newurl, url, return NULL);
152 /* strip the trailing slash if one exists */
153 if(newurl[len - 1] == '/') {
154 newurl[len - 1] = '\0';
155 }
156 return newurl;
157 }
158
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)
163 */
164 int SYMEXPORT alpm_db_add_server(alpm_db_t *db, const char *url)
165 {
166 char *newurl;
167
168 /* Sanity checks */
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));
172
173 newurl = sanitize_url(url);
174 if(!newurl) {
175 return -1;
176 }
177 db->servers = alpm_list_add(db->servers, newurl);
178 _alpm_log(db->handle, ALPM_LOG_DEBUG, "adding new server URL to database '%s': %s\n",
179 db->treename, newurl);
180
181 return 0;
182 }
183
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)
189 */
190 int SYMEXPORT alpm_db_remove_server(alpm_db_t *db, const char *url)
191 {
192 char *newurl, *vdata = NULL;
193
194 /* Sanity checks */
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));
198
199 newurl = sanitize_url(url);
200 if(!newurl) {
201 return -1;
202 }
203 db->servers = alpm_list_remove_str(db->servers, newurl, &vdata);
204 free(newurl);
205 if(vdata) {
206 _alpm_log(db->handle, ALPM_LOG_DEBUG, "removed server URL from database '%s': %s\n",
207 db->treename, newurl);
208 free(vdata);
209 return 0;
210 }
211
212 return 1;
213 }
214
215 /** Get the name of a package database. */
216 const char SYMEXPORT *alpm_db_get_name(const alpm_db_t *db)
217 {
218 ASSERT(db != NULL, return NULL);
219 return db->treename;
220 }
221
222 /** Get the signature verification level for a database. */
223 pgp_verify_t SYMEXPORT alpm_db_get_sigverify_level(alpm_db_t *db)
224 {
225 ASSERT(db != NULL, return -1);
226 if(db->pgp_verify == PM_PGP_VERIFY_UNKNOWN) {
227 return alpm_option_get_default_sigverify(db->handle);
228 } else {
229 return db->pgp_verify;
230 }
231 }
232
233 /** Check the validity of a database. */
234 int SYMEXPORT alpm_db_get_valid(alpm_db_t *db)
235 {
236 ASSERT(db != NULL, return -1);
237 db->handle->pm_errno = 0;
238 return db->ops->validate(db);
239 }
240
241 /** Get a package entry from a package database. */
242 alpm_pkg_t SYMEXPORT *alpm_db_get_pkg(alpm_db_t *db, const char *name)
243 {
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));
248
249 return _alpm_db_get_pkgfromcache(db, name);
250 }
251
252 /** Get the package cache of a package database. */
253 alpm_list_t SYMEXPORT *alpm_db_get_pkgcache(alpm_db_t *db)
254 {
255 ASSERT(db != NULL, return NULL);
256 db->handle->pm_errno = 0;
257 return _alpm_db_get_pkgcache(db);
258 }
259
260 /** Get a group entry from a package database. */
261 alpm_group_t SYMEXPORT *alpm_db_readgroup(alpm_db_t *db, const char *name)
262 {
263 ASSERT(db != NULL, return NULL);
264 db->handle->pm_errno = 0;
265 ASSERT(name != NULL && strlen(name) != 0,
266 RET_ERR(db->handle, PM_ERR_WRONG_ARGS, NULL));
267
268 return _alpm_db_get_groupfromcache(db, name);
269 }
270
271 /** Get the group cache of a package database. */
272 alpm_list_t SYMEXPORT *alpm_db_get_groupcache(alpm_db_t *db)
273 {
274 ASSERT(db != NULL, return NULL);
275 db->handle->pm_errno = 0;
276
277 return _alpm_db_get_groupcache(db);
278 }
279
280 /** Searches a database. */
281 alpm_list_t SYMEXPORT *alpm_db_search(alpm_db_t *db, const alpm_list_t* needles)
282 {
283 ASSERT(db != NULL, return NULL);
284 db->handle->pm_errno = 0;
285
286 return _alpm_db_search(db, needles);
287 }
288
289 /** Set install reason for a package in db. */
290 int SYMEXPORT alpm_db_set_pkgreason(alpm_db_t *db, const char *name, alpm_pkgreason_t reason)
291 {
292 ASSERT(db != NULL, return -1);
293 db->handle->pm_errno = 0;
294 /* TODO assert db == db_local ? shouldn't need a db param at all here... */
295 ASSERT(name != NULL, RET_ERR(db->handle, PM_ERR_WRONG_ARGS, -1));
296
297 alpm_pkg_t *pkg = _alpm_db_get_pkgfromcache(db, name);
298 if(pkg == NULL) {
299 RET_ERR(db->handle, PM_ERR_PKG_NOT_FOUND, -1);
300 }
301
302 _alpm_log(db->handle, ALPM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
303 if(alpm_pkg_get_reason(pkg) == reason) {
304 /* we are done */
305 return 0;
306 }
307 /* set reason (in pkgcache) */
308 pkg->reason = reason;
309 /* write DESC */
310 if(_alpm_local_db_write(db, pkg, INFRQ_DESC)) {
311 RET_ERR(db->handle, PM_ERR_DB_WRITE, -1);
312 }
313
314 return 0;
315 }
316
317 /** @} */
318
319 alpm_db_t *_alpm_db_new(const char *treename, int is_local)
320 {
321 alpm_db_t *db;
322
323 CALLOC(db, 1, sizeof(alpm_db_t), return NULL);
324 STRDUP(db->treename, treename, return NULL);
325 db->is_local = is_local;
326 db->pgp_verify = PM_PGP_VERIFY_UNKNOWN;
327
328 return db;
329 }
330
331 void _alpm_db_free(alpm_db_t *db)
332 {
333 /* cleanup pkgcache */
334 _alpm_db_free_pkgcache(db);
335 /* cleanup server list */
336 FREELIST(db->servers);
337 FREE(db->_path);
338 FREE(db->treename);
339 FREE(db);
340
341 return;
342 }
343
344 const char *_alpm_db_path(alpm_db_t *db)
345 {
346 if(!db) {
347 return NULL;
348 }
349 if(!db->_path) {
350 const char *dbpath;
351 size_t pathsize;
352
353 dbpath = alpm_option_get_dbpath(db->handle);
354 if(!dbpath) {
355 _alpm_log(db->handle, ALPM_LOG_ERROR, _("database path is undefined\n"));
356 RET_ERR(db->handle, PM_ERR_DB_OPEN, NULL);
357 }
358
359 if(db->is_local) {
360 pathsize = strlen(dbpath) + strlen(db->treename) + 2;
361 CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
362 sprintf(db->_path, "%s%s/", dbpath, db->treename);
363 } else {
364 pathsize = strlen(dbpath) + 5 + strlen(db->treename) + 4;
365 CALLOC(db->_path, 1, pathsize, RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
366 /* all sync DBs now reside in the sync/ subdir of the dbpath */
367 sprintf(db->_path, "%ssync/%s.db", dbpath, db->treename);
368 }
369 _alpm_log(db->handle, ALPM_LOG_DEBUG, "database path for tree %s set to %s\n",
370 db->treename, db->_path);
371 }
372 return db->_path;
373 }
374
375 char *_alpm_db_sig_path(alpm_db_t *db)
376 {
377 char *sigpath;
378 size_t len;
379 const char *dbfile = _alpm_db_path(db);
380 if(!db || !dbfile) {
381 return NULL;
382 }
383 len = strlen(dbfile) + strlen(".sig") + 1;
384 CALLOC(sigpath, len, sizeof(char), RET_ERR(db->handle, PM_ERR_MEMORY, NULL));
385 sprintf(sigpath, "%s.sig", dbfile);
386 return sigpath;
387 }
388
389 int _alpm_db_cmp(const void *d1, const void *d2)
390 {
391 alpm_db_t *db1 = (alpm_db_t *)d1;
392 alpm_db_t *db2 = (alpm_db_t *)d2;
393 return strcmp(db1->treename, db2->treename);
394 }
395
396 alpm_list_t *_alpm_db_search(alpm_db_t *db, const alpm_list_t *needles)
397 {
398 const alpm_list_t *i, *j, *k;
399 alpm_list_t *ret = NULL;
400 /* copy the pkgcache- we will free the list var after each needle */
401 alpm_list_t *list = alpm_list_copy(_alpm_db_get_pkgcache(db));
402
403 for(i = needles; i; i = i->next) {
404 char *targ;
405 regex_t reg;
406
407 if(i->data == NULL) {
408 continue;
409 }
410 ret = NULL;
411 targ = i->data;
412 _alpm_log(db->handle, ALPM_LOG_DEBUG, "searching for target '%s'\n", targ);
413
414 if(regcomp(&reg, targ, REG_EXTENDED | REG_NOSUB | REG_ICASE | REG_NEWLINE) != 0) {
415 RET_ERR(db->handle, PM_ERR_INVALID_REGEX, NULL);
416 }
417
418 for(j = list; j; j = j->next) {
419 alpm_pkg_t *pkg = j->data;
420 const char *matched = NULL;
421 const char *name = alpm_pkg_get_name(pkg);
422 const char *desc = alpm_pkg_get_desc(pkg);
423
424 /* check name as regex AND as plain text */
425 if(name && (regexec(&reg, name, 0, 0, 0) == 0 || strstr(name, targ))) {
426 matched = name;
427 }
428 /* check desc */
429 else if(desc && regexec(&reg, desc, 0, 0, 0) == 0) {
430 matched = desc;
431 }
432 /* TODO: should we be doing this, and should we print something
433 * differently when we do match it since it isn't currently printed? */
434 if(!matched) {
435 /* check provides */
436 for(k = alpm_pkg_get_provides(pkg); k; k = k->next) {
437 if(regexec(&reg, k->data, 0, 0, 0) == 0) {
438 matched = k->data;
439 break;
440 }
441 }
442 }
443 if(!matched) {
444 /* check groups */
445 for(k = alpm_pkg_get_groups(pkg); k; k = k->next) {
446 if(regexec(&reg, k->data, 0, 0, 0) == 0) {
447 matched = k->data;
448 break;
449 }
450 }
451 }
452
453 if(matched != NULL) {
454 _alpm_log(db->handle, ALPM_LOG_DEBUG, " search target '%s' matched '%s'\n",
455 targ, matched);
456 ret = alpm_list_add(ret, pkg);
457 }
458 }
459
460 /* Free the existing search list, and use the returned list for the
461 * next needle. This allows for AND-based package searching. */
462 alpm_list_free(list);
463 list = ret;
464 regfree(&reg);
465 }
466
467 return ret;
468 }
469
470 /* Returns a new package cache from db.
471 * It frees the cache if it already exists.
472 */
473 static int load_pkgcache(alpm_db_t *db)
474 {
475 _alpm_db_free_pkgcache(db);
476
477 _alpm_log(db->handle, ALPM_LOG_DEBUG, "loading package cache for repository '%s'\n",
478 db->treename);
479 if(db->ops->populate(db) == -1) {
480 _alpm_log(db->handle, ALPM_LOG_DEBUG,
481 "failed to load package cache for repository '%s'\n", db->treename);
482 return -1;
483 }
484
485 db->status |= DB_STATUS_PKGCACHE;
486 return 0;
487 }
488
489 void _alpm_db_free_pkgcache(alpm_db_t *db)
490 {
491 if(db == NULL || !(db->status & DB_STATUS_PKGCACHE)) {
492 return;
493 }
494
495 _alpm_log(db->handle, ALPM_LOG_DEBUG,
496 "freeing package cache for repository '%s'\n", db->treename);
497
498 alpm_list_free_inner(_alpm_db_get_pkgcache(db),
499 (alpm_list_fn_free)_alpm_pkg_free);
500 _alpm_pkghash_free(db->pkgcache);
501 db->status &= ~DB_STATUS_PKGCACHE;
502
503 _alpm_db_free_groupcache(db);
504 }
505
506 alpm_pkghash_t *_alpm_db_get_pkgcache_hash(alpm_db_t *db)
507 {
508 if(db == NULL) {
509 return NULL;
510 }
511
512 if(!(db->status & DB_STATUS_VALID)) {
513 RET_ERR(db->handle, PM_ERR_DB_INVALID, NULL);
514 }
515
516 if(!(db->status & DB_STATUS_PKGCACHE)) {
517 load_pkgcache(db);
518 }
519
520 return db->pkgcache;
521 }
522
523 alpm_list_t *_alpm_db_get_pkgcache(alpm_db_t *db)
524 {
525 alpm_pkghash_t *hash = _alpm_db_get_pkgcache_hash(db);
526
527 if(hash == NULL) {
528 return NULL;
529 }
530
531 return hash->list;
532 }
533
534 /* "duplicate" pkg then add it to pkgcache */
535 int _alpm_db_add_pkgincache(alpm_db_t *db, alpm_pkg_t *pkg)
536 {
537 alpm_pkg_t *newpkg;
538
539 if(db == NULL || pkg == NULL || !(db->status & DB_STATUS_PKGCACHE)) {
540 return -1;
541 }
542
543 newpkg = _alpm_pkg_dup(pkg);
544 if(newpkg == NULL) {
545 return -1;
546 }
547
548 _alpm_log(db->handle, ALPM_LOG_DEBUG, "adding entry '%s' in '%s' cache\n",
549 alpm_pkg_get_name(newpkg), db->treename);
550 db->pkgcache = _alpm_pkghash_add_sorted(db->pkgcache, newpkg);
551
552 _alpm_db_free_groupcache(db);
553
554 return 0;
555 }
556
557 int _alpm_db_remove_pkgfromcache(alpm_db_t *db, alpm_pkg_t *pkg)
558 {
559 alpm_pkg_t *data = NULL;
560
561 if(db == NULL || pkg == NULL || !(db->status & DB_STATUS_PKGCACHE)) {
562 return -1;
563 }
564
565 _alpm_log(db->handle, ALPM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
566 alpm_pkg_get_name(pkg), db->treename);
567
568 db->pkgcache = _alpm_pkghash_remove(db->pkgcache, pkg, &data);
569 if(data == NULL) {
570 /* package not found */
571 _alpm_log(db->handle, ALPM_LOG_DEBUG, "cannot remove entry '%s' from '%s' cache: not found\n",
572 alpm_pkg_get_name(pkg), db->treename);
573 return -1;
574 }
575
576 _alpm_pkg_free(data);
577
578 _alpm_db_free_groupcache(db);
579
580 return 0;
581 }
582
583 alpm_pkg_t *_alpm_db_get_pkgfromcache(alpm_db_t *db, const char *target)
584 {
585 if(db == NULL) {
586 return NULL;
587 }
588
589 alpm_pkghash_t *pkgcache = _alpm_db_get_pkgcache_hash(db);
590 if(!pkgcache) {
591 return NULL;
592 }
593
594 return _alpm_pkghash_find(pkgcache, target);
595 }
596
597 /* Returns a new group cache from db.
598 */
599 static int load_grpcache(alpm_db_t *db)
600 {
601 alpm_list_t *lp;
602
603 if(db == NULL) {
604 return -1;
605 }
606
607 _alpm_log(db->handle, ALPM_LOG_DEBUG, "loading group cache for repository '%s'\n",
608 db->treename);
609
610 for(lp = _alpm_db_get_pkgcache(db); lp; lp = lp->next) {
611 const alpm_list_t *i;
612 alpm_pkg_t *pkg = lp->data;
613
614 for(i = alpm_pkg_get_groups(pkg); i; i = i->next) {
615 const char *grpname = i->data;
616 alpm_list_t *j;
617 alpm_group_t *grp = NULL;
618 int found = 0;
619
620 /* first look through the group cache for a group with this name */
621 for(j = db->grpcache; j; j = j->next) {
622 grp = j->data;
623
624 if(strcmp(grp->name, grpname) == 0
625 && !alpm_list_find_ptr(grp->packages, pkg)) {
626 grp->packages = alpm_list_add(grp->packages, pkg);
627 found = 1;
628 break;
629 }
630 }
631 if(found) {
632 continue;
633 }
634 /* we didn't find the group, so create a new one with this name */
635 grp = _alpm_group_new(grpname);
636 if(!grp) {
637 _alpm_db_free_groupcache(db);
638 return -1;
639 }
640 grp->packages = alpm_list_add(grp->packages, pkg);
641 db->grpcache = alpm_list_add(db->grpcache, grp);
642 }
643 }
644
645 db->status |= DB_STATUS_GRPCACHE;
646 return 0;
647 }
648
649 void _alpm_db_free_groupcache(alpm_db_t *db)
650 {
651 alpm_list_t *lg;
652
653 if(db == NULL || !(db->status & DB_STATUS_GRPCACHE)) {
654 return;
655 }
656
657 _alpm_log(db->handle, ALPM_LOG_DEBUG,
658 "freeing group cache for repository '%s'\n", db->treename);
659
660 for(lg = db->grpcache; lg; lg = lg->next) {
661 _alpm_group_free(lg->data);
662 lg->data = NULL;
663 }
664 FREELIST(db->grpcache);
665 db->status &= ~DB_STATUS_GRPCACHE;
666 }
667
668 alpm_list_t *_alpm_db_get_groupcache(alpm_db_t *db)
669 {
670 if(db == NULL) {
671 return NULL;
672 }
673
674 if(!(db->status & DB_STATUS_VALID)) {
675 RET_ERR(db->handle, PM_ERR_DB_INVALID, NULL);
676 }
677
678 if(!(db->status & DB_STATUS_GRPCACHE)) {
679 load_grpcache(db);
680 }
681
682 return db->grpcache;
683 }
684
685 alpm_group_t *_alpm_db_get_groupfromcache(alpm_db_t *db, const char *target)
686 {
687 alpm_list_t *i;
688
689 if(db == NULL || target == NULL || strlen(target) == 0) {
690 return NULL;
691 }
692
693 for(i = _alpm_db_get_groupcache(db); i; i = i->next) {
694 alpm_group_t *info = i->data;
695
696 if(strcmp(info->name, target) == 0) {
697 return info;
698 }
699 }
700
701 return NULL;
702 }
703
704 /* vim: set ts=2 sw=2 noet: */
ngaba's pacman repo