?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove sync DB reregister check
[pacman-ng.git] / lib / libalpm / be_sync.c
blob9d85a454bd6c63bf3a8cd613d9039b97d98ffa36
1 /*
2 * be_sync.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 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "config.h"
22
23 #include <sys/stat.h>
24
25 /* libarchive */
26 #include <archive.h>
27 #include <archive_entry.h>
28
29 /* libalpm */
30 #include "util.h"
31 #include "log.h"
32 #include "alpm.h"
33 #include "alpm_list.h"
34 #include "package.h"
35 #include "handle.h"
36 #include "delta.h"
37 #include "deps.h"
38 #include "dload.h"
39
40 /** Update a package database
41 *
42 * An update of the package database \a db will be attempted. Unless
43 * \a force is true, the update will only be performed if the remote
44 * database was modified since the last update.
45 *
46 * A transaction is necessary for this operation, in order to obtain a
47 * database lock. During this transaction the front-end will be informed
48 * of the download progress of the database via the download callback.
49 *
50 * Example:
51 * @code
52 * alpm_list_t *syncs = alpm_option_get_syncdbs();
53 * if(alpm_trans_init(0, NULL, NULL, NULL) == 0) {
54 * for(i = syncs; i; i = alpm_list_next(i)) {
55 * pmdb_t *db = alpm_list_getdata(i);
56 * result = alpm_db_update(0, db);
57 * alpm_trans_release();
58 *
59 * if(result < 0) {
60 * printf("Unable to update database: %s\n", alpm_strerrorlast());
61 * } else if(result == 1) {
62 * printf("Database already up to date\n");
63 * } else {
64 * printf("Database updated\n");
65 * }
66 * }
67 * }
68 * @endcode
69 *
70 * @ingroup alpm_databases
71 * @note After a successful update, the \link alpm_db_get_pkgcache()
72 * package cache \endlink will be invalidated
73 * @param force if true, then forces the update, otherwise update only in case
74 * the database isn't up to date
75 * @param db pointer to the package database to update
76 * @return 0 on success, -1 on error (pm_errno is set accordingly), 1 if up to
77 * to date
78 */
79 int SYMEXPORT alpm_db_update(int force, pmdb_t *db)
80 {
81 char *syncpath;
82 const char *dbpath;
83 alpm_list_t *i;
84 struct stat buf;
85 size_t len;
86 int ret = -1;
87 mode_t oldmask;
88 pgp_verify_t check_sig;
89
90 ALPM_LOG_FUNC;
91
92 /* Sanity checks */
93 ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
94 ASSERT(db != NULL && db != handle->db_local, RET_ERR(PM_ERR_WRONG_ARGS, -1));
95 ASSERT(db->servers != NULL, RET_ERR(PM_ERR_SERVER_NONE, -1));
96
97 dbpath = alpm_option_get_dbpath();
98 len = strlen(dbpath) + 6;
99 MALLOC(syncpath, len, RET_ERR(PM_ERR_MEMORY, -1));
100 sprintf(syncpath, "%s%s", dbpath, "sync/");
101
102 /* make sure we have a sane umask */
103 oldmask = umask(0022);
104
105 if(stat(syncpath, &buf) != 0) {
106 _alpm_log(PM_LOG_DEBUG, "database dir '%s' does not exist, creating it\n",
107 syncpath);
108 if(_alpm_makepath(syncpath) != 0) {
109 free(syncpath);
110 RET_ERR(PM_ERR_SYSTEM, -1);
111 }
112 } else if(!S_ISDIR(buf.st_mode)) {
113 _alpm_log(PM_LOG_WARNING, _("removing invalid file: %s\n"), syncpath);
114 if(unlink(syncpath) != 0 || _alpm_makepath(syncpath) != 0) {
115 free(syncpath);
116 RET_ERR(PM_ERR_SYSTEM, -1);
117 }
118 }
119
120 check_sig = _alpm_db_get_sigverify_level(db);
121
122 for(i = db->servers; i; i = i->next) {
123 const char *server = i->data;
124 char *fileurl;
125 size_t len;
126 int sig_ret = 0;
127
128 /* print server + filename into a buffer (leave space for .sig) */
129 len = strlen(server) + strlen(db->treename) + 9;
130 CALLOC(fileurl, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, -1));
131 snprintf(fileurl, len, "%s/%s.db", server, db->treename);
132
133 ret = _alpm_download(fileurl, syncpath, force, 0, 0);
134
135 if(ret == 0 && (check_sig == PM_PGP_VERIFY_ALWAYS ||
136 check_sig == PM_PGP_VERIFY_OPTIONAL)) {
137 int errors_ok = (check_sig == PM_PGP_VERIFY_OPTIONAL);
138 /* if we downloaded a DB, we want the .sig from the same server */
139 snprintf(fileurl, len, "%s/%s.db.sig", server, db->treename);
140
141 sig_ret = _alpm_download(fileurl, syncpath, 1, 0, errors_ok);
142 /* errors_ok suppresses error messages, but not the return code */
143 sig_ret = errors_ok ? 0 : sig_ret;
144 }
145
146 FREE(fileurl);
147 if(ret != -1 && sig_ret != -1) {
148 break;
149 }
150 }
151
152 if(ret == 1) {
153 /* files match, do nothing */
154 pm_errno = 0;
155 goto cleanup;
156 } else if(ret == -1) {
157 /* pm_errno was set by the download code */
158 _alpm_log(PM_LOG_DEBUG, "failed to sync db: %s\n", alpm_strerrorlast());
159 goto cleanup;
160 }
161
162 /* Cache needs to be rebuilt */
163 _alpm_db_free_pkgcache(db);
164
165 cleanup:
166
167 free(syncpath);
168 umask(oldmask);
169 return ret;
170 }
171
172 /* Forward decl so I don't reorganize the whole file right now */
173 static int sync_db_read(pmdb_t *db, struct archive *archive,
174 struct archive_entry *entry, pmpkg_t *likely_pkg);
175
176 /*
177 * This is the data table used to generate the estimating function below.
178 * "Weighted Avg" means averaging the bottom table values; thus each repo, big
179 * or small, will have equal influence. "Unweighted Avg" means averaging the
180 * sums of the top table columns, thus each package has equal influence. The
181 * final values are calculated by (surprise) averaging the averages, because
182 * why the hell not.
183 *
184 * Database Pkgs tar bz2 gz xz
185 * community 2096 5294080 256391 421227 301296
186 * core 180 460800 25257 36850 29356
187 * extra 2606 6635520 294647 470818 339392
188 * multilib 126 327680 16120 23261 18732
189 * testing 76 204800 10902 14348 12100
190 *
191 * Bytes Per Package
192 * community 2096 2525.80 122.32 200.97 143.75
193 * core 180 2560.00 140.32 204.72 163.09
194 * extra 2606 2546.25 113.06 180.67 130.23
195 * multilib 126 2600.63 127.94 184.61 148.67
196 * testing 76 2694.74 143.45 188.79 159.21
197
198 * Weighted Avg 2585.48 129.42 191.95 148.99
199 * Unweighted Avg 2543.39 118.74 190.16 137.93
200 * Average of Avgs 2564.44 124.08 191.06 143.46
201 */
202 static size_t estimate_package_count(struct stat *st, struct archive *archive)
203 {
204 unsigned int per_package;
205
206 switch(archive_compression(archive)) {
207 case ARCHIVE_COMPRESSION_NONE:
208 per_package = 2564;
209 break;
210 case ARCHIVE_COMPRESSION_GZIP:
211 per_package = 191;
212 break;
213 case ARCHIVE_COMPRESSION_BZIP2:
214 per_package = 124;
215 break;
216 case ARCHIVE_COMPRESSION_COMPRESS:
217 per_package = 193;
218 break;
219 case ARCHIVE_COMPRESSION_LZMA:
220 case ARCHIVE_COMPRESSION_XZ:
221 per_package = 143;
222 break;
223 #ifdef ARCHIVE_COMPRESSION_UU
224 case ARCHIVE_COMPRESSION_UU:
225 per_package = 3543;
226 break;
227 #endif
228 default:
229 /* assume it is at least somewhat compressed */
230 per_package = 200;
231 }
232 return (size_t)((st->st_size / per_package) + 1);
233 }
234
235 static int sync_db_populate(pmdb_t *db)
236 {
237 const char *dbpath;
238 size_t est_count;
239 int count = 0;
240 struct stat buf;
241 struct archive *archive;
242 struct archive_entry *entry;
243 pmpkg_t *pkg = NULL;
244
245 ALPM_LOG_FUNC;
246
247 ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
248
249 if((archive = archive_read_new()) == NULL) {
250 RET_ERR(PM_ERR_LIBARCHIVE, -1);
251 }
252
253 archive_read_support_compression_all(archive);
254 archive_read_support_format_all(archive);
255
256 dbpath = _alpm_db_path(db);
257 if(!dbpath) {
258 /* pm_errno set in _alpm_db_path() */
259 return -1;
260 }
261
262 _alpm_log(PM_LOG_DEBUG, "opening database archive %s\n", dbpath);
263
264 if(archive_read_open_filename(archive, dbpath,
265 ARCHIVE_DEFAULT_BYTES_PER_BLOCK) != ARCHIVE_OK) {
266 _alpm_log(PM_LOG_ERROR, _("could not open file %s: %s\n"), dbpath,
267 archive_error_string(archive));
268 archive_read_finish(archive);
269 RET_ERR(PM_ERR_DB_OPEN, -1);
270 }
271 if(stat(dbpath, &buf) != 0) {
272 RET_ERR(PM_ERR_DB_OPEN, -1);
273 }
274 est_count = estimate_package_count(&buf, archive);
275
276 /* initialize hash at 66% full */
277 db->pkgcache = _alpm_pkghash_create(est_count * 3 / 2);
278 if(db->pkgcache == NULL) {
279 RET_ERR(PM_ERR_MEMORY, -1);
280 }
281
282 while(archive_read_next_header(archive, &entry) == ARCHIVE_OK) {
283 const struct stat *st;
284
285 st = archive_entry_stat(entry);
286
287 if(S_ISDIR(st->st_mode)) {
288 const char *name;
289
290 pkg = _alpm_pkg_new();
291 if(pkg == NULL) {
292 archive_read_finish(archive);
293 RET_ERR(PM_ERR_MEMORY, -1);
294 }
295
296 name = archive_entry_pathname(entry);
297
298 if(_alpm_splitname(name, pkg) != 0) {
299 _alpm_log(PM_LOG_ERROR, _("invalid name for database entry '%s'\n"),
300 name);
301 _alpm_pkg_free(pkg);
302 continue;
303 }
304
305 /* duplicated database entries are not allowed */
306 if(_alpm_pkghash_find(db->pkgcache, pkg->name)) {
307 _alpm_log(PM_LOG_ERROR, _("duplicated database entry '%s'\n"), pkg->name);
308 _alpm_pkg_free(pkg);
309 continue;
310 }
311
312 pkg->origin = PKG_FROM_SYNCDB;
313 pkg->ops = &default_pkg_ops;
314 pkg->origin_data.db = db;
315
316 /* add to the collection */
317 _alpm_log(PM_LOG_FUNCTION, "adding '%s' to package cache for db '%s'\n",
318 pkg->name, db->treename);
319 db->pkgcache = _alpm_pkghash_add(db->pkgcache, pkg);
320 count++;
321 } else {
322 /* we have desc, depends or deltas - parse it */
323 sync_db_read(db, archive, entry, pkg);
324 }
325 }
326
327 if(count > 0) {
328 db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
329 }
330 archive_read_finish(archive);
331 _alpm_log(PM_LOG_DEBUG, "added %d packages to package cache for db '%s'\n",
332 count, db->treename);
333
334 return count;
335 }
336
337 #define READ_NEXT(s) do { \
338 if(_alpm_archive_fgets(archive, &buf) != ARCHIVE_OK) goto error; \
339 s = _alpm_strtrim(buf.line); \
340 } while(0)
341
342 #define READ_AND_STORE(f) do { \
343 READ_NEXT(line); \
344 STRDUP(f, line, goto error); \
345 } while(0)
346
347 #define READ_AND_STORE_ALL(f) do { \
348 char *linedup; \
349 READ_NEXT(line); \
350 if(strlen(line) == 0) break; \
351 STRDUP(linedup, line, goto error); \
352 f = alpm_list_add(f, linedup); \
353 } while(1) /* note the while(1) and not (0) */
354
355 static int sync_db_read(pmdb_t *db, struct archive *archive,
356 struct archive_entry *entry, pmpkg_t *likely_pkg)
357 {
358 const char *entryname = NULL, *filename;
359 char *pkgname, *p, *q;
360 pmpkg_t *pkg;
361 struct archive_read_buffer buf;
362
363 ALPM_LOG_FUNC;
364
365 if(db == NULL) {
366 RET_ERR(PM_ERR_DB_NULL, -1);
367 }
368
369 if(entry != NULL) {
370 entryname = archive_entry_pathname(entry);
371 }
372 if(entryname == NULL) {
373 _alpm_log(PM_LOG_DEBUG, "invalid archive entry provided to _alpm_sync_db_read, skipping\n");
374 return -1;
375 }
376
377 _alpm_log(PM_LOG_FUNCTION, "loading package data from archive entry %s\n",
378 entryname);
379
380 memset(&buf, 0, sizeof(buf));
381 /* 512K for a line length seems reasonable */
382 buf.max_line_size = 512 * 1024;
383
384 /* get package and db file names */
385 STRDUP(pkgname, entryname, RET_ERR(PM_ERR_MEMORY, -1));
386 p = pkgname + strlen(pkgname);
387 for(q = --p; *q && *q != '/'; q--);
388 filename = q + 1;
389 for(p = --q; *p && *p != '-'; p--);
390 for(q = --p; *q && *q != '-'; q--);
391 *q = '\0';
392
393 /* package is already in db due to parsing of directory name */
394 if(likely_pkg && strcmp(likely_pkg->name, pkgname) == 0) {
395 pkg = likely_pkg;
396 } else {
397 if(db->pkgcache == NULL) {
398 RET_ERR(PM_ERR_MEMORY, -1);
399 }
400 pkg = _alpm_pkghash_find(db->pkgcache, pkgname);
401 }
402 if(pkg == NULL) {
403 _alpm_log(PM_LOG_DEBUG, "package %s not found in %s sync database",
404 pkgname, db->treename);
405 return -1;
406 }
407
408 if(strcmp(filename, "desc") == 0 || strcmp(filename, "depends") == 0
409 || strcmp(filename, "deltas") == 0) {
410 while(_alpm_archive_fgets(archive, &buf) == ARCHIVE_OK) {
411 char *line = _alpm_strtrim(buf.line);
412
413 if(strcmp(line, "%NAME%") == 0) {
414 READ_NEXT(line);
415 if(strcmp(line, pkg->name) != 0) {
416 _alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: name "
417 "mismatch on package %s\n"), db->treename, pkg->name);
418 }
419 } else if(strcmp(line, "%VERSION%") == 0) {
420 READ_NEXT(line);
421 if(strcmp(line, pkg->version) != 0) {
422 _alpm_log(PM_LOG_ERROR, _("%s database is inconsistent: version "
423 "mismatch on package %s\n"), db->treename, pkg->name);
424 }
425 } else if(strcmp(line, "%FILENAME%") == 0) {
426 READ_AND_STORE(pkg->filename);
427 } else if(strcmp(line, "%DESC%") == 0) {
428 READ_AND_STORE(pkg->desc);
429 } else if(strcmp(line, "%GROUPS%") == 0) {
430 READ_AND_STORE_ALL(pkg->groups);
431 } else if(strcmp(line, "%URL%") == 0) {
432 READ_AND_STORE(pkg->url);
433 } else if(strcmp(line, "%LICENSE%") == 0) {
434 READ_AND_STORE_ALL(pkg->licenses);
435 } else if(strcmp(line, "%ARCH%") == 0) {
436 READ_AND_STORE(pkg->arch);
437 } else if(strcmp(line, "%BUILDDATE%") == 0) {
438 READ_NEXT(line);
439 pkg->builddate = _alpm_parsedate(line);
440 } else if(strcmp(line, "%PACKAGER%") == 0) {
441 READ_AND_STORE(pkg->packager);
442 } else if(strcmp(line, "%CSIZE%") == 0) {
443 /* Note: the CSIZE and SIZE fields both share the "size" field in the
444 * pkginfo_t struct. This can be done b/c CSIZE is currently only used
445 * in sync databases, and SIZE is only used in local databases.
446 */
447 READ_NEXT(line);
448 pkg->size = atol(line);
449 /* also store this value to isize if isize is unset */
450 if(pkg->isize == 0) {
451 pkg->isize = pkg->size;
452 }
453 } else if(strcmp(line, "%ISIZE%") == 0) {
454 READ_NEXT(line);
455 pkg->isize = atol(line);
456 } else if(strcmp(line, "%MD5SUM%") == 0) {
457 READ_AND_STORE(pkg->md5sum);
458 } else if(strcmp(line, "%SHA256SUM%") == 0) {
459 /* we don't do anything with this value right now */
460 READ_NEXT(line);
461 } else if(strcmp(line, "%PGPSIG%") == 0) {
462 READ_AND_STORE(pkg->base64_sig);
463 } else if(strcmp(line, "%REPLACES%") == 0) {
464 READ_AND_STORE_ALL(pkg->replaces);
465 } else if(strcmp(line, "%DEPENDS%") == 0) {
466 /* Different than the rest because of the _alpm_splitdep call. */
467 while(1) {
468 READ_NEXT(line);
469 if(strlen(line) == 0) break;
470 pkg->depends = alpm_list_add(pkg->depends, _alpm_splitdep(line));
471 }
472 } else if(strcmp(line, "%OPTDEPENDS%") == 0) {
473 READ_AND_STORE_ALL(pkg->optdepends);
474 } else if(strcmp(line, "%CONFLICTS%") == 0) {
475 READ_AND_STORE_ALL(pkg->conflicts);
476 } else if(strcmp(line, "%PROVIDES%") == 0) {
477 READ_AND_STORE_ALL(pkg->provides);
478 } else if(strcmp(line, "%DELTAS%") == 0) {
479 /* Different than the rest because of the _alpm_delta_parse call. */
480 while(1) {
481 READ_NEXT(line);
482 if(strlen(line) == 0) break;
483 pkg->deltas = alpm_list_add(pkg->deltas, _alpm_delta_parse(line));
484 }
485 }
486 }
487 } else if(strcmp(filename, "files") == 0) {
488 /* currently do nothing with this file */
489 } else {
490 /* unknown database file */
491 _alpm_log(PM_LOG_DEBUG, "unknown database file: %s\n", filename);
492 }
493
494 error:
495 FREE(pkgname);
496 /* TODO: return 0 always? */
497 return 0;
498 }
499
500 static int sync_db_version(pmdb_t UNUSED *db)
501 {
502 return 2;
503 }
504
505 struct db_operations sync_db_ops = {
506 .populate = sync_db_populate,
507 .unregister = _alpm_db_unregister,
508 .version = sync_db_version,
509 };
510
511 pmdb_t *_alpm_db_register_sync(const char *treename)
512 {
513 pmdb_t *db;
514
515 ALPM_LOG_FUNC;
516 _alpm_log(PM_LOG_DEBUG, "registering sync database '%s'\n", treename);
517
518 db = _alpm_db_new(treename, 0);
519 if(db == NULL) {
520 RET_ERR(PM_ERR_DB_CREATE, NULL);
521 }
522 db->ops = &sync_db_ops;
523
524 handle->dbs_sync = alpm_list_add(handle->dbs_sync, db);
525 return db;
526 }
527
528
529 /* vim: set ts=2 sw=2 noet: */
ngaba's pacman repo