database.c 72.2 KB
Newer Older
1 2 3
/* database.c - Alpine Package Keeper (APK)
 *
 * Copyright (C) 2005-2008 Natanael Copa <n@tanael.org>
4
 * Copyright (C) 2008-2011 Timo Teräs <timo.teras@iki.fi>
5 6
 * All rights reserved.
 *
7
 * This program is free software; you can redistribute it and/or modify it
8 9 10 11 12 13 14
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation. See http://www.gnu.org/ for details.
 */

#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
15
#include <mntent.h>
16
#include <limits.h>
17 18 19
#include <unistd.h>
#include <malloc.h>
#include <string.h>
20
#include <stdlib.h>
21
#include <signal.h>
22
#include <fnmatch.h>
Timo Teräs's avatar
Timo Teräs committed
23
#include <sys/vfs.h>
24
#include <sys/file.h>
25
#include <sys/wait.h>
Natanael Copa's avatar
Natanael Copa committed
26
#include <sys/stat.h>
27
#include <sys/statvfs.h>
28 29 30 31

#include "apk_defines.h"
#include "apk_package.h"
#include "apk_database.h"
32
#include "apk_applet.h"
33
#include "apk_archive.h"
Natanael Copa's avatar
Natanael Copa committed
34 35
#include "apk_print.h"

Timo Teräs's avatar
Timo Teräs committed
36 37 38 39 40
static const apk_spn_match_def apk_spn_repo_separators = {
	[4] = (1<<0) /* */,
	[7] = (1<<2) /*:*/,
};

41
enum {
42 43
	APK_DIR_FREE = 0,
	APK_DIR_REMOVE
44 45
};

Natanael Copa's avatar
Natanael Copa committed
46 47
int apk_verbosity = 1;
unsigned int apk_flags = 0;
48

49 50
static apk_blob_t tmpprefix = { .len=8, .ptr = ".apknew." };

51 52
static const char * const apkindex_tar_gz = "APKINDEX.tar.gz";

Timo Teräs's avatar
Timo Teräs committed
53
static const char * const apk_static_cache_dir = "var/cache/apk";
Timo Teräs's avatar
Timo Teräs committed
54
static const char * const apk_linked_cache_dir = "etc/apk/cache";
Timo Teräs's avatar
Timo Teräs committed
55

Timo Teräs's avatar
Timo Teräs committed
56
static const char * const apk_lock_file = "var/lock/apkdb";
Timo Teräs's avatar
Timo Teräs committed
57

Timo Teräs's avatar
Timo Teräs committed
58 59
static const char * const apk_world_file = "etc/apk/world";
static const char * const apk_world_file_tmp = "etc/apk/world.new";
60
static const char * const apk_arch_file = "etc/apk/arch";
Timo Teräs's avatar
Timo Teräs committed
61 62 63 64 65 66 67

static const char * const apk_scripts_file = "lib/apk/db/scripts.tar";
static const char * const apk_scripts_file_tmp = "lib/apk/db/scripts.tar.new";

static const char * const apk_triggers_file = "lib/apk/db/triggers";
static const char * const apk_triggers_file_tmp = "lib/apk/db/triggers.new";

Timo Teräs's avatar
Timo Teräs committed
68
const char * const apk_installed_file = "lib/apk/db/installed";
Timo Teräs's avatar
Timo Teräs committed
69 70
static const char * const apk_installed_file_tmp = "lib/apk/db/installed.new";

71 72
static struct apk_db_acl *apk_default_acl_dir, *apk_default_acl_file;

73 74 75
struct install_ctx {
	struct apk_database *db;
	struct apk_package *pkg;
76
	struct apk_installed_package *ipkg;
77 78

	int script;
79
	char **script_args;
80
	int script_pending : 1;
81

82
	struct apk_db_dir_instance *diri;
Timo Teräs's avatar
Timo Teräs committed
83
	struct apk_checksum data_csum;
84
	struct apk_sign_ctx sctx;
85

86 87 88 89 90
	apk_progress_cb cb;
	void *cb_ctx;
	size_t installed_size;
	size_t current_file_size;

91 92
	struct hlist_node **diri_node;
	struct hlist_node **file_diri_node;
93 94
};

95
static apk_blob_t pkg_name_get_key(apk_hash_item item)
96
{
97
	return APK_BLOB_STR(((struct apk_name *) item)->name);
98 99
}

100 101 102
static void pkg_name_free(struct apk_name *name)
{
	free(name->name);
103
	apk_provider_array_free(&name->providers);
Timo Teräs's avatar
Timo Teräs committed
104
	apk_name_array_free(&name->rdepends);
Timo Teräs's avatar
Timo Teräs committed
105
	apk_name_array_free(&name->rinstall_if);
106 107 108
	free(name);
}

109 110 111
static const struct apk_hash_ops pkg_name_hash_ops = {
	.node_offset = offsetof(struct apk_name, hash_node),
	.get_key = pkg_name_get_key,
112 113
	.hash_key = apk_blob_hash,
	.compare = apk_blob_compare,
114
	.delete_item = (apk_hash_delete_f) pkg_name_free,
115 116
};

117
static apk_blob_t pkg_info_get_key(apk_hash_item item)
118
{
Timo Teräs's avatar
Timo Teräs committed
119
	return APK_BLOB_CSUM(((struct apk_package *) item)->csum);
120 121
}

122
static unsigned long csum_hash(apk_blob_t csum)
123
{
124 125
	/* Checksum's highest bits have the most "randomness", use that
	 * directly as hash */
126
	return *(unsigned long *) csum.ptr;
127 128 129 130 131
}

static const struct apk_hash_ops pkg_info_hash_ops = {
	.node_offset = offsetof(struct apk_package, hash_node),
	.get_key = pkg_info_get_key,
132 133
	.hash_key = csum_hash,
	.compare = apk_blob_compare,
134 135 136
	.delete_item = (apk_hash_delete_f) apk_pkg_free,
};

137
static apk_blob_t apk_db_dir_get_key(apk_hash_item item)
138
{
Timo Teräs's avatar
Timo Teräs committed
139 140
	struct apk_db_dir *dir = (struct apk_db_dir *) item;
	return APK_BLOB_PTR_LEN(dir->name, dir->namelen);
141 142 143 144 145
}

static const struct apk_hash_ops dir_hash_ops = {
	.node_offset = offsetof(struct apk_db_dir, hash_node),
	.get_key = apk_db_dir_get_key,
146 147
	.hash_key = apk_blob_hash,
	.compare = apk_blob_compare,
148 149 150
	.delete_item = (apk_hash_delete_f) free,
};

151 152 153 154 155 156
struct apk_db_file_hash_key {
	apk_blob_t dirname;
	apk_blob_t filename;
};

static unsigned long apk_db_file_hash_key(apk_blob_t _key)
157
{
158 159
	struct apk_db_file_hash_key *key = (struct apk_db_file_hash_key *) _key.ptr;

Timo Teräs's avatar
Timo Teräs committed
160
	return apk_blob_hash_seed(key->filename, apk_blob_hash(key->dirname));
161 162 163 164 165 166
}

static unsigned long apk_db_file_hash_item(apk_hash_item item)
{
	struct apk_db_file *dbf = (struct apk_db_file *) item;

Timo Teräs's avatar
Timo Teräs committed
167 168
	return apk_blob_hash_seed(APK_BLOB_PTR_LEN(dbf->name, dbf->namelen),
				  dbf->diri->dir->hash);
169 170 171 172 173 174
}

static int apk_db_file_compare_item(apk_hash_item item, apk_blob_t _key)
{
	struct apk_db_file *dbf = (struct apk_db_file *) item;
	struct apk_db_file_hash_key *key = (struct apk_db_file_hash_key *) _key.ptr;
Timo Teräs's avatar
Timo Teräs committed
175
	struct apk_db_dir *dir = dbf->diri->dir;
176 177
	int r;

Timo Teräs's avatar
Timo Teräs committed
178 179
	r = apk_blob_compare(key->filename,
			     APK_BLOB_PTR_LEN(dbf->name, dbf->namelen));
180 181 182
	if (r != 0)
		return r;

Timo Teräs's avatar
Timo Teräs committed
183 184 185
	r = apk_blob_compare(key->dirname,
			     APK_BLOB_PTR_LEN(dir->name, dir->namelen));
	return r;
186 187 188 189
}

static const struct apk_hash_ops file_hash_ops = {
	.node_offset = offsetof(struct apk_db_file, hash_node),
190 191 192
	.hash_key = apk_db_file_hash_key,
	.hash_item = apk_db_file_hash_item,
	.compare_item = apk_db_file_compare_item,
193 194 195
	.delete_item = (apk_hash_delete_f) free,
};

Timo Teräs's avatar
Timo Teräs committed
196 197 198 199 200
struct apk_name *apk_db_query_name(struct apk_database *db, apk_blob_t name)
{
	return (struct apk_name *) apk_hash_get(&db->available.names, name);
}

201
struct apk_name *apk_db_get_name(struct apk_database *db, apk_blob_t name)
202 203
{
	struct apk_name *pn;
204
	unsigned long hash = apk_hash_from_key(&db->available.names, name);
205

206
	pn = (struct apk_name *) apk_hash_get_hashed(&db->available.names, name, hash);
207 208 209 210 211 212 213
	if (pn != NULL)
		return pn;

	pn = calloc(1, sizeof(struct apk_name));
	if (pn == NULL)
		return NULL;

214
	pn->name = apk_blob_cstr(name);
215
	apk_provider_array_init(&pn->providers);
Timo Teräs's avatar
Timo Teräs committed
216
	apk_name_array_init(&pn->rdepends);
Timo Teräs's avatar
Timo Teräs committed
217
	apk_name_array_init(&pn->rinstall_if);
218
	apk_hash_insert_hashed(&db->available.names, pn, hash);
219 220 221 222

	return pn;
}

223 224 225 226 227 228 229 230
static struct apk_db_acl *apk_db_acl_atomize(mode_t mode, uid_t uid, gid_t gid)
{
	struct apk_db_acl acl = { .mode = mode & 07777, .uid = uid, .gid = gid };
	apk_blob_t *b;
	b = apk_blob_atomize_dup(APK_BLOB_STRUCT(acl));
	return (struct apk_db_acl *) b->ptr;
}

231
static void apk_db_dir_prepare(struct apk_database *db, struct apk_db_dir *dir, mode_t newmode)
232
{
233
	struct stat st;
234

235 236
	if (dir->namelen == 0) return;
	if (dir->created) return;
237

238 239 240 241 242 243 244 245 246 247 248 249 250
	if (fstatat(db->root_fd, dir->name, &st, AT_SYMLINK_NOFOLLOW) == 0) {
		/* If directory exists and stats match what we expect,
		 * then we can allow auto updating the permissions */
		dir->created = 1;
		dir->update_permissions |=
			(st.st_mode & 07777) == (dir->mode & 07777) &&
			st.st_uid == dir->uid && st.st_gid == dir->gid;
	} else if (newmode) {
		if (!(apk_flags & APK_SIMULATE))
			mkdirat(db->root_fd, dir->name, newmode);
		dir->created = 1;
		dir->update_permissions = 1;
	}
251 252
}

253
void apk_db_dir_unref(struct apk_database *db, struct apk_db_dir *dir, int rmdir_mode)
254
{
255
	if (--dir->refs > 0) return;
256
	db->installed.stats.dirs--;
257
	if (dir->namelen == 0) return;
258

259 260 261
	if (rmdir_mode == APK_DIR_REMOVE && !(apk_flags & APK_SIMULATE))
		if (unlinkat(db->root_fd, dir->name, AT_REMOVEDIR))
			;
262

263
	apk_db_dir_unref(db, dir->parent, rmdir_mode);
264 265
}

266
struct apk_db_dir *apk_db_dir_ref(struct apk_db_dir *dir)
267 268 269 270 271
{
	dir->refs++;
	return dir;
}

272 273
struct apk_db_dir *apk_db_dir_query(struct apk_database *db,
				    apk_blob_t name)
274 275 276 277
{
	return (struct apk_db_dir *) apk_hash_get(&db->installed.dirs, name);
}

278
struct apk_db_dir *apk_db_dir_get(struct apk_database *db, apk_blob_t name)
279 280
{
	struct apk_db_dir *dir;
281
	struct apk_protected_path_array *ppaths;
282
	struct apk_protected_path *ppath;
283
	apk_blob_t bparent;
284
	unsigned long hash = apk_hash_from_key(&db->installed.dirs, name);
285
	char *relative_name;
286

287
	if (name.len && name.ptr[name.len-1] == '/')
288 289
		name.len--;

290
	dir = (struct apk_db_dir *) apk_hash_get_hashed(&db->installed.dirs, name, hash);
291
	if (dir != NULL)
292
		return apk_db_dir_ref(dir);
293

294
	db->installed.stats.dirs++;
295 296
	dir = malloc(sizeof(*dir) + name.len + 1);
	memset(dir, 0, sizeof(*dir));
297
	dir->refs = 1;
298 299
	dir->uid = (uid_t) -1;
	dir->gid = (gid_t) -1;
300
	dir->rooted_name[0] = '/';
Timo Teräs's avatar
Timo Teräs committed
301 302 303 304
	memcpy(dir->name, name.ptr, name.len);
	dir->name[name.len] = 0;
	dir->namelen = name.len;
	dir->hash = hash;
305
	apk_protected_path_array_init(&dir->protected_paths);
306
	apk_hash_insert_hashed(&db->installed.dirs, dir, hash);
307

308
	if (name.len == 0) {
309
		dir->parent = NULL;
310 311 312
		dir->has_protected_children = 1;
		ppaths = NULL;
	} else if (apk_blob_rsplit(name, '/', &bparent, NULL)) {
313
		dir->parent = apk_db_dir_get(db, bparent);
314 315
		dir->protect_mode = dir->parent->protect_mode;
		dir->has_protected_children = (dir->protect_mode != APK_PROTECT_NONE);
316 317
		ppaths = dir->parent->protected_paths;
	} else {
318
		dir->parent = apk_db_dir_get(db, APK_BLOB_NULL);
319 320
		ppaths = db->protected_paths;
	}
321

322 323
	if (ppaths == NULL)
		return dir;
324

325
	relative_name = strrchr(dir->rooted_name, '/') + 1;
326 327
	foreach_array_item(ppath, ppaths) {
		char *slash = strchr(ppath->relative_pattern, '/');
328 329 330 331
		if (slash != NULL) {
			*slash = 0;
			if (fnmatch(ppath->relative_pattern, relative_name, FNM_PATHNAME) != 0) {
				*slash = '/';
332 333
				continue;
			}
334 335 336 337
			*slash = '/';

			*apk_protected_path_array_add(&dir->protected_paths) = (struct apk_protected_path) {
				.relative_pattern = slash + 1,
338
				.protect_mode = ppath->protect_mode,
339 340 341 342
			};
		} else {
			if (fnmatch(ppath->relative_pattern, relative_name, FNM_PATHNAME) != 0)
				continue;
343

344
			dir->protect_mode = ppath->protect_mode;
345
		}
346
		dir->has_protected_children |= (ppath->protect_mode != APK_PROTECT_NONE);
347 348
	}

349 350 351
	return dir;
}

352 353 354
static struct apk_db_dir_instance *apk_db_diri_new(struct apk_database *db,
						   struct apk_package *pkg,
						   apk_blob_t name,
355
						   struct hlist_node ***after)
356 357 358 359
{
	struct apk_db_dir_instance *diri;

	diri = calloc(1, sizeof(struct apk_db_dir_instance));
360
	if (diri != NULL) {
361 362
		hlist_add_after(&diri->pkg_dirs_list, *after);
		*after = &diri->pkg_dirs_list.next;
363
		diri->dir = apk_db_dir_get(db, name);
364
		diri->pkg = pkg;
365
		diri->acl = apk_default_acl_dir;
366
	}
367 368 369 370

	return diri;
}

371 372 373
static void apk_db_dir_apply_diri_permissions(struct apk_db_dir_instance *diri)
{
	struct apk_db_dir *dir = diri->dir;
374
	struct apk_db_acl *acl = diri->acl;
375

376 377 378 379 380 381
	if (acl->uid < dir->uid || (acl->uid == dir->uid && acl->gid < dir->gid)) {
		dir->uid = acl->uid;
		dir->gid = acl->gid;
		dir->mode = acl->mode;
	} else if (acl->uid == dir->uid && acl->gid == dir->gid) {
		dir->mode &= acl->mode;
382 383 384
	}
}

385
static void apk_db_diri_set(struct apk_db_dir_instance *diri, struct apk_db_acl *acl)
386
{
387
	diri->acl = acl;
388
	apk_db_dir_apply_diri_permissions(diri);
389 390
}

391
static void apk_db_diri_free(struct apk_database *db,
392
			     struct apk_db_dir_instance *diri,
393
			     int rmdir_mode)
394
{
395
	struct apk_db_dir *dir = diri->dir;
396

397 398 399 400
	if (rmdir_mode == APK_DIR_REMOVE)
		apk_db_dir_prepare(db, diri->dir, 0);

	apk_db_dir_unref(db, dir, rmdir_mode);
401 402 403
	free(diri);
}

404 405 406 407 408 409
struct apk_db_file *apk_db_file_query(struct apk_database *db,
				      apk_blob_t dir,
				      apk_blob_t name)
{
	struct apk_db_file_hash_key key;

410 411 412
	if (dir.len && dir.ptr[dir.len-1] == '/')
		dir.len--;

413 414 415 416 417 418 419 420 421
	key = (struct apk_db_file_hash_key) {
		.dirname = dir,
		.filename = name,
	};

	return (struct apk_db_file *) apk_hash_get(&db->installed.files,
						   APK_BLOB_BUF(&key));
}

Timo Teräs's avatar
Timo Teräs committed
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437
static struct apk_db_file *apk_db_file_new(struct apk_db_dir_instance *diri,
					   apk_blob_t name,
					   struct hlist_node ***after)
{
	struct apk_db_file *file;

	file = malloc(sizeof(*file) + name.len + 1);
	if (file == NULL)
		return NULL;

	memset(file, 0, sizeof(*file));
	memcpy(file->name, name.ptr, name.len);
	file->name[name.len] = 0;
	file->namelen = name.len;

	file->diri = diri;
438
	file->acl = apk_default_acl_file;
Timo Teräs's avatar
Timo Teräs committed
439 440 441 442 443 444
	hlist_add_after(&file->diri_files_list, *after);
	*after = &file->diri_files_list.next;

	return file;
}

445
static struct apk_db_file *apk_db_file_get(struct apk_database *db,
446
					   struct apk_db_dir_instance *diri,
447 448
					   apk_blob_t name,
					   struct hlist_node ***after)
449 450
{
	struct apk_db_file *file;
451
	struct apk_db_file_hash_key key;
Timo Teräs's avatar
Timo Teräs committed
452 453
	struct apk_db_dir *dir = diri->dir;
	unsigned long hash;
454 455

	key = (struct apk_db_file_hash_key) {
Timo Teräs's avatar
Timo Teräs committed
456
		.dirname = APK_BLOB_PTR_LEN(dir->name, dir->namelen),
457 458
		.filename = name,
	};
459

Timo Teräs's avatar
Timo Teräs committed
460 461 462
	hash = apk_blob_hash_seed(name, dir->hash);
	file = (struct apk_db_file *) apk_hash_get_hashed(
		&db->installed.files, APK_BLOB_BUF(&key), hash);
463 464 465
	if (file != NULL)
		return file;

Timo Teräs's avatar
Timo Teräs committed
466
	file = apk_db_file_new(diri, name, after);
Timo Teräs's avatar
Timo Teräs committed
467
	apk_hash_insert_hashed(&db->installed.files, file, hash);
468
	db->installed.stats.files++;
469 470 471 472

	return file;
}

Timo Teräs's avatar
Timo Teräs committed
473 474
static void apk_db_pkg_rdepends(struct apk_database *db, struct apk_package *pkg)
{
475 476
	struct apk_name *rname, **rd;
	struct apk_dependency *d;
Timo Teräs's avatar
Timo Teräs committed
477

478 479
	foreach_array_item(d, pkg->depends) {
		rname = d->name;
480
		rname->is_dependency |= !d->conflict;
481 482
		foreach_array_item(rd, rname->rdepends)
			if (*rd == pkg->name)
Timo Teräs's avatar
Timo Teräs committed
483
				goto rdeps_done;
Timo Teräs's avatar
Timo Teräs committed
484
		*apk_name_array_add(&rname->rdepends) = pkg->name;
485
rdeps_done: ;
Timo Teräs's avatar
Timo Teräs committed
486
	}
487 488 489 490
	foreach_array_item(d, pkg->install_if) {
		rname = d->name;
		foreach_array_item(rd, rname->rinstall_if)
			if (*rd == pkg->name)
Timo Teräs's avatar
Timo Teräs committed
491 492
				goto riif_done;
		*apk_name_array_add(&rname->rinstall_if) = pkg->name;
493
riif_done: ;
Timo Teräs's avatar
Timo Teräs committed
494 495
	}
	return;
Timo Teräs's avatar
Timo Teräs committed
496 497
}

498 499 500 501 502
static inline void add_provider(struct apk_name *name, struct apk_provider p)
{
	*apk_provider_array_add(&name->providers) = p;
}

503
struct apk_package *apk_db_pkg_add(struct apk_database *db, struct apk_package *pkg)
504 505
{
	struct apk_package *idb;
506
	struct apk_dependency *dep;
507

508
	if (pkg->license == NULL)
509
		pkg->license = apk_blob_atomize(APK_BLOB_NULL);
510

511 512 513 514 515
	/* Set as "cached" if installing from specified file, and
	 * for virtual packages */
	if (pkg->filename != NULL || pkg->installed_size == 0)
		pkg->repos |= BIT(APK_REPOSITORY_CACHED);

Timo Teräs's avatar
Timo Teräs committed
516
	idb = apk_hash_get(&db->available.packages, APK_BLOB_CSUM(pkg->csum));
517 518 519
	if (idb == NULL) {
		idb = pkg;
		apk_hash_insert(&db->available.packages, pkg);
520
		add_provider(pkg->name, APK_PROVIDER_FROM_PACKAGE(pkg));
521
		foreach_array_item(dep, pkg->provides)
522
			add_provider(dep->name, APK_PROVIDER_FROM_PROVIDES(pkg, dep));
Timo Teräs's avatar
Timo Teräs committed
523
		apk_db_pkg_rdepends(db, pkg);
524 525
	} else {
		idb->repos |= pkg->repos;
526 527 528 529
		if (idb->filename == NULL && pkg->filename != NULL) {
			idb->filename = pkg->filename;
			pkg->filename = NULL;
		}
530 531 532 533 534
		if (idb->ipkg == NULL && pkg->ipkg != NULL) {
			idb->ipkg = pkg->ipkg;
			idb->ipkg->pkg = idb;
			pkg->ipkg = NULL;
		}
535 536 537 538 539
		apk_pkg_free(pkg);
	}
	return idb;
}

540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
static int apk_pkg_format_cache_pkg(apk_blob_t to, struct apk_package *pkg)
{
	/* pkgname-1.0_alpha1.12345678.apk */
	apk_blob_push_blob(&to, APK_BLOB_STR(pkg->name->name));
	apk_blob_push_blob(&to, APK_BLOB_STR("-"));
	apk_blob_push_blob(&to, *pkg->version);
	apk_blob_push_blob(&to, APK_BLOB_STR("."));
	apk_blob_push_hexdump(&to, APK_BLOB_PTR_LEN((char *) pkg->csum.data,
						    APK_CACHE_CSUM_BYTES));
	apk_blob_push_blob(&to, APK_BLOB_STR(".apk"));
	apk_blob_push_blob(&to, APK_BLOB_PTR_LEN("", 1));
	if (APK_BLOB_IS_NULL(to))
		return -ENOBUFS;
	return 0;
}

int apk_repo_format_cache_index(apk_blob_t to, struct apk_repository *repo)
557
{
558
	/* APKINDEX.12345678.tar.gz */
559
	apk_blob_push_blob(&to, APK_BLOB_STR("APKINDEX."));
560
	apk_blob_push_hexdump(&to, APK_BLOB_PTR_LEN((char *) repo->csum.data, APK_CACHE_CSUM_BYTES));
561
	apk_blob_push_blob(&to, APK_BLOB_STR(".tar.gz"));
562
	apk_blob_push_blob(&to, APK_BLOB_PTR_LEN("", 1));
563 564 565
	if (APK_BLOB_IS_NULL(to))
		return -ENOBUFS;
	return 0;
566 567
}

568 569
int apk_repo_format_real_url(struct apk_database *db, struct apk_repository *repo,
			     struct apk_package *pkg, char *buf, size_t len)
570
{
571
	apk_blob_t arch;
572 573
	int r;

574 575 576
	if (pkg && pkg->arch) arch = *pkg->arch;
	else arch = *db->arch;

577 578 579
	if (pkg != NULL)
		r = snprintf(buf, len, "%s%s" BLOB_FMT "/"  PKG_FILE_FMT,
			     repo->url, repo->url[strlen(repo->url)-1] == '/' ? "" : "/",
580
			     BLOB_PRINTF(arch), PKG_FILE_PRINTF(pkg));
581 582 583
	else
		r = snprintf(buf, len, "%s%s" BLOB_FMT "/%s",
			     repo->url, repo->url[strlen(repo->url)-1] == '/' ? "" : "/",
584
			     BLOB_PRINTF(arch), apkindex_tar_gz);
585 586 587 588
	if (r >= len)
		return -ENOBUFS;
	return 0;
}
589

590 591 592
int apk_repo_format_item(struct apk_database *db, struct apk_repository *repo, struct apk_package *pkg,
			 int *fd, char *buf, size_t len)
{
Timo Teräs's avatar
Timo Teräs committed
593
	if (repo->url == apk_linked_cache_dir) {
594 595 596 597 598 599 600
		*fd = db->cache_fd;
		return apk_pkg_format_cache_pkg(APK_BLOB_PTR_LEN(buf, len), pkg);
	} else {
		*fd = AT_FDCWD;
		return apk_repo_format_real_url(db, repo, pkg, buf, len);
	}
}
601

602
int apk_cache_download(struct apk_database *db, struct apk_repository *repo,
603 604
		       struct apk_package *pkg, int verify,
		       apk_progress_cb cb, void *cb_ctx)
605
{
606
	struct stat st;
607 608 609
	struct apk_istream *is;
	struct apk_bstream *bs;
	struct apk_sign_ctx sctx;
610 611 612
	char url[PATH_MAX];
	char tmpcacheitem[128], *cacheitem = &tmpcacheitem[tmpprefix.len];
	apk_blob_t b = APK_BLOB_BUF(tmpcacheitem);
613 614
	int r, fd;

615
	apk_blob_push_blob(&b, tmpprefix);
616
	if (pkg != NULL)
617
		r = apk_pkg_format_cache_pkg(b, pkg);
618
	else
619
		r = apk_repo_format_cache_index(b, repo);
620
	if (r < 0) return r;
621

622
	r = apk_repo_format_real_url(db, repo, pkg, url, sizeof(url));
623
	if (r < 0) return r;
624

625 626 627
	if ((apk_flags & APK_FORCE) ||
	    fstatat(db->cache_fd, cacheitem, &st, 0) != 0)
		st.st_mtime = 0;
628

629
	apk_message("fetch %s", url);
630

631 632
	if (apk_flags & APK_SIMULATE) return 0;
	if (cb) cb(cb_ctx, 0);
633

634 635
	if (verify != APK_SIGN_NONE) {
		apk_sign_ctx_init(&sctx, APK_SIGN_VERIFY, NULL, db->keys_fd);
636
		bs = apk_bstream_from_url_if_modified(url, st.st_mtime);
637
		bs = apk_bstream_tee(bs, db->cache_fd, tmpcacheitem, cb, cb_ctx);
638
		is = apk_bstream_gunzip_mpart(bs, apk_sign_ctx_mpart_cb, &sctx);
639 640 641 642
		if (!IS_ERR_OR_NULL(is))
			r = apk_tar_parse(is, apk_sign_ctx_verify_tar, &sctx, FALSE, &db->id_cache);
		else
			r = PTR_ERR(is) ?: -EIO;
643
		apk_sign_ctx_free(&sctx);
644
	} else {
645 646 647 648 649 650
		is = apk_istream_from_url_if_modified(url, st.st_mtime);
		if (!IS_ERR_OR_NULL(is)) {
			fd = openat(db->cache_fd, tmpcacheitem, O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
			if (fd < 0) r = -errno;
		} else fd = -1, r = PTR_ERR(is) ?: -EIO;

651
		if (fd >= 0) {
652
			r = apk_istream_splice(is, fd, APK_SPLICE_ALL, cb, cb_ctx);
653
			close(fd);
654 655
		}
	}
656 657
	if (!IS_ERR_OR_NULL(is)) is->close(is);
	if (r == -EALREADY) return 0;
658
	if (r < 0) {
659
		unlinkat(db->cache_fd, tmpcacheitem, 0);
660 661
		return r;
	}
662

663 664
	if (renameat(db->cache_fd, tmpcacheitem, db->cache_fd, cacheitem) < 0)
		return -errno;
665
	return 0;
666 667
}

668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
static struct apk_db_dir_instance *find_diri(struct apk_installed_package *ipkg,
					     apk_blob_t dirname,
					     struct apk_db_dir_instance *curdiri,
					     struct hlist_node ***tail)
{
	struct hlist_node *n;
	struct apk_db_dir_instance *diri;

	if (curdiri != NULL &&
	    apk_blob_compare(APK_BLOB_PTR_LEN(curdiri->dir->name,
					      curdiri->dir->namelen),
			     dirname) == 0)
		return curdiri;

	hlist_for_each_entry(diri, n, &ipkg->owned_dirs, pkg_dirs_list) {
		if (apk_blob_compare(APK_BLOB_PTR_LEN(diri->dir->name,
						      diri->dir->namelen), dirname) == 0) {
			if (tail != NULL)
				*tail = hlist_tail_ptr(&diri->owned_files);
			return diri;
		}
	}
	return NULL;
}

Timo Teräs's avatar
Timo Teräs committed
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717
int apk_db_read_overlay(struct apk_database *db, struct apk_bstream *bs)
{
	struct apk_db_dir_instance *diri = NULL;
	struct hlist_node **diri_node = NULL, **file_diri_node = NULL;
	struct apk_package *pkg;
	struct apk_installed_package *ipkg;
	apk_blob_t token = APK_BLOB_STR("\n"), line, bdir, bfile;

	pkg = apk_pkg_new();
	if (pkg == NULL)
		return -1;

	ipkg = apk_pkg_install(db, pkg);
	if (ipkg == NULL)
		return -1;

	diri_node = hlist_tail_ptr(&ipkg->owned_dirs);

	while (!APK_BLOB_IS_NULL(line = bs->read(bs, token))) {
		if (!apk_blob_rsplit(line, '/', &bdir, &bfile))
			break;

		if (bfile.len == 0) {
			diri = apk_db_diri_new(db, pkg, bdir, &diri_node);
			file_diri_node = &diri->owned_files.first;
718
			diri->dir->created = 1;
Timo Teräs's avatar
Timo Teräs committed
719
		} else {
720 721
			diri = find_diri(ipkg, bdir, diri, &file_diri_node);
			if (diri == NULL) {
722 723
				diri = apk_db_diri_new(db, pkg, bdir, &diri_node);
				file_diri_node = &diri->owned_files.first;
724
			}
Timo Teräs's avatar
Timo Teräs committed
725
			(void) apk_db_file_get(db, diri, bfile, &file_diri_node);
Timo Teräs's avatar
Timo Teräs committed
726 727 728 729 730 731
		}
	}

	return 0;
}

732
int apk_db_index_read(struct apk_database *db, struct apk_bstream *bs, int repo)
733 734
{
	struct apk_package *pkg = NULL;
735
	struct apk_installed_package *ipkg = NULL;
736
	struct apk_db_dir_instance *diri = NULL;
737
	struct apk_db_file *file = NULL;
738
	struct apk_db_acl *acl;
739 740
	struct hlist_node **diri_node = NULL;
	struct hlist_node **file_diri_node = NULL;
741
	apk_blob_t token = APK_BLOB_STR("\n"), l;
742 743 744
	mode_t mode;
	uid_t uid;
	gid_t gid;
745
	int field, r, lineno = 0;
746

747
	while (!APK_BLOB_IS_NULL(l = bs->read(bs, token))) {
748 749
		lineno++;

750 751 752
		if (l.len < 2 || l.ptr[1] != ':') {
			if (pkg == NULL)
				continue;
753

754
			if (repo >= 0) {
755
				pkg->repos |= BIT(repo);
756 757
			} else if (repo == -2) {
				pkg->cached_non_repository = 1;
758 759 760 761
			} else if (repo == -1 && ipkg == NULL) {
				/* Installed package without files */
				ipkg = apk_pkg_install(db, pkg);
			}
762

763
			if (apk_db_pkg_add(db, pkg) == NULL) {
764 765
				apk_error("Installed database load failed");
				return -1;
766
			}
767
			pkg = NULL;
768
			ipkg = NULL;
769 770
			continue;
		}
771

772 773 774 775 776 777 778 779
		/* Get field */
		field = l.ptr[0];
		l.ptr += 2;
		l.len -= 2;

		/* If no package, create new */
		if (pkg == NULL) {
			pkg = apk_pkg_new();
780
			ipkg = NULL;
781 782 783
			diri = NULL;
			file_diri_node = NULL;
		}
784

785
		/* Standard index line? */
786
		r = apk_pkg_add_info(db, pkg, field, l);
787
		if (r == 0)
788
			continue;
789
		if (r == 1 && repo == -1 && ipkg == NULL) {
790 791 792 793 794 795
			/* Instert to installed database; this needs to
			 * happen after package name has been read, but
			 * before first FDB entry. */
			ipkg = apk_pkg_install(db, pkg);
			diri_node = hlist_tail_ptr(&ipkg->owned_dirs);
		}
796 797
		if (repo != -1 || ipkg == NULL)
			continue;
798

799 800 801
		/* Check FDB special entries */
		switch (field) {
		case 'F':
802
			if (pkg->name == NULL) goto bad_entry;
803 804 805
			diri = apk_db_diri_new(db, pkg, l, &diri_node);
			file_diri_node = &diri->owned_files.first;
			break;
806
		case 'a':
807
			if (file == NULL) goto bad_entry;
808
		case 'M':
809
			if (diri == NULL) goto bad_entry;
810
			uid = apk_blob_pull_uint(&l, 10);
811
			apk_blob_pull_char(&l, ':');
812
			gid = apk_blob_pull_uint(&l, 10);
813
			apk_blob_pull_char(&l, ':');
814
			mode = apk_blob_pull_uint(&l, 8);
815
			acl = apk_db_acl_atomize(mode, uid, gid);
816
			if (field == 'M')
817
				apk_db_diri_set(diri, acl);
818
			else
819
				file->acl = acl;
820 821
			break;
		case 'R':
822
			if (diri == NULL) goto bad_entry;
Timo Teräs's avatar
Timo Teräs committed
823
			file = apk_db_file_get(db, diri, l, &file_diri_node);
824 825
			break;
		case 'Z':
826
			if (file == NULL) goto bad_entry;
Timo Teräs's avatar
Timo Teräs committed
827
			apk_blob_pull_csum(&l, &file->csum);
828
			break;
829
		case 'r':
830
			apk_blob_pull_deps(&l, db, &ipkg->replaces);
831
			break;
832
		case 'q':
833
			ipkg->replaces_priority = apk_blob_pull_uint(&l, 10);
834
			break;
835
		case 's':
836 837
			ipkg->repository_tag = apk_db_get_tag_id(db, l);
			break;
838 839 840 841 842 843 844 845 846
		case 'f':
			for (r = 0; r < l.len; r++) {
				switch (l.ptr[r]) {
				case 'f': ipkg->broken_files = 1; break;
				case 's': ipkg->broken_script = 1; break;
				default:
					if (!(apk_flags & APK_FORCE))
						goto old_apk_tools;
				}
847
			}
848 849 850 851
			break;
		default:
			if (r != 0 && !(apk_flags & APK_FORCE))
				goto old_apk_tools;
852 853 854
			/* Installed. So mark the package as installable. */
			pkg->filename = NULL;
			continue;
855
		}
856
		if (APK_BLOB_IS_NULL(l)) goto bad_entry;
857
	}
858
	return 0;
859 860 861 862
old_apk_tools:
	/* Installed db should not have unsupported fields */
	apk_error("This apk-tools is too old to handle installed packages");
	return -1;
863 864 865
bad_entry:
	apk_error("FDB format error (line %d, entry '%c')", lineno, field);
	return -1;
866 867
}

868 869 870 871 872 873 874 875 876 877 878 879 880
static void apk_blob_push_db_acl(apk_blob_t *b, char field, struct apk_db_acl *acl)
{
	char hdr[2] = { field, ':' };

	apk_blob_push_blob(b, APK_BLOB_BUF(hdr));
	apk_blob_push_uint(b, acl->uid, 10);
	apk_blob_push_blob(b, APK_BLOB_STR(":"));
	apk_blob_push_uint(b, acl->gid, 10);
	apk_blob_push_blob(b, APK_BLOB_STR(":"));
	apk_blob_push_uint(b, acl->mode, 8);
	apk_blob_push_blob(b, APK_BLOB_STR("\n"));
}

Timo Teräs's avatar
Timo Teräs committed
881
static int apk_db_write_fdb(struct apk_database *db, struct apk_ostream *os)
882
{
883
	struct apk_installed_package *ipkg;
884
	struct apk_package *pkg;
885
	struct apk_db_dir_instance *diri;
886
	struct apk_db_file *file;
887
	struct hlist_node *c1, *c2;
888
	char buf[1024];
889 890
	apk_blob_t bbuf = APK_BLOB_BUF(buf);
	int r;
891

892 893
	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		pkg = ipkg->pkg;
894 895 896
		r = apk_pkg_write_index_entry(pkg, os);
		if (r < 0)
			return r;
897

898 899
		if (ipkg->replaces->num) {
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("r:"));
900
			apk_blob_push_deps(&bbuf, db, ipkg->replaces);
901 902
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
		}
903 904 905 906 907
		if (ipkg->replaces_priority) {
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("q:"));
			apk_blob_push_uint(&bbuf, ipkg->replaces_priority, 10);
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
		}
908
		if (ipkg->repository_tag) {
909
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("s:"));
910
			apk_blob_push_blob(&bbuf, db->repo_tags[ipkg->repository_tag].plain_name);
911 912
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
		}
913 914 915 916 917 918 919 920
		if (ipkg->broken_files || ipkg->broken_script) {
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("f:"));
			if (ipkg->broken_files)
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("f"));
			if (ipkg->broken_script)
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("s"));
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
		}
921
		hlist_for_each_entry(diri, c1, &ipkg->owned_dirs, pkg_dirs_list) {
922 923 924
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("F:"));
			apk_blob_push_blob(&bbuf, APK_BLOB_PTR_LEN(diri->dir->name, diri->dir->namelen));
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
925

926 927 928
			if (1 || diri->acl != apk_default_acl_dir)
				apk_blob_push_db_acl(&bbuf, 'M', diri->acl);

929
			hlist_for_each_entry(file, c2, &diri->owned_files, diri_files_list) {
930 931
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("R:"));
				apk_blob_push_blob(&bbuf, APK_BLOB_PTR_LEN(file->name, file->namelen));
932 933 934 935 936
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));

				if (1 || file->acl != apk_default_acl_file)
					apk_blob_push_db_acl(&bbuf, 'a', file->acl);

Timo Teräs's avatar
Timo Teräs committed
937
				if (file->csum.type != APK_CHECKSUM_NONE) {
938
					apk_blob_push_blob(&bbuf, APK_BLOB_STR("Z:"));
Timo Teräs's avatar
Timo Teräs committed
939
					apk_blob_push_csum(&bbuf, &file->csum);
940
					apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
941
				}
942

943
				if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
944
					return -EIO;
945
				bbuf = APK_BLOB_BUF(buf);
946
			}
947
			if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
948
				return -EIO;
949
			bbuf = APK_BLOB_BUF(buf);
950
		}
Timo Teräs's avatar
Timo Teräs committed
951
		os->write(os, "\n", 1);
952 953 954 955 956
	}

	return 0;
}