database.c 73.1 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 60
static const char * const apk_world_file = "etc/apk/world";
static const char * const apk_world_file_tmp = "etc/apk/world.new";
static const char * const apk_world_file_old = "var/lib/apk/world";
61
static const char * const apk_arch_file = "etc/apk/arch";
Timo Teräs's avatar
Timo Teräs committed
62 63 64 65 66 67 68 69 70

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_scripts_file_old = "var/lib/apk/scripts.tar";

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

Timo Teräs's avatar
Timo Teräs committed
71
const char * const apk_installed_file = "lib/apk/db/installed";
Timo Teräs's avatar
Timo Teräs committed
72 73 74
static const char * const apk_installed_file_tmp = "lib/apk/db/installed.new";
static const char * const apk_installed_file_old = "var/lib/apk/installed";

75 76 77
struct install_ctx {
	struct apk_database *db;
	struct apk_package *pkg;
78
	struct apk_installed_package *ipkg;
79 80

	int script;
81
	char **script_args;
82
	int script_pending : 1;
83

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

88 89 90 91 92
	apk_progress_cb cb;
	void *cb_ctx;
	size_t installed_size;
	size_t current_file_size;

93 94
	struct hlist_node **diri_node;
	struct hlist_node **file_diri_node;
95 96
};

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

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

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

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

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

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

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

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,
148 149
	.hash_key = apk_blob_hash,
	.compare = apk_blob_compare,
150 151 152
	.delete_item = (apk_hash_delete_f) free,
};

153 154 155 156 157 158
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)
159
{
160 161
	struct apk_db_file_hash_key *key = (struct apk_db_file_hash_key *) _key.ptr;

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

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
169 170
	return apk_blob_hash_seed(APK_BLOB_PTR_LEN(dbf->name, dbf->namelen),
				  dbf->diri->dir->hash);
171 172 173 174 175 176
}

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
177
	struct apk_db_dir *dir = dbf->diri->dir;
178 179
	int r;

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

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

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

Timo Teräs's avatar
Timo Teräs committed
198 199 200 201 202
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);
}

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

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

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

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

	return pn;
}

225
static void apk_db_dir_prepare(struct apk_database *db, struct apk_db_dir *dir, mode_t newmode)
226
{
227
	struct stat st;
228

229 230
	if (dir->namelen == 0) return;
	if (dir->created) return;
231

232 233 234 235 236 237 238 239 240 241 242 243 244
	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;
	}
245 246
}

247
void apk_db_dir_unref(struct apk_database *db, struct apk_db_dir *dir, int rmdir_mode)
248
{
249
	if (--dir->refs > 0) return;
250
	db->installed.stats.dirs--;
251
	if (dir->namelen == 0) return;
252

253 254 255
	if (rmdir_mode == APK_DIR_REMOVE && !(apk_flags & APK_SIMULATE))
		if (unlinkat(db->root_fd, dir->name, AT_REMOVEDIR))
			;
256

257
	apk_db_dir_unref(db, dir->parent, rmdir_mode);
258 259
}

260
struct apk_db_dir *apk_db_dir_ref(struct apk_db_dir *dir)
261 262 263 264 265
{
	dir->refs++;
	return dir;
}

266 267
struct apk_db_dir *apk_db_dir_query(struct apk_database *db,
				    apk_blob_t name)
268 269 270 271
{
	return (struct apk_db_dir *) apk_hash_get(&db->installed.dirs, name);
}

272
struct apk_db_dir *apk_db_dir_get(struct apk_database *db, apk_blob_t name)
273 274
{
	struct apk_db_dir *dir;
275
	struct apk_protected_path_array *ppaths;
276
	struct apk_protected_path *ppath;
277
	apk_blob_t bparent;
278
	unsigned long hash = apk_hash_from_key(&db->installed.dirs, name);
279
	char *relative_name;
280

281
	if (name.len && name.ptr[name.len-1] == '/')
282 283
		name.len--;

284
	dir = (struct apk_db_dir *) apk_hash_get_hashed(&db->installed.dirs, name, hash);
285
	if (dir != NULL)
286
		return apk_db_dir_ref(dir);
287

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

302
	if (name.len == 0) {
303
		dir->parent = NULL;
304 305 306
		dir->has_protected_children = 1;
		ppaths = NULL;
	} else if (apk_blob_rsplit(name, '/', &bparent, NULL)) {
307
		dir->parent = apk_db_dir_get(db, bparent);
308 309
		dir->protect_mode = dir->parent->protect_mode;
		dir->has_protected_children = (dir->protect_mode != APK_PROTECT_NONE);
310 311
		ppaths = dir->parent->protected_paths;
	} else {
312
		dir->parent = apk_db_dir_get(db, APK_BLOB_NULL);
313 314
		ppaths = db->protected_paths;
	}
315

316 317
	if (ppaths == NULL)
		return dir;
318

319
	relative_name = strrchr(dir->rooted_name, '/') + 1;
320 321
	foreach_array_item(ppath, ppaths) {
		char *slash = strchr(ppath->relative_pattern, '/');
322 323 324 325
		if (slash != NULL) {
			*slash = 0;
			if (fnmatch(ppath->relative_pattern, relative_name, FNM_PATHNAME) != 0) {
				*slash = '/';
326 327
				continue;
			}
328 329 330 331
			*slash = '/';

			*apk_protected_path_array_add(&dir->protected_paths) = (struct apk_protected_path) {
				.relative_pattern = slash + 1,
332
				.protect_mode = ppath->protect_mode,
333 334 335 336
			};
		} else {
			if (fnmatch(ppath->relative_pattern, relative_name, FNM_PATHNAME) != 0)
				continue;
337

338
			dir->protect_mode = ppath->protect_mode;
339
		}
340
		dir->has_protected_children |= (ppath->protect_mode != APK_PROTECT_NONE);
341 342
	}

343 344 345
	return dir;
}

346 347 348
static struct apk_db_dir_instance *apk_db_diri_new(struct apk_database *db,
						   struct apk_package *pkg,
						   apk_blob_t name,
349
						   struct hlist_node ***after)
350 351 352 353
{
	struct apk_db_dir_instance *diri;

	diri = calloc(1, sizeof(struct apk_db_dir_instance));
354
	if (diri != NULL) {
355 356
		hlist_add_after(&diri->pkg_dirs_list, *after);
		*after = &diri->pkg_dirs_list.next;
357
		diri->dir = apk_db_dir_get(db, name);
358 359
		diri->pkg = pkg;
	}
360 361 362 363

	return diri;
}

364 365 366 367
static void apk_db_dir_apply_diri_permissions(struct apk_db_dir_instance *diri)
{
	struct apk_db_dir *dir = diri->dir;

368 369
	if (diri->uid < dir->uid ||
	    (diri->uid == dir->uid && diri->gid < dir->gid)) {
370 371
		dir->uid = diri->uid;
		dir->gid = diri->gid;
372 373 374
		dir->mode = diri->mode;
	} else if (diri->uid == dir->uid && diri->gid == dir->gid) {
		dir->mode &= diri->mode;
375 376 377
	}
}

378 379 380
static void apk_db_diri_set(struct apk_db_dir_instance *diri, mode_t mode,
			    uid_t uid, gid_t gid)
{
381
	diri->mode = mode & 07777;
382 383
	diri->uid = uid;
	diri->gid = gid;
384
	apk_db_dir_apply_diri_permissions(diri);
385 386
}

387
static void apk_db_diri_free(struct apk_database *db,
388
			     struct apk_db_dir_instance *diri,
389
			     int rmdir_mode)
390
{
391
	struct apk_db_dir *dir = diri->dir;
392

393 394 395 396
	if (rmdir_mode == APK_DIR_REMOVE)
		apk_db_dir_prepare(db, diri->dir, 0);

	apk_db_dir_unref(db, dir, rmdir_mode);
397 398 399
	free(diri);
}

400 401 402 403 404 405
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;

406 407 408
	if (dir.len && dir.ptr[dir.len-1] == '/')
		dir.len--;

409 410 411 412 413 414 415 416 417
	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
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
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;
	hlist_add_after(&file->diri_files_list, *after);
	*after = &file->diri_files_list.next;

	return file;
}

440 441 442 443 444 445 446
static void apk_db_file_set(struct apk_db_file *file, mode_t mode, uid_t uid, gid_t gid)
{
	file->mode = mode & 07777;
	file->uid = uid;
	file->gid = gid;
}

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

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

Timo Teräs's avatar
Timo Teräs committed
462 463 464
	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);
465 466 467
	if (file != NULL)
		return file;

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

	return file;
}

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

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

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

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

510
	if (pkg->license == NULL)
511
		pkg->license = apk_blob_atomize(APK_BLOB_NULL);
512

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

542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
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)
559
{
560
	/* APKINDEX.12345678.tar.gz */
561
	apk_blob_push_blob(&to, APK_BLOB_STR("APKINDEX."));
562
	apk_blob_push_hexdump(&to, APK_BLOB_PTR_LEN((char *) repo->csum.data, APK_CACHE_CSUM_BYTES));
563
	apk_blob_push_blob(&to, APK_BLOB_STR(".tar.gz"));
564
	apk_blob_push_blob(&to, APK_BLOB_PTR_LEN("", 1));
565 566 567
	if (APK_BLOB_IS_NULL(to))
		return -ENOBUFS;
	return 0;
568 569
}

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

576 577 578
	if (pkg && pkg->arch) arch = *pkg->arch;
	else arch = *db->arch;

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

592 593 594
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
595
	if (repo->url == apk_linked_cache_dir) {
596 597 598 599 600 601 602
		*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);
	}
}
603

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

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

624 625 626
	r = apk_repo_format_real_url(db, repo, pkg, url, sizeof(url));
	if (r < 0)
		return r;
627

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

	if (apk_flags & APK_SIMULATE)
		return 0;
632

633 634 635
	if (cb)
		cb(cb_ctx, 0);

636 637 638
	if (verify != APK_SIGN_NONE) {
		apk_sign_ctx_init(&sctx, APK_SIGN_VERIFY, NULL, db->keys_fd);
		bs = apk_bstream_from_url(url);
639
		bs = apk_bstream_tee(bs, db->cache_fd, tmpcacheitem, cb, cb_ctx);
640
		is = apk_bstream_gunzip_mpart(bs, apk_sign_ctx_mpart_cb, &sctx);
641 642
		if (is) r = apk_tar_parse(is, apk_sign_ctx_verify_tar, &sctx, FALSE, &db->id_cache);
		else r = -errno;
643
		apk_sign_ctx_free(&sctx);
644 645
	} else {
		is = apk_istream_from_url(url);
646
		fd = openat(db->cache_fd, tmpcacheitem, O_RDWR | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
647
		if (fd >= 0) {
648
			r = apk_istream_splice(is, fd, APK_SPLICE_ALL, cb, cb_ctx);
649 650 651
			close(fd);
		} else {
			r = -errno;
652 653
		}
	}
654
	if (is) is->close(is);
655
	if (r < 0) {
656
		unlinkat(db->cache_fd, tmpcacheitem, 0);
657 658
		return r;
	}
659

660 661
	if (renameat(db->cache_fd, tmpcacheitem, db->cache_fd, cacheitem) < 0)
		return -errno;
662

663
	return 0;
664 665
}

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
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
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
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;
716
			diri->dir->created = 1;
Timo Teräs's avatar
Timo Teräs committed
717
		} else {
718 719
			diri = find_diri(ipkg, bdir, diri, &file_diri_node);
			if (diri == NULL) {
720 721
				diri = apk_db_diri_new(db, pkg, bdir, &diri_node);
				file_diri_node = &diri->owned_files.first;
722
			}
Timo Teräs's avatar
Timo Teräs committed
723
			(void) apk_db_file_get(db, diri, bfile, &file_diri_node);
Timo Teräs's avatar
Timo Teräs committed
724 725 726 727 728 729
		}
	}

	return 0;
}

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

744 745 746 747
	while (!APK_BLOB_IS_NULL(l = bs->read(bs, token))) {
		if (l.len < 2 || l.ptr[1] != ':') {
			if (pkg == NULL)
				continue;
748

749
			if (repo >= 0) {
750
				pkg->repos |= BIT(repo);
751 752
			} else if (repo == -2) {
				pkg->cached_non_repository = 1;
753 754 755 756
			} else if (repo == -1 && ipkg == NULL) {
				/* Installed package without files */
				ipkg = apk_pkg_install(db, pkg);
			}
757

758
			if (apk_db_pkg_add(db, pkg) == NULL) {
759 760
				apk_error("Installed database load failed");
				return -1;
761
			}
762
			pkg = NULL;
763
			ipkg = NULL;
764 765
			continue;
		}
766

767 768 769 770 771 772 773 774
		/* Get field */
		field = l.ptr[0];
		l.ptr += 2;
		l.len -= 2;

		/* If no package, create new */
		if (pkg == NULL) {
			pkg = apk_pkg_new();
775
			ipkg = NULL;
776 777 778
			diri = NULL;
			file_diri_node = NULL;
		}
779

780
		/* Standard index line? */
781 782
		r = apk_pkg_add_info(db, pkg, field, l);
		if (r == 0) {
783 784
			continue;
		}
785
		if (r == 1 && repo == -1 && ipkg == NULL) {
786 787 788 789 790 791
			/* 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);
		}
792 793
		if (repo != -1 || ipkg == NULL)
			continue;
794

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

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

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

896 897
		if (ipkg->replaces->num) {
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("r:"));
898
			apk_blob_push_deps(&bbuf, db, ipkg->replaces);
899 900
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
		}
901 902 903 904 905
		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"));
		}
906
		if (ipkg->repository_tag) {
907
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("s:"));
908
			apk_blob_push_blob(&bbuf, db->repo_tags[ipkg->repository_tag].plain_name);
909 910
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
		}
911 912 913 914 915 916 917 918
		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"));
		}
919
		hlist_for_each_entry(diri, c1, &ipkg->owned_dirs, pkg_dirs_list) {
920 921 922 923 924 925 926 927 928
			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("\nM:"));
			apk_blob_push_uint(&bbuf, diri->uid, 10);
			apk_blob_push_blob(&bbuf, APK_BLOB_STR(":"));
			apk_blob_push_uint(&bbuf, diri->gid, 10);
			apk_blob_push_blob(&bbuf, APK_BLOB_STR(":"));
			apk_blob_push_uint(&bbuf, diri->mode, 8);
			apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
929

930
			hlist_for_each_entry(file, c2, &diri->owned_files, diri_files_list) {
931 932
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("R:"));
				apk_blob_push_blob(&bbuf, APK_BLOB_PTR_LEN(file->name, file->namelen));
933 934 935 936 937 938 939 940
				if (file->mode != 0 || file->uid != 0 || file->gid != 0) {
					apk_blob_push_blob(&bbuf, APK_BLOB_STR("\na:"));
					apk_blob_push_uint(&bbuf, file->uid, 10);
					apk_blob_push_blob(&bbuf, APK_BLOB_STR(":"));
					apk_blob_push_uint(&bbuf, file->gid, 10);
					apk_blob_push_blob(&bbuf, APK_BLOB_STR(":"));
					apk_blob_push_uint(&bbuf, file->mode, 8);
				}
Timo Teräs's avatar
Timo Teräs committed
941
				if (file->csum.type != APK_CHECKSUM_NONE) {
942
					apk_blob_push_blob(&bbuf, APK_BLOB_STR("\nZ:"));
Timo Teräs's avatar
Timo Teräs committed
943
					apk_blob_push_csum(&bbuf, &file->csum);
944
				}
945
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
946

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

	return 0;
}

Timo Teräs's avatar
Timo Teräs committed
961
static int apk_db_scriptdb_write(struct apk_database *db, struct apk_ostream *os)
962
{
963
	struct apk_installed_package *ipkg;
964
	struct apk_package *pkg;
Timo Teräs's avatar
Timo Teräs committed
965 966 967
	struct apk_file_info fi;
	char filename[256];
	apk_blob_t bfn;
968
	int r, i;
969
	time_t now = time(NULL);
970 971 972 973 974 975 976

	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		pkg = ipkg->pkg;

		for (i = 0; i < APK_SCRIPT_MAX; i++) {
			if (ipkg->script[i].ptr == NULL)
				continue;
977

Timo Teräs's avatar
Timo Teräs committed
978 979
			fi = (struct apk_file_info) {
				.name = filename,
980
				.size = ipkg->script[i].len,
Timo Teräs's avatar
Timo Teräs committed
981
				.mode = 0755 | S_IFREG,
982
				.mtime = now,
Timo Teräs's avatar
Timo Teräs committed
983 984 985 986 987 988
			};
			/* The scripts db expects file names in format:
			 * pkg-version.<hexdump of package checksum>.action */
			bfn = APK_BLOB_BUF(filename);
			apk_blob_push_blob(&bfn, APK_BLOB_STR(pkg->name->name));
			apk_blob_push_blob(&bfn, APK_BLOB_STR("-"));
989
			apk_blob_push_blob(&bfn, *pkg->version);
Timo Teräs's avatar
Timo Teräs committed
990 991 992
			apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
			apk_blob_push_csum(&bfn, &pkg->csum);
			apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
993
			apk_blob_push_blob(&bfn, APK_BLOB_STR(apk_script_types[i]));
Timo Teräs's avatar
Timo Teräs committed
994