database.c 57.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-2009 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 32

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

37 38 39 40 41 42 43 44
#if defined(__x86_64__)
#define APK_DEFAULT_ARCH	"x86_64"
#elif defined(__i386__)
#define APK_DEFAULT_ARCH	"x86"
#else
#define APK_DEFAULT_ARCH	"noarch"
#endif

45 46 47 48 49
enum {
	APK_DISALLOW_RMDIR = 0,
	APK_ALLOW_RMDIR = 1
};

Natanael Copa's avatar
Natanael Copa committed
50 51
int apk_verbosity = 1;
unsigned int apk_flags = 0;
52
const char *apk_arch = APK_DEFAULT_ARCH;
53

54
const char * const apkindex_tar_gz = "APKINDEX.tar.gz";
Timo Teräs's avatar
Timo Teräs committed
55 56
static const char * const apk_static_cache_dir = "var/lib/apk";
static const char * const apk_linked_cache_dir = "etc/apk/cache";
Timo Teräs's avatar
Timo Teräs committed
57
static const char * const apk_lock_file = "var/lock/apkdb";
Timo Teräs's avatar
Timo Teräs committed
58

59 60 61
struct install_ctx {
	struct apk_database *db;
	struct apk_package *pkg;
62
	struct apk_installed_package *ipkg;
63 64

	int script;
65
	char **script_args;
66
	int script_pending : 1;
67

68
	struct apk_db_dir_instance *diri;
Timo Teräs's avatar
Timo Teräs committed
69
	struct apk_checksum data_csum;
70
	struct apk_sign_ctx sctx;
71
	struct apk_name_array *replaces;
72

73 74 75 76 77
	apk_progress_cb cb;
	void *cb_ctx;
	size_t installed_size;
	size_t current_file_size;

78 79
	struct hlist_node **diri_node;
	struct hlist_node **file_diri_node;
80 81
};

82
static apk_blob_t pkg_name_get_key(apk_hash_item item)
83
{
84
	return APK_BLOB_STR(((struct apk_name *) item)->name);
85 86
}

87 88 89
static void pkg_name_free(struct apk_name *name)
{
	free(name->name);
Timo Teräs's avatar
Timo Teräs committed
90 91
	apk_package_array_free(&name->pkgs);
	apk_name_array_free(&name->rdepends);
Timo Teräs's avatar
Timo Teräs committed
92
	apk_name_array_free(&name->rinstall_if);
93 94 95
	free(name);
}

96 97 98
static const struct apk_hash_ops pkg_name_hash_ops = {
	.node_offset = offsetof(struct apk_name, hash_node),
	.get_key = pkg_name_get_key,
99 100
	.hash_key = apk_blob_hash,
	.compare = apk_blob_compare,
101
	.delete_item = (apk_hash_delete_f) pkg_name_free,
102 103
};

104
static apk_blob_t pkg_info_get_key(apk_hash_item item)
105
{
Timo Teräs's avatar
Timo Teräs committed
106
	return APK_BLOB_CSUM(((struct apk_package *) item)->csum);
107 108
}

109
static unsigned long csum_hash(apk_blob_t csum)
110
{
111 112
	/* Checksum's highest bits have the most "randomness", use that
	 * directly as hash */
113
	return *(unsigned long *) csum.ptr;
114 115 116 117 118
}

static const struct apk_hash_ops pkg_info_hash_ops = {
	.node_offset = offsetof(struct apk_package, hash_node),
	.get_key = pkg_info_get_key,
119 120
	.hash_key = csum_hash,
	.compare = apk_blob_compare,
121 122 123
	.delete_item = (apk_hash_delete_f) apk_pkg_free,
};

124
static apk_blob_t apk_db_dir_get_key(apk_hash_item item)
125
{
Timo Teräs's avatar
Timo Teräs committed
126 127
	struct apk_db_dir *dir = (struct apk_db_dir *) item;
	return APK_BLOB_PTR_LEN(dir->name, dir->namelen);
128 129 130 131 132
}

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,
133 134
	.hash_key = apk_blob_hash,
	.compare = apk_blob_compare,
135 136 137
	.delete_item = (apk_hash_delete_f) free,
};

138 139 140 141 142 143
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)
144
{
145 146
	struct apk_db_file_hash_key *key = (struct apk_db_file_hash_key *) _key.ptr;

Timo Teräs's avatar
Timo Teräs committed
147
	return apk_blob_hash_seed(key->filename, apk_blob_hash(key->dirname));
148 149 150 151 152 153
}

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
154 155
	return apk_blob_hash_seed(APK_BLOB_PTR_LEN(dbf->name, dbf->namelen),
				  dbf->diri->dir->hash);
156 157 158 159 160 161
}

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
162
	struct apk_db_dir *dir = dbf->diri->dir;
163 164
	int r;

Timo Teräs's avatar
Timo Teräs committed
165 166
	r = apk_blob_compare(key->filename,
			     APK_BLOB_PTR_LEN(dbf->name, dbf->namelen));
167 168 169
	if (r != 0)
		return r;

Timo Teräs's avatar
Timo Teräs committed
170 171 172
	r = apk_blob_compare(key->dirname,
			     APK_BLOB_PTR_LEN(dir->name, dir->namelen));
	return r;
173 174 175 176
}

static const struct apk_hash_ops file_hash_ops = {
	.node_offset = offsetof(struct apk_db_file, hash_node),
177 178 179
	.hash_key = apk_db_file_hash_key,
	.hash_item = apk_db_file_hash_item,
	.compare_item = apk_db_file_compare_item,
180 181 182
	.delete_item = (apk_hash_delete_f) free,
};

Timo Teräs's avatar
Timo Teräs committed
183 184 185 186 187
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);
}

188
struct apk_name *apk_db_get_name(struct apk_database *db, apk_blob_t name)
189 190
{
	struct apk_name *pn;
191
	unsigned long hash = apk_hash_from_key(&db->available.names, name);
192

193
	pn = (struct apk_name *) apk_hash_get_hashed(&db->available.names, name, hash);
194 195 196 197 198 199 200
	if (pn != NULL)
		return pn;

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

201
	pn->name = apk_blob_cstr(name);
202
	pn->id = db->name_id++;
Timo Teräs's avatar
Timo Teräs committed
203 204
	apk_package_array_init(&pn->pkgs);
	apk_name_array_init(&pn->rdepends);
Timo Teräs's avatar
Timo Teräs committed
205
	apk_name_array_init(&pn->rinstall_if);
206
	apk_hash_insert_hashed(&db->available.names, pn, hash);
207 208 209 210

	return pn;
}

211 212
static void apk_db_dir_unref(struct apk_database *db, struct apk_db_dir *dir,
			     int allow_rmdir)
213 214 215 216 217 218
{
	dir->refs--;
	if (dir->refs > 0)
		return;

	db->installed.stats.dirs--;
219 220
	if (allow_rmdir)
		unlinkat(db->root_fd, dir->name, AT_REMOVEDIR);
221 222

	if (dir->parent != NULL)
223
		apk_db_dir_unref(db, dir->parent, allow_rmdir);
224 225
}

226
static struct apk_db_dir *apk_db_dir_ref(struct apk_db_dir *dir)
227 228 229 230 231
{
	dir->refs++;
	return dir;
}

232 233
struct apk_db_dir *apk_db_dir_query(struct apk_database *db,
				    apk_blob_t name)
234 235 236 237
{
	return (struct apk_db_dir *) apk_hash_get(&db->installed.dirs, name);
}

238 239
static struct apk_db_dir *apk_db_dir_get(struct apk_database *db,
					 apk_blob_t name)
240 241 242
{
	struct apk_db_dir *dir;
	apk_blob_t bparent;
243
	unsigned long hash = apk_hash_from_key(&db->installed.dirs, name);
244
	int i;
245

246
	if (name.len && name.ptr[name.len-1] == '/')
247 248
		name.len--;

249
	dir = (struct apk_db_dir *) apk_hash_get_hashed(&db->installed.dirs, name, hash);
250
	if (dir != NULL)
251
		return apk_db_dir_ref(dir);
252

253
	db->installed.stats.dirs++;
254 255
	dir = malloc(sizeof(*dir) + name.len + 1);
	memset(dir, 0, sizeof(*dir));
256
	dir->refs = 1;
257
	dir->rooted_name[0] = '/';
Timo Teräs's avatar
Timo Teräs committed
258 259 260 261
	memcpy(dir->name, name.ptr, name.len);
	dir->name[name.len] = 0;
	dir->namelen = name.len;
	dir->hash = hash;
262
	apk_hash_insert_hashed(&db->installed.dirs, dir, hash);
263

264 265
	if (name.len == 0)
		dir->parent = NULL;
266
	else if (apk_blob_rsplit(name, '/', &bparent, NULL))
267
		dir->parent = apk_db_dir_get(db, bparent);
268
	else
269
		dir->parent = apk_db_dir_get(db, APK_BLOB_NULL);
270

271 272 273 274
	if (dir->parent != NULL)
		dir->flags = dir->parent->flags;

	for (i = 0; i < db->protected_paths->num; i++) {
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
		int flags = dir->flags, j;

		flags |= APK_DBDIRF_PROTECTED;
		for (j = 0; ; j++) {
			switch (db->protected_paths->item[i][j]) {
			case '-':
				flags &= ~(APK_DBDIRF_PROTECTED |
					   APK_DBDIRF_SYMLINKS_ONLY);
				continue;
			case '*':
				flags |= APK_DBDIRF_SYMLINKS_ONLY |
					 APK_DBDIRF_PROTECTED;
				continue;
			}
			break;
		}

		if (strcmp(&db->protected_paths->item[i][j], dir->name) == 0)
			dir->flags = flags;
294 295
	}

296 297 298
	return dir;
}

299 300 301
static struct apk_db_dir_instance *apk_db_diri_new(struct apk_database *db,
						   struct apk_package *pkg,
						   apk_blob_t name,
302
						   struct hlist_node ***after)
303 304 305 306
{
	struct apk_db_dir_instance *diri;

	diri = calloc(1, sizeof(struct apk_db_dir_instance));
307
	if (diri != NULL) {
308 309
		hlist_add_after(&diri->pkg_dirs_list, *after);
		*after = &diri->pkg_dirs_list.next;
310
		diri->dir = apk_db_dir_get(db, name);
311 312
		diri->pkg = pkg;
	}
313 314 315 316 317 318 319 320 321 322 323 324

	return diri;
}

static void apk_db_diri_set(struct apk_db_dir_instance *diri, mode_t mode,
			    uid_t uid, gid_t gid)
{
	diri->mode = mode;
	diri->uid = uid;
	diri->gid = gid;
}

325
static void apk_db_diri_mkdir(struct apk_database *db, struct apk_db_dir_instance *diri)
326
{
327 328 329 330
	if (mkdirat(db->root_fd, diri->dir->name, diri->mode) == 0) {
		if (fchownat(db->root_fd, diri->dir->name, diri->uid, diri->gid, 0) != 0)
			;
	}
331 332
}

333
static void apk_db_diri_free(struct apk_database *db,
334 335
			     struct apk_db_dir_instance *diri,
			     int allow_rmdir)
336
{
337
	apk_db_dir_unref(db, diri->dir, allow_rmdir);
338 339 340
	free(diri);
}

341 342 343 344 345 346 347 348 349 350 351 352 353 354 355
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;

	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
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
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;
}

378
static struct apk_db_file *apk_db_file_get(struct apk_database *db,
379
					   struct apk_db_dir_instance *diri,
380 381
					   apk_blob_t name,
					   struct hlist_node ***after)
382 383
{
	struct apk_db_file *file;
384
	struct apk_db_file_hash_key key;
Timo Teräs's avatar
Timo Teräs committed
385 386
	struct apk_db_dir *dir = diri->dir;
	unsigned long hash;
387 388

	key = (struct apk_db_file_hash_key) {
Timo Teräs's avatar
Timo Teräs committed
389
		.dirname = APK_BLOB_PTR_LEN(dir->name, dir->namelen),
390 391
		.filename = name,
	};
392

Timo Teräs's avatar
Timo Teräs committed
393 394 395
	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);
396 397 398
	if (file != NULL)
		return file;

Timo Teräs's avatar
Timo Teräs committed
399
	file = apk_db_file_new(diri, name, after);
Timo Teräs's avatar
Timo Teräs committed
400
	apk_hash_insert_hashed(&db->installed.files, file, hash);
401
	db->installed.stats.files++;
402 403 404 405

	return file;
}

Timo Teräs's avatar
Timo Teräs committed
406 407 408
static void apk_db_pkg_rdepends(struct apk_database *db, struct apk_package *pkg)
{
	int i, j;
Timo Teräs's avatar
Timo Teräs committed
409
	struct apk_name *rname;
Timo Teräs's avatar
Timo Teräs committed
410 411

	for (i = 0; i < pkg->depends->num; i++) {
Timo Teräs's avatar
Timo Teräs committed
412
		rname = pkg->depends->item[i].name;
Timo Teräs's avatar
Timo Teräs committed
413 414
		for (j = 0; j < rname->rdepends->num; j++)
			if (rname->rdepends->item[j] == pkg->name)
Timo Teräs's avatar
Timo Teräs committed
415
				goto rdeps_done;
Timo Teräs's avatar
Timo Teräs committed
416 417
		*apk_name_array_add(&rname->rdepends) = pkg->name;
	}
Timo Teräs's avatar
Timo Teräs committed
418 419 420 421 422 423 424 425 426 427
rdeps_done:
	for (i = 0; i < pkg->install_if->num; i++) {
		rname = pkg->install_if->item[i].name;
		for (j = 0; j < rname->rinstall_if->num; j++)
			if (rname->rinstall_if->item[j] == pkg->name)
				goto riif_done;
		*apk_name_array_add(&rname->rinstall_if) = pkg->name;
	}
riif_done:
	return;
Timo Teräs's avatar
Timo Teräs committed
428 429
}

430
struct apk_package *apk_db_pkg_add(struct apk_database *db, struct apk_package *pkg)
431 432 433
{
	struct apk_package *idb;

434
	if (pkg->license == NULL)
435
		pkg->license = apk_blob_atomize(APK_BLOB_NULL);
436

Timo Teräs's avatar
Timo Teräs committed
437
	idb = apk_hash_get(&db->available.packages, APK_BLOB_CSUM(pkg->csum));
438 439 440 441
	if (idb == NULL) {
		idb = pkg;
		apk_hash_insert(&db->available.packages, pkg);
		*apk_package_array_add(&pkg->name->pkgs) = pkg;
Timo Teräs's avatar
Timo Teräs committed
442
		apk_db_pkg_rdepends(db, pkg);
443 444
	} else {
		idb->repos |= pkg->repos;
445 446 447 448
		if (idb->filename == NULL && pkg->filename != NULL) {
			idb->filename = pkg->filename;
			pkg->filename = NULL;
		}
449 450 451 452 453
		if (idb->ipkg == NULL && pkg->ipkg != NULL) {
			idb->ipkg = pkg->ipkg;
			idb->ipkg->pkg = idb;
			pkg->ipkg = NULL;
		}
454 455 456 457 458
		apk_pkg_free(pkg);
	}
	return idb;
}

459
void apk_cache_format_index(apk_blob_t to, struct apk_repository *repo)
460
{
461
	/* APKINDEX.12345678.tar.gz */
462
	apk_blob_push_blob(&to, APK_BLOB_STR("APKINDEX."));
463 464
	apk_blob_push_hexdump(&to, APK_BLOB_PTR_LEN((char *) repo->csum.data,
						    APK_CACHE_CSUM_BYTES));
465
	apk_blob_push_blob(&to, APK_BLOB_STR(".tar.gz"));
466 467 468
	apk_blob_push_blob(&to, APK_BLOB_PTR_LEN("", 1));
}

469
int apk_cache_download(struct apk_database *db, const char *url, apk_blob_t *arch,
470 471 472 473 474
		       const char *item, const char *cacheitem, int verify)
{
	char fullurl[PATH_MAX];
	int r;

475 476 477 478 479 480 481 482
	if (arch != NULL)
		snprintf(fullurl, sizeof(fullurl), "%s%s" BLOB_FMT "/%s",
			 url, url[strlen(url)-1] == '/' ? "" : "/",
			 BLOB_PRINTF(*arch), item);
	else
		snprintf(fullurl, sizeof(fullurl), "%s%s/%s",
			 url, url[strlen(url)-1] == '/' ? "" : "/",
			 item);
483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500
	apk_message("fetch %s", fullurl);

	if (apk_flags & APK_SIMULATE)
		return 0;

	r = apk_url_download(fullurl, db->cachetmp_fd, cacheitem);
	if (r < 0)
		return r;

	if (verify != APK_SIGN_NONE) {
		struct apk_istream *is;
		struct apk_sign_ctx sctx;

		apk_sign_ctx_init(&sctx, APK_SIGN_VERIFY, NULL, db->keys_fd);
		is = apk_bstream_gunzip_mpart(
			apk_bstream_from_file(db->cachetmp_fd, cacheitem),
			apk_sign_ctx_mpart_cb, &sctx);

501
		r = apk_tar_parse(is, apk_sign_ctx_verify_tar, &sctx, FALSE, &db->id_cache);
502 503 504 505 506 507 508
		is->close(is);
		apk_sign_ctx_free(&sctx);
		if (r != 0) {
			unlinkat(db->cachetmp_fd, cacheitem, 0);
			return r;
		}
	}
509

510 511 512 513
	if (db->cachetmp_fd != db->cache_fd) {
		if (renameat(db->cachetmp_fd, cacheitem, db->cache_fd, cacheitem) < 0)
			return -errno;
	}
514

515
	return 0;
516 517
}

518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
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
543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569
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;
	struct apk_db_file *file;
	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;
		} else {
570 571
			diri = find_diri(ipkg, bdir, diri, &file_diri_node);
			if (diri == NULL) {
572 573
				diri = apk_db_diri_new(db, pkg, bdir, &diri_node);
				file_diri_node = &diri->owned_files.first;
574
			}
Timo Teräs's avatar
Timo Teräs committed
575 576 577 578 579 580 581
			file = apk_db_file_get(db, diri, bfile, &file_diri_node);
		}
	}

	return 0;
}

582
int apk_db_index_read(struct apk_database *db, struct apk_bstream *bs, int repo)
583 584
{
	struct apk_package *pkg = NULL;
585
	struct apk_installed_package *ipkg = NULL;
586
	struct apk_db_dir_instance *diri = NULL;
587
	struct apk_db_file *file = NULL;
588 589
	struct hlist_node **diri_node = NULL;
	struct hlist_node **file_diri_node = NULL;
590
	apk_blob_t token = APK_BLOB_STR("\n"), l;
591
	int field, r;
592

593 594 595 596
	while (!APK_BLOB_IS_NULL(l = bs->read(bs, token))) {
		if (l.len < 2 || l.ptr[1] != ':') {
			if (pkg == NULL)
				continue;
597

598
			if (repo >= 0)
599
				pkg->repos |= BIT(repo);
600

601
			if (apk_db_pkg_add(db, pkg) == NULL) {
602 603
				apk_error("Installed database load failed");
				return -1;
604
			}
605
			pkg = NULL;
606
			ipkg = NULL;
607 608
			continue;
		}
609

610 611 612 613 614 615 616 617
		/* Get field */
		field = l.ptr[0];
		l.ptr += 2;
		l.len -= 2;

		/* If no package, create new */
		if (pkg == NULL) {
			pkg = apk_pkg_new();
618
			ipkg = NULL;
619 620 621
			diri = NULL;
			file_diri_node = NULL;
		}
622

623
		/* Standard index line? */
624 625 626 627 628 629 630 631 632
		r = apk_pkg_add_info(db, pkg, field, l);
		if (r == 0) {
			if (repo == -1 && field == 'S') {
				/* 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);
			}
633 634
			continue;
		}
635 636
		if (repo != -1 || ipkg == NULL)
			continue;
637

638 639 640 641 642
		/* Check FDB special entries */
		switch (field) {
		case 'F':
			if (pkg->name == NULL) {
				apk_error("FDB directory entry before package entry");
643 644
				return -1;
			}
645 646 647 648 649 650 651 652
			diri = apk_db_diri_new(db, pkg, l, &diri_node);
			file_diri_node = &diri->owned_files.first;
			break;
		case 'M':
			if (diri == NULL) {
				apk_error("FDB directory metadata entry before directory entry");
				return -1;
			}
653 654 655 656 657
			diri->uid = apk_blob_pull_uint(&l, 10);
			apk_blob_pull_char(&l, ':');
			diri->gid = apk_blob_pull_uint(&l, 10);
			apk_blob_pull_char(&l, ':');
			diri->mode = apk_blob_pull_uint(&l, 8);
658 659 660 661 662 663
			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
664
			file = apk_db_file_get(db, diri, l, &file_diri_node);
665 666 667 668 669 670
			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
671
			apk_blob_pull_csum(&l, &file->csum);
672 673
			break;
		default:
674 675 676 677 678 679 680 681
			if (r != 0 && !(apk_flags & APK_FORCE)) {
				/* Installed db should not have unsupported fields */
				apk_error("This apk-tools is too old to handle installed packages");
				return -1;
			}
			/* Installed. So mark the package as installable. */
			pkg->filename = NULL;
			continue;
682
		}
683 684 685 686
		if (APK_BLOB_IS_NULL(l)) {
			apk_error("FDB format error in entry '%c'", field);
			return -1;
		}
687 688
	}

689
	return 0;
690 691
}

Timo Teräs's avatar
Timo Teräs committed
692
static int apk_db_write_fdb(struct apk_database *db, struct apk_ostream *os)
693
{
694
	struct apk_installed_package *ipkg;
695
	struct apk_package *pkg;
696
	struct apk_db_dir_instance *diri;
697
	struct apk_db_file *file;
698
	struct hlist_node *c1, *c2;
699
	char buf[1024];
700 701
	apk_blob_t bbuf = APK_BLOB_BUF(buf);
	int r;
702

703 704
	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		pkg = ipkg->pkg;
705 706 707
		r = apk_pkg_write_index_entry(pkg, os);
		if (r < 0)
			return r;
708

709
		hlist_for_each_entry(diri, c1, &ipkg->owned_dirs, pkg_dirs_list) {
710 711 712 713 714 715 716 717 718
			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"));
719

720
			hlist_for_each_entry(file, c2, &diri->owned_files, diri_files_list) {
721 722
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("R:"));
				apk_blob_push_blob(&bbuf, APK_BLOB_PTR_LEN(file->name, file->namelen));
Timo Teräs's avatar
Timo Teräs committed
723
				if (file->csum.type != APK_CHECKSUM_NONE) {
724
					apk_blob_push_blob(&bbuf, APK_BLOB_STR("\nZ:"));
Timo Teräs's avatar
Timo Teräs committed
725
					apk_blob_push_csum(&bbuf, &file->csum);
726
				}
727
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
728

729
				if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
730
					return -1;
731
				bbuf = APK_BLOB_BUF(buf);
732
			}
733
			if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
734
				return -1;
735
			bbuf = APK_BLOB_BUF(buf);
736
		}
Timo Teräs's avatar
Timo Teräs committed
737
		os->write(os, "\n", 1);
738 739 740 741 742
	}

	return 0;
}

Timo Teräs's avatar
Timo Teräs committed
743
static int apk_db_scriptdb_write(struct apk_database *db, struct apk_ostream *os)
744
{
745
	struct apk_installed_package *ipkg;
746
	struct apk_package *pkg;
Timo Teräs's avatar
Timo Teräs committed
747 748 749
	struct apk_file_info fi;
	char filename[256];
	apk_blob_t bfn;
750
	int r, i;
751
	time_t now = time(NULL);
752 753 754 755 756 757 758

	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;
759

Timo Teräs's avatar
Timo Teräs committed
760 761
			fi = (struct apk_file_info) {
				.name = filename,
762
				.size = ipkg->script[i].len,
Timo Teräs's avatar
Timo Teräs committed
763
				.mode = 0755 | S_IFREG,
764
				.mtime = now,
Timo Teräs's avatar
Timo Teräs committed
765 766 767 768 769 770
			};
			/* 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("-"));
771
			apk_blob_push_blob(&bfn, *pkg->version);
Timo Teräs's avatar
Timo Teräs committed
772 773 774
			apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
			apk_blob_push_csum(&bfn, &pkg->csum);
			apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
775
			apk_blob_push_blob(&bfn, APK_BLOB_STR(apk_script_types[i]));
Timo Teräs's avatar
Timo Teräs committed
776 777
			apk_blob_push_blob(&bfn, APK_BLOB_PTR_LEN("", 1));

778
			r = apk_tar_write_entry(os, &fi, ipkg->script[i].ptr);
Timo Teräs's avatar
Timo Teräs committed
779 780
			if (r < 0)
				return r;
781 782 783
		}
	}

784
	return apk_tar_write_entry(os, NULL, NULL);
785 786
}

Timo Teräs's avatar
Timo Teräs committed
787
static int apk_db_scriptdb_read_v1(struct apk_database *db, struct apk_istream *is)
788 789
{
	struct apk_package *pkg;
Timo Teräs's avatar
Timo Teräs committed
790 791 792 793 794 795
	struct {
		unsigned char md5sum[16];
		unsigned int type;
		unsigned int size;
	} hdr;
	struct apk_checksum csum;
796

797
	while (is->read(is, &hdr, sizeof(hdr)) == sizeof(hdr)) {
Timo Teräs's avatar
Timo Teräs committed
798 799 800 801
		memcpy(csum.data, hdr.md5sum, sizeof(hdr.md5sum));
		csum.type = APK_CHECKSUM_MD5;

		pkg = apk_db_get_pkg(db, &csum);
802 803
		if (pkg != NULL && pkg->ipkg != NULL)
			apk_ipkg_add_script(pkg->ipkg, is, hdr.type, hdr.size);
Timo Teräs's avatar
Timo Teräs committed
804 805
		else
			apk_istream_skip(is, hdr.size);
806 807 808 809 810
	}

	return 0;
}

Timo Teräs's avatar
Timo Teräs committed
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
static int apk_read_script_archive_entry(void *ctx,
					 const struct apk_file_info *ae,
					 struct apk_istream *is)
{
	struct apk_database *db = (struct apk_database *) ctx;
	struct apk_package *pkg;
	char *fncsum, *fnaction;
	struct apk_checksum csum;
	apk_blob_t blob;
	int type;

	if (!S_ISREG(ae->mode))
		return 0;

	/* The scripts db expects file names in format:
	 * pkgname-version.<hexdump of package checksum>.action */
	fnaction = memrchr(ae->name, '.', strlen(ae->name));
	if (fnaction == NULL || fnaction == ae->name)
		return 0;
	fncsum = memrchr(ae->name, '.', fnaction - ae->name - 1);
	if (fncsum == NULL)
		return 0;
	fnaction++;
	fncsum++;

	/* Parse it */
	type = apk_script_type(fnaction);
	if (type == APK_SCRIPT_INVALID)
		return 0;
	blob = APK_BLOB_PTR_PTR(fncsum, fnaction - 2);
	apk_blob_pull_csum(&blob, &csum);

	/* Attach script */
	pkg = apk_db_get_pkg(db, &csum);
845 846
	if (pkg != NULL && pkg->ipkg != NULL)
		apk_ipkg_add_script(pkg->ipkg, is, type, ae->size);
Timo Teräs's avatar
Timo Teräs committed
847 848 849 850

	return 0;
}

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871
static int parse_triggers(void *ctx, apk_blob_t blob)
{
	struct apk_installed_package *ipkg = ctx;

	if (blob.len == 0)
		return 0;

	*apk_string_array_add(&ipkg->triggers) = apk_blob_cstr(blob);
	return 0;
}

static void apk_db_triggers_write(struct apk_database *db, struct apk_ostream *os)
{
	struct apk_installed_package *ipkg;
	char buf[APK_BLOB_CHECKSUM_BUF];
	apk_blob_t bfn;
	int i;

	list_for_each_entry(ipkg, &db->installed.triggers, trigger_pkgs_list) {
		bfn = APK_BLOB_BUF(buf);
		apk_blob_push_csum(&bfn, &ipkg->pkg->csum);
872 873
		bfn = apk_blob_pushed(APK_BLOB_BUF(buf), bfn);
		os->write(os, bfn.ptr, bfn.len);
874

875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
		for (i = 0; i < ipkg->triggers->num; i++) {
			os->write(os, " ", 1);
			apk_ostream_write_string(os, ipkg->triggers->item[i]);
		}
		os->write(os, "\n", 1);
	}
}

static void apk_db_triggers_read(struct apk_database *db, struct apk_bstream *bs)
{
	struct apk_checksum csum;
	struct apk_package *pkg;
	struct apk_installed_package *ipkg;
	apk_blob_t l;

	while (!APK_BLOB_IS_NULL(l = bs->read(bs, APK_BLOB_STR("\n")))) {
		apk_blob_pull_csum(&l, &csum);
		apk_blob_pull_char(&l, ' ');

		pkg = apk_db_get_pkg(db, &csum);
		if (pkg == NULL || pkg->ipkg == NULL)
			continue;

		ipkg = pkg->ipkg;
		apk_blob_for_each_segment(l, " ", parse_triggers, ipkg);
Timo Teräs's avatar
Timo Teräs committed
900 901
		if (ipkg->triggers->num != 0 &&
		    !list_hashed(&ipkg->trigger_pkgs_list))
902 903 904 905 906
			list_add_tail(&ipkg->trigger_pkgs_list,
				      &db->installed.triggers);
	}
}

Timo Teräs's avatar
Timo Teräs committed
907
static int apk_db_read_state(struct apk_database *db, int flags)
908
{
909
	struct apk_istream *is;
910
	struct apk_bstream *bs;
Timo Teräs's avatar
Timo Teräs committed
911
	apk_blob_t blob;
912
	int i, r;
913 914 915 916 917 918 919 920 921

	/* Read:
	 * 1. installed repository
	 * 2. source repositories
	 * 3. master dependencies
	 * 4. package statuses
	 * 5. files db
	 * 6. script db
	 */
Timo Teräs's avatar
Timo Teräs committed
922
	if (!(flags & APK_OPENF_NO_WORLD)) {
923
		blob = apk_blob_from_file(db->root_fd, "var/lib/apk/world");
Timo Teräs's avatar
Timo Teräs committed
924 925 926 927
		if (APK_BLOB_IS_NULL(blob))
			return -ENOENT;
		apk_deps_parse(db, &db->world, blob);
		free(blob.ptr);
928

Timo Teräs's avatar
Timo Teräs committed
929
		for (i = 0; i < db->world->num; i++)
Timo Teräs's avatar
Timo Teräs committed
930 931
			db->world->item[i].name->flags |= APK_NAME_TOPLEVEL;
	}
932

Timo Teräs's avatar
Timo Teräs committed
933
	if (!(flags & APK_OPENF_NO_INSTALLED)) {
934
		bs = apk_bstream_from_file(db->root_fd, "var/lib/apk/installed");
935
		if (bs != NULL) {
936
			r = apk_db_index_read(db, bs, -1);
937
			bs->close(bs, NULL);
938 939
			if (r != 0)
				return -1;
Timo Teräs's avatar
Timo Teräs committed
940
		}
941

942 943 944 945 946
		bs = apk_bstream_from_file(db->root_fd, "var/lib/apk/triggers");
		if (bs != NULL) {
			apk_db_triggers_read(db, bs);
			bs->close(bs, NULL);
		}
947 948
	}

Timo Teräs's avatar
Timo Teräs committed
949
	if (!(flags & APK_OPENF_NO_SCRIPTS)) {
950
		is = apk_istream_from_file(db->root_fd, "var/lib/apk/scripts.tar");
Timo Teräs's avatar
Timo Teräs committed
951
		if (is != NULL) {
952
			apk_tar_parse(is, apk_read_script_archive_entry, db,
953
				      FALSE, &db->id_cache);
Timo Teräs's avatar
Timo Teräs committed
954
		} else {
955
			is = apk_istream_from_file(db->root_fd, "var/lib/apk/scripts");
Timo Teräs's avatar
Timo Teräs committed
956 957
			if (is != NULL)
				apk_db_scriptdb_read_v1(db, is);
Timo Teräs's avatar
Timo Teräs committed
958
		}
Timo Teräs's avatar
Timo Teräs committed
959 960
		if (is != NULL)
			is->close(is);
961 962 963 964 965
	}

	return 0;
}

966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994
struct index_write_ctx {
	struct apk_ostream *os;
	int count;
	int force;
};

static int write_index_entry(apk_hash_item item, void *ctx)
{
	struct index_write_ctx *iwctx = (struct index_write_ctx *) ctx;
	struct apk_package *pkg = (struct apk_package *) item;
	int r;

	if (!iwctx->force && pkg->filename == NULL)
		return 0;

	r = apk_pkg_write_index_entry(pkg, iwctx->os);
	if (r < 0)
		return r;

	if (iwctx->os->write(iwctx->os, "\n", 1) != 1)
		return -1;

	iwctx->count++;
	return 0;
}

static int apk_db_index_write_nr_cache(struct apk_database *db)
{
	struct index_write_ctx ctx = { NULL, 0, TRUE };
995
	struct apk_installed_package *ipkg;
996 997 998 999 1000 1001 1002 1003
	struct apk_ostream *os;
	int r;

	if (!apk_db_cache_active(db))
		return 0;

	/* Write list of installed non-repository packages to
	 * cached index file */
1004 1005 1006 1007
	os = apk_ostream_to_file(db->cache_fd,
				 "installed",
				 "installed.new",
				 0644);
1008 1009 1010
	if (os == NULL)
		return -1;

1011
	ctx.os = os;
1012 1013
	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		if (ipkg->pkg->repos != 0)
1014
			continue;
1015
		r = write_index_entry(ipkg->pkg, &ctx);
1016 1017 1018
		if (r != 0)
			return r;
	}
1019 1020 1021
	r = os->close(os);
	if (r < 0)
		return r;
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034

	return ctx.count;
}

int apk_db_index_write(struct apk_database *db, struct apk_ostream *os)
{
	struct index_write_ctx ctx = { os, 0, FALSE };

	apk_hash_foreach(&db->available.packages, write_index_entry, &ctx);

	return ctx.count;
}

1035 1036 1037 1038 1039 1040 1041 1042
static int add_protected_path(void *ctx, apk_blob_t blob)
{
	struct apk_database *db = (struct apk_database *) ctx;

	*apk_string_array_add(&db->protected_paths) = apk_blob_cstr(blob);
	return 0;
}

1043 1044 1045 1046
static int apk_db_create(struct apk_database *db)
{
	int fd;

1047 1048 1049 1050 1051 1052
	mkdirat(db->root_fd, "tmp", 01777);
	mkdirat(db->root_fd, "dev", 0755);
	mknodat(db->root_fd, "dev/null", 0666, makedev(1, 3));
	mkdirat(db->root_fd, "var", 0755);
	mkdirat(db->root_fd, "var/lib", 0755);
	mkdirat(db->root_fd, "var/lib/apk", 0755);
1053 1054
	mkdirat(db->root_fd, "var/cache", 0755);
	mkdirat(db->root_fd, "var/cache/misc", 0755);
Timo Teräs's avatar
Timo Teräs committed
1055
	mkdirat(db->root_fd, "var/lock", 0755);
1056

1057
	fd = openat(db->root_fd, "var/lib/apk/world", O_CREAT|O_RDWR|O_TRUNC|O_CLOEXEC, 0644);
1058 1059 1060 1061 1062 1063 1064
	if (fd < 0)
		return -errno;
	close(fd);

	return 0;
}

1065 1066 1067 1068
static void handle_alarm(int sig)
{
}

1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
static char *find_mountpoint(int atfd, const char *rel_path)
{
	struct mntent *me;
	struct stat64 st;
	FILE *f;
	char *ret = NULL;
	dev_t dev;

	if (fstatat64(atfd, rel_path, &st, 0) != 0)
		return NULL;
	dev = st.st_dev;

	f = setmntent("/proc/mounts", "r");
	if (f == NULL)
		return NULL;
	while ((me = getmntent(f)) != NULL) {
		if (strcmp(me->mnt_fsname, "rootfs") == 0)
			continue;
		if (fstatat64(atfd, me->mnt_dir, &st, 0) == 0 &&
		    st.st_dev == dev) {
			ret = strdup(me->mnt_dir);
			break;
		}
	}
	endmntent(f);

	return ret;
}

static int do_remount(const char *path, const char *option)
{
	pid_t pid;
	int status;

	pid = fork();
	if (pid < 0)
		return -errno;

	if (pid == 0) {
		execl("/bin/mount", "mount", "-o", "remount", "-o",
		      option, path, NULL);
		return 1;
	}

	waitpid(pid, &status, 0);
	if (!WIFEXITED(status))
		return -1;

	return WEXITSTATUS(status);
}

1120
int apk_db_open(struct apk_database *db, struct apk_db_options *dbopts)
1121
{
1122 1123
	const char *msg = NULL;
	struct apk_repository_list *repo = NULL;
Timo Teräs's avatar
Timo Teräs committed
1124
	struct apk_bstream *bs;
Timo Teräs's avatar
Timo Teräs committed
1125
	struct statfs stfs;
Timo Teräs's avatar
Timo Teräs committed
1126
	apk_blob_t blob;
1127
	int r, fd, rr = 0;
1128

1129
	memset(db, 0, sizeof(*db));
1130 1131 1132 1133
	if (apk_flags & APK_SIMULATE) {
		dbopts->open_flags &= ~(APK_OPENF_CREATE | APK_OPENF_WRITE);
		dbopts->open_flags |= APK_OPENF_READ;
	}
1134 1135 1136 1137 1138 1139
	if (dbopts->open_flags == 0) {
		msg = "Invalid open flags (internal error)";
		r = -1;
		goto ret_r;
	}

1140 1141
	apk_hash_init(&db->available.names, &pkg_name_hash_ops, 1000);
	apk_hash_init(&db->available.packages, &pkg_info_hash_ops, 4000);
Timo Teräs's avatar
Timo Teräs committed
1142 1143
	apk_hash_init(&db->installed.dirs, &dir_hash_ops, 2000);
	apk_hash_init(&db->installed.files, &file_hash_ops, 10000);
1144
	list_init(&db->installed.packages);
1145
	list_init(&db->installed.triggers);
Timo Teräs's avatar
Timo Teräs committed
1146 1147
	apk_dependency_array_init(&db->world);
	apk_string_array_init(&db->protected_paths);
1148
	db->permanent = 1;
1149

1150
	db->root = strdup(dbopts->root ?: "/");
1151
	db->root_fd = openat(AT_FDCWD, db->root, O_RDONLY | O_CLOEXEC);
1152
	if (db->root_fd < 0 && (dbopts->open_flags & APK_OPENF_CREATE)) {
1153
		mkdirat(AT_FDCWD, db->root, 0755);
1154
		db->root_fd = openat(AT_FDCWD, db->root, O_RDONLY | O_CLOEXEC);
1155 1156 1157 1158 1159
	}
	if (db->root_fd < 0) {
		msg = "Unable to open root";
		goto ret_errno;
	}
Timo Teräs's avatar
Timo Teräs committed
1160 1161
	if (fstatfs(db->root_fd, &stfs) == 0 &&
	    stfs.f_type == 0x01021994 /* TMPFS_MAGIC */)
1162 1163
		db->permanent = 0;

Timo Teräs's avatar
Timo Teräs committed
1164 1165
	apk_id_cache_init(&db->id_cache, db->root_fd);

1166
	if (dbopts->open_flags & APK_OPENF_WRITE) {
Timo Teräs's avatar
Timo Teräs committed
1167
		db->lock_fd = openat(db->root_fd, apk_lock_file,
1168
				     O_CREAT | O_RDWR | O_CLOEXEC, 0400);