database.c 48.8 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 <limits.h>
16 17 18
#include <unistd.h>
#include <malloc.h>
#include <string.h>
19
#include <stdlib.h>
20
#include <signal.h>
21
#include <sys/file.h>
22 23 24 25 26

#include "apk_defines.h"
#include "apk_package.h"
#include "apk_database.h"
#include "apk_state.h"
27
#include "apk_applet.h"
28
#include "apk_archive.h"
29

30
const char * const apkindex_tar_gz = "APKINDEX.tar.gz";
Timo Teräs's avatar
Timo Teräs committed
31
const char * const apk_index_gz = "APK_INDEX.gz";
Timo Teräs's avatar
Timo Teräs committed
32 33 34
static const char * const apk_static_cache_dir = "var/lib/apk";
static const char * const apk_linked_cache_dir = "etc/apk/cache";

35 36 37
struct install_ctx {
	struct apk_database *db;
	struct apk_package *pkg;
38
	struct apk_installed_package *ipkg;
39 40

	int script;
41
	char **script_args;
42
	int script_pending : 1;
43

44
	struct apk_db_dir_instance *diri;
Timo Teräs's avatar
Timo Teräs committed
45
	struct apk_checksum data_csum;
46
	struct apk_sign_ctx sctx;
47
	struct apk_name_array *replaces;
48

49 50 51 52 53
	apk_progress_cb cb;
	void *cb_ctx;
	size_t installed_size;
	size_t current_file_size;

54 55
	struct hlist_node **diri_node;
	struct hlist_node **file_diri_node;
56 57
};

58
static apk_blob_t pkg_name_get_key(apk_hash_item item)
59
{
60
	return APK_BLOB_STR(((struct apk_name *) item)->name);
61 62
}

63 64 65
static void pkg_name_free(struct apk_name *name)
{
	free(name->name);
66 67 68 69
	if (name->pkgs)
		free(name->pkgs);
	if (name->rdepends)
		free(name->rdepends);
70 71 72
	free(name);
}

73 74 75
static const struct apk_hash_ops pkg_name_hash_ops = {
	.node_offset = offsetof(struct apk_name, hash_node),
	.get_key = pkg_name_get_key,
76 77
	.hash_key = apk_blob_hash,
	.compare = apk_blob_compare,
78
	.delete_item = (apk_hash_delete_f) pkg_name_free,
79 80
};

81
static apk_blob_t pkg_info_get_key(apk_hash_item item)
82
{
Timo Teräs's avatar
Timo Teräs committed
83
	return APK_BLOB_CSUM(((struct apk_package *) item)->csum);
84 85
}

86
static unsigned long csum_hash(apk_blob_t csum)
87
{
88 89
	/* Checksum's highest bits have the most "randomness", use that
	 * directly as hash */
90
	return *(unsigned long *) csum.ptr;
91 92 93 94 95
}

static const struct apk_hash_ops pkg_info_hash_ops = {
	.node_offset = offsetof(struct apk_package, hash_node),
	.get_key = pkg_info_get_key,
96 97
	.hash_key = csum_hash,
	.compare = apk_blob_compare,
98 99 100
	.delete_item = (apk_hash_delete_f) apk_pkg_free,
};

101
static apk_blob_t apk_db_dir_get_key(apk_hash_item item)
102
{
Timo Teräs's avatar
Timo Teräs committed
103 104
	struct apk_db_dir *dir = (struct apk_db_dir *) item;
	return APK_BLOB_PTR_LEN(dir->name, dir->namelen);
105 106 107 108 109
}

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,
110 111
	.hash_key = apk_blob_hash,
	.compare = apk_blob_compare,
112 113 114
	.delete_item = (apk_hash_delete_f) free,
};

115 116 117 118 119 120
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)
121
{
122 123
	struct apk_db_file_hash_key *key = (struct apk_db_file_hash_key *) _key.ptr;

Timo Teräs's avatar
Timo Teräs committed
124
	return apk_blob_hash_seed(key->filename, apk_blob_hash(key->dirname));
125 126 127 128 129 130
}

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
131 132
	return apk_blob_hash_seed(APK_BLOB_PTR_LEN(dbf->name, dbf->namelen),
				  dbf->diri->dir->hash);
133 134 135 136 137 138
}

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
139
	struct apk_db_dir *dir = dbf->diri->dir;
140 141
	int r;

Timo Teräs's avatar
Timo Teräs committed
142 143
	r = apk_blob_compare(key->filename,
			     APK_BLOB_PTR_LEN(dbf->name, dbf->namelen));
144 145 146
	if (r != 0)
		return r;

Timo Teräs's avatar
Timo Teräs committed
147 148 149
	r = apk_blob_compare(key->dirname,
			     APK_BLOB_PTR_LEN(dir->name, dir->namelen));
	return r;
150 151 152 153
}

static const struct apk_hash_ops file_hash_ops = {
	.node_offset = offsetof(struct apk_db_file, hash_node),
154 155 156
	.hash_key = apk_db_file_hash_key,
	.hash_item = apk_db_file_hash_item,
	.compare_item = apk_db_file_compare_item,
157 158 159
	.delete_item = (apk_hash_delete_f) free,
};

Timo Teräs's avatar
Timo Teräs committed
160 161 162 163 164
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);
}

165
struct apk_name *apk_db_get_name(struct apk_database *db, apk_blob_t name)
166 167
{
	struct apk_name *pn;
168
	unsigned long hash = apk_hash_from_key(&db->available.names, name);
169

170
	pn = (struct apk_name *) apk_hash_get_hashed(&db->available.names, name, hash);
171 172 173 174 175 176 177
	if (pn != NULL)
		return pn;

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

178
	pn->name = apk_blob_cstr(name);
179
	pn->id = db->name_id++;
180
	apk_hash_insert_hashed(&db->available.names, pn, hash);
181 182 183 184

	return pn;
}

185
static void apk_db_dir_unref(struct apk_database *db, struct apk_db_dir *dir)
186 187 188 189 190 191 192 193
{
	dir->refs--;
	if (dir->refs > 0)
		return;

	db->installed.stats.dirs--;

	if (dir->parent != NULL)
194
		apk_db_dir_unref(db, dir->parent);
195 196
}

197
static struct apk_db_dir *apk_db_dir_ref(struct apk_db_dir *dir)
198 199 200 201 202
{
	dir->refs++;
	return dir;
}

203 204
struct apk_db_dir *apk_db_dir_query(struct apk_database *db,
				    apk_blob_t name)
205 206 207 208
{
	return (struct apk_db_dir *) apk_hash_get(&db->installed.dirs, name);
}

209 210
static struct apk_db_dir *apk_db_dir_get(struct apk_database *db,
					 apk_blob_t name)
211 212 213
{
	struct apk_db_dir *dir;
	apk_blob_t bparent;
214
	unsigned long hash = apk_hash_from_key(&db->installed.dirs, name);
215
	int i;
216

217
	if (name.len && name.ptr[name.len-1] == '/')
218 219
		name.len--;

220
	dir = (struct apk_db_dir *) apk_hash_get_hashed(&db->installed.dirs, name, hash);
221
	if (dir != NULL)
222
		return apk_db_dir_ref(dir);
223

224
	db->installed.stats.dirs++;
225 226
	dir = malloc(sizeof(*dir) + name.len + 1);
	memset(dir, 0, sizeof(*dir));
227
	dir->refs = 1;
Timo Teräs's avatar
Timo Teräs committed
228 229 230 231
	memcpy(dir->name, name.ptr, name.len);
	dir->name[name.len] = 0;
	dir->namelen = name.len;
	dir->hash = hash;
232
	apk_hash_insert_hashed(&db->installed.dirs, dir, hash);
233

234 235
	if (name.len == 0)
		dir->parent = NULL;
236
	else if (apk_blob_rsplit(name, '/', &bparent, NULL))
237
		dir->parent = apk_db_dir_get(db, bparent);
238
	else
239
		dir->parent = apk_db_dir_get(db, APK_BLOB_NULL);
240

241 242 243 244
	if (dir->parent != NULL)
		dir->flags = dir->parent->flags;

	for (i = 0; i < db->protected_paths->num; i++) {
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263
		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;
264 265
	}

266 267 268
	return dir;
}

269 270 271
static struct apk_db_dir_instance *apk_db_diri_new(struct apk_database *db,
						   struct apk_package *pkg,
						   apk_blob_t name,
272
						   struct hlist_node ***after)
273 274 275 276
{
	struct apk_db_dir_instance *diri;

	diri = calloc(1, sizeof(struct apk_db_dir_instance));
277
	if (diri != NULL) {
278 279
		hlist_add_after(&diri->pkg_dirs_list, *after);
		*after = &diri->pkg_dirs_list.next;
280
		diri->dir = apk_db_dir_get(db, name);
281 282
		diri->pkg = pkg;
	}
283 284 285 286 287 288 289 290 291 292 293 294

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

295
static void apk_db_diri_mkdir(struct apk_database *db, struct apk_db_dir_instance *diri)
296
{
297 298
	if (mkdirat(db->root_fd, diri->dir->name, diri->mode) == 0)
		fchownat(db->root_fd, diri->dir->name, diri->uid, diri->gid, 0);
299 300
}

301
static void apk_db_diri_rmdir(struct apk_database *db, struct apk_db_dir_instance *diri)
302
{
Timo Teräs's avatar
Timo Teräs committed
303
	if (diri->dir->refs == 1)
304
		unlinkat(db->root_fd, diri->dir->name, 1);
305 306
}

307 308 309
static void apk_db_diri_free(struct apk_database *db,
			     struct apk_db_dir_instance *diri)
{
310
	apk_db_dir_unref(db, diri->dir);
311 312 313
	free(diri);
}

314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
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
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
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;
}

351
static struct apk_db_file *apk_db_file_get(struct apk_database *db,
352
					   struct apk_db_dir_instance *diri,
353 354
					   apk_blob_t name,
					   struct hlist_node ***after)
355 356
{
	struct apk_db_file *file;
357
	struct apk_db_file_hash_key key;
Timo Teräs's avatar
Timo Teräs committed
358 359
	struct apk_db_dir *dir = diri->dir;
	unsigned long hash;
360 361

	key = (struct apk_db_file_hash_key) {
Timo Teräs's avatar
Timo Teräs committed
362
		.dirname = APK_BLOB_PTR_LEN(dir->name, dir->namelen),
363 364
		.filename = name,
	};
365

Timo Teräs's avatar
Timo Teräs committed
366 367 368
	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);
369 370 371
	if (file != NULL)
		return file;

Timo Teräs's avatar
Timo Teräs committed
372
	file = apk_db_file_new(diri, name, after);
Timo Teräs's avatar
Timo Teräs committed
373
	apk_hash_insert_hashed(&db->installed.files, file, hash);
374
	db->installed.stats.files++;
375 376 377 378

	return file;
}

Timo Teräs's avatar
Timo Teräs committed
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
static void apk_db_pkg_rdepends(struct apk_database *db, struct apk_package *pkg)
{
	int i, j;

	if (pkg->depends == NULL)
		return;

	for (i = 0; i < pkg->depends->num; i++) {
		struct apk_name *rname = pkg->depends->item[i].name;

		if (rname->rdepends) {
			for (j = 0; j < rname->rdepends->num; j++)
				if (rname->rdepends->item[j] == pkg->name)
					return;
		}
		*apk_name_array_add(&rname->rdepends) = pkg->name;
	}
}

398
struct apk_package *apk_db_pkg_add(struct apk_database *db, struct apk_package *pkg)
399 400 401
{
	struct apk_package *idb;

Timo Teräs's avatar
Timo Teräs committed
402
	idb = apk_hash_get(&db->available.packages, APK_BLOB_CSUM(pkg->csum));
403 404 405 406
	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
407
		apk_db_pkg_rdepends(db, pkg);
408 409
	} else {
		idb->repos |= pkg->repos;
410 411 412 413
		if (idb->filename == NULL && pkg->filename != NULL) {
			idb->filename = pkg->filename;
			pkg->filename = NULL;
		}
414 415 416 417 418
		if (idb->ipkg == NULL && pkg->ipkg != NULL) {
			idb->ipkg = pkg->ipkg;
			idb->ipkg->pkg = idb;
			pkg->ipkg = NULL;
		}
419 420 421 422 423
		apk_pkg_free(pkg);
	}
	return idb;
}

424
void apk_cache_format_index(apk_blob_t to, struct apk_repository *repo, int ver)
425
{
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
	/* APKINDEX.12345678.tar.gz */
	/* APK_INDEX.12345678.gz */
	if (ver == 0)
		apk_blob_push_blob(&to, APK_BLOB_STR("APKINDEX."));
	else
		apk_blob_push_blob(&to, APK_BLOB_STR("APK_INDEX."));
	apk_blob_push_hexdump(&to, APK_BLOB_PTR_LEN((char *) repo->csum.data,
						    APK_CACHE_CSUM_BYTES));
	if (ver == 0)
		apk_blob_push_blob(&to, APK_BLOB_STR(".tar.gz"));
	else
		apk_blob_push_blob(&to, APK_BLOB_STR(".gz"));
	apk_blob_push_blob(&to, APK_BLOB_PTR_LEN("", 1));
}

int apk_cache_download(struct apk_database *db, const char *url,
		       const char *item, const char *cacheitem, int verify)
{
	char fullurl[PATH_MAX];
	int r;

	snprintf(fullurl, sizeof(fullurl), "%s%s%s",
		 url, url[strlen(url)-1] == '/' ? "" : "/", item);
	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);

		r = apk_tar_parse(is, apk_sign_ctx_verify_tar, &sctx, FALSE);
		is->close(is);
		apk_sign_ctx_free(&sctx);
		if (r != 0) {
			unlinkat(db->cachetmp_fd, cacheitem, 0);
			return r;
		}
	}
475

476 477
	if (renameat(db->cachetmp_fd, cacheitem, db->cache_fd, cacheitem) < 0)
		return -errno;
478

479
	return 0;
480 481
}

482
int apk_db_index_read(struct apk_database *db, struct apk_bstream *bs, int repo)
483 484
{
	struct apk_package *pkg = NULL;
485
	struct apk_installed_package *ipkg = NULL;
486
	struct apk_db_dir_instance *diri = NULL;
487
	struct apk_db_file *file = NULL;
488 489
	struct hlist_node **diri_node = NULL;
	struct hlist_node **file_diri_node = NULL;
490 491
	apk_blob_t token = APK_BLOB_STR("\n"), l;
	int field;
492

493 494 495 496
	while (!APK_BLOB_IS_NULL(l = bs->read(bs, token))) {
		if (l.len < 2 || l.ptr[1] != ':') {
			if (pkg == NULL)
				continue;
497

498
			if (repo >= 0)
499
				pkg->repos |= BIT(repo);
500

501
			if (apk_db_pkg_add(db, pkg) == NULL) {
502 503
				apk_error("Installed database load failed");
				return -1;
504
			}
505
			pkg = NULL;
506
			ipkg = NULL;
507 508
			continue;
		}
509

510 511 512 513 514 515 516 517 518
		/* Get field */
		field = l.ptr[0];
		l.ptr += 2;
		l.len -= 2;

		/* If no package, create new */
		if (pkg == NULL) {
			pkg = apk_pkg_new();
			diri = NULL;
519
			diri_node = NULL;
520 521
			file_diri_node = NULL;
		}
522

523 524 525 526 527 528 529 530
		/* Standard index line? */
		if (apk_pkg_add_info(db, pkg, field, l) == 0)
			continue;

		if (repo != -1) {
			apk_error("Invalid index entry '%c'", field);
			return -1;
		}
531

532 533 534 535 536 537
		/* Create the installation entry */
		if (ipkg == NULL) {
			ipkg = apk_pkg_install(db, pkg);
			diri_node = hlist_tail_ptr(&ipkg->owned_dirs);
		}

538 539 540 541 542
		/* Check FDB special entries */
		switch (field) {
		case 'F':
			if (pkg->name == NULL) {
				apk_error("FDB directory entry before package entry");
543 544
				return -1;
			}
545 546 547 548 549 550 551 552
			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;
			}
553 554 555 556 557
			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);
558 559 560 561 562 563
			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
564
			file = apk_db_file_get(db, diri, l, &file_diri_node);
565 566 567 568 569 570
			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
571
			apk_blob_pull_csum(&l, &file->csum);
572 573 574 575
			break;
		default:
			apk_error("FDB entry '%c' unsupported", field);
			return -1;
576
		}
577 578 579 580
		if (APK_BLOB_IS_NULL(l)) {
			apk_error("FDB format error in entry '%c'", field);
			return -1;
		}
581 582
	}

583
	return 0;
584 585
}

Timo Teräs's avatar
Timo Teräs committed
586
static int apk_db_write_fdb(struct apk_database *db, struct apk_ostream *os)
587
{
588
	struct apk_installed_package *ipkg;
589
	struct apk_package *pkg;
590
	struct apk_db_dir_instance *diri;
591
	struct apk_db_file *file;
592
	struct hlist_node *c1, *c2;
593
	char buf[1024];
594 595
	apk_blob_t bbuf = APK_BLOB_BUF(buf);
	int r;
596

597 598
	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		pkg = ipkg->pkg;
599 600 601
		r = apk_pkg_write_index_entry(pkg, os);
		if (r < 0)
			return r;
602

603
		hlist_for_each_entry(diri, c1, &ipkg->owned_dirs, pkg_dirs_list) {
604 605 606 607 608 609 610 611 612
			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"));
613

614
			hlist_for_each_entry(file, c2, &diri->owned_files, diri_files_list) {
615 616
				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
617
				if (file->csum.type != APK_CHECKSUM_NONE) {
618
					apk_blob_push_blob(&bbuf, APK_BLOB_STR("\nZ:"));
Timo Teräs's avatar
Timo Teräs committed
619
					apk_blob_push_csum(&bbuf, &file->csum);
620
				}
621
				apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
622

623
				if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
624
					return -1;
625
				bbuf = APK_BLOB_BUF(buf);
626
			}
627
			if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
628
				return -1;
629
			bbuf = APK_BLOB_BUF(buf);
630
		}
Timo Teräs's avatar
Timo Teräs committed
631
		os->write(os, "\n", 1);
632 633 634 635 636
	}

	return 0;
}

Timo Teräs's avatar
Timo Teräs committed
637
static int apk_db_scriptdb_write(struct apk_database *db, struct apk_ostream *os)
638
{
639
	struct apk_installed_package *ipkg;
640
	struct apk_package *pkg;
Timo Teräs's avatar
Timo Teräs committed
641 642 643
	struct apk_file_info fi;
	char filename[256];
	apk_blob_t bfn;
644 645 646 647 648 649 650 651
	int r, i;

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

Timo Teräs's avatar
Timo Teräs committed
653 654
			fi = (struct apk_file_info) {
				.name = filename,
655
				.size = ipkg->script[i].len,
Timo Teräs's avatar
Timo Teräs committed
656 657 658 659 660 661 662 663 664 665 666
				.mode = 0755 | S_IFREG,
			};
			/* 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("-"));
			apk_blob_push_blob(&bfn, APK_BLOB_STR(pkg->version));
			apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
			apk_blob_push_csum(&bfn, &pkg->csum);
			apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
667
			apk_blob_push_blob(&bfn, APK_BLOB_STR(apk_script_types[i]));
Timo Teräs's avatar
Timo Teräs committed
668 669
			apk_blob_push_blob(&bfn, APK_BLOB_PTR_LEN("", 1));

670
			r = apk_tar_write_entry(os, &fi, ipkg->script[i].ptr);
Timo Teräs's avatar
Timo Teräs committed
671 672
			if (r < 0)
				return r;
673 674 675
		}
	}

676
	return apk_tar_write_entry(os, NULL, NULL);
677 678
}

Timo Teräs's avatar
Timo Teräs committed
679
static int apk_db_scriptdb_read_v1(struct apk_database *db, struct apk_istream *is)
680 681
{
	struct apk_package *pkg;
Timo Teräs's avatar
Timo Teräs committed
682 683 684 685 686 687
	struct {
		unsigned char md5sum[16];
		unsigned int type;
		unsigned int size;
	} hdr;
	struct apk_checksum csum;
688

689
	while (is->read(is, &hdr, sizeof(hdr)) == sizeof(hdr)) {
Timo Teräs's avatar
Timo Teräs committed
690 691 692 693
		memcpy(csum.data, hdr.md5sum, sizeof(hdr.md5sum));
		csum.type = APK_CHECKSUM_MD5;

		pkg = apk_db_get_pkg(db, &csum);
694 695
		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
696 697
		else
			apk_istream_skip(is, hdr.size);
698 699 700 701 702
	}

	return 0;
}

Timo Teräs's avatar
Timo Teräs committed
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
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);
737 738
	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
739 740 741 742

	return 0;
}

Timo Teräs's avatar
Timo Teräs committed
743
static int apk_db_read_state(struct apk_database *db, int flags)
744
{
745
	struct apk_istream *is;
746
	struct apk_bstream *bs;
Timo Teräs's avatar
Timo Teräs committed
747
	apk_blob_t blob;
748
	int i;
749 750 751 752 753 754 755 756 757

	/* 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
758
	if (!(flags & APK_OPENF_NO_WORLD)) {
759
		blob = apk_blob_from_file(db->root_fd, "var/lib/apk/world");
Timo Teräs's avatar
Timo Teräs committed
760 761 762 763
		if (APK_BLOB_IS_NULL(blob))
			return -ENOENT;
		apk_deps_parse(db, &db->world, blob);
		free(blob.ptr);
764

Timo Teräs's avatar
Timo Teräs committed
765
		for (i = 0; db->world != NULL && i < db->world->num; i++)
Timo Teräs's avatar
Timo Teräs committed
766 767
			db->world->item[i].name->flags |= APK_NAME_TOPLEVEL;
	}
768

Timo Teräs's avatar
Timo Teräs committed
769
	if (!(flags & APK_OPENF_NO_INSTALLED)) {
770
		bs = apk_bstream_from_file(db->root_fd, "var/lib/apk/installed");
771 772 773
		if (bs != NULL) {
			apk_db_index_read(db, bs, -1);
			bs->close(bs, NULL);
Timo Teräs's avatar
Timo Teräs committed
774
		}
775

776 777 778 779 780 781
		if (apk_db_cache_active(db)) {
			bs = apk_bstream_from_file(db->cache_fd, "installed");
			if (bs != NULL) {
				apk_db_index_read(db, bs, -2);
				bs->close(bs, NULL);
			}
782
		}
783 784
	}

Timo Teräs's avatar
Timo Teräs committed
785
	if (!(flags & APK_OPENF_NO_SCRIPTS)) {
786
		is = apk_istream_from_file(db->root_fd, "var/lib/apk/scripts.tar");
Timo Teräs's avatar
Timo Teräs committed
787
		if (is != NULL) {
788 789
			apk_tar_parse(is, apk_read_script_archive_entry, db,
				      FALSE);
Timo Teräs's avatar
Timo Teräs committed
790
		} else {
791
			is = apk_istream_from_file(db->root_fd, "var/lib/apk/scripts");
Timo Teräs's avatar
Timo Teräs committed
792 793
			if (is != NULL)
				apk_db_scriptdb_read_v1(db, is);
Timo Teräs's avatar
Timo Teräs committed
794
		}
Timo Teräs's avatar
Timo Teräs committed
795 796
		if (is != NULL)
			is->close(is);
797 798 799 800 801
	}

	return 0;
}

802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830
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 };
831
	struct apk_installed_package *ipkg;
832 833 834 835 836 837 838 839
	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 */
840 841 842 843
	os = apk_ostream_to_file(db->cache_fd,
				 "installed",
				 "installed.new",
				 0644);
844 845 846
	if (os == NULL)
		return -1;

847
	ctx.os = os;
848 849
	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		if (ipkg->pkg->repos != 0)
850
			continue;
851
		r = write_index_entry(ipkg->pkg, &ctx);
852 853 854
		if (r != 0)
			return r;
	}
855 856 857
	r = os->close(os);
	if (r < 0)
		return r;
858 859 860 861 862 863 864 865 866 867 868 869 870

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

871 872 873 874 875 876 877 878
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;
}

879 880 881 882
static int apk_db_create(struct apk_database *db)
{
	int fd;

883 884 885 886 887 888
	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);
889 890
	mkdirat(db->root_fd, "var/cache", 0755);
	mkdirat(db->root_fd, "var/cache/misc", 0755);
891

892
	fd = openat(db->root_fd, "var/lib/apk/world", O_CREAT|O_RDWR|O_TRUNC, 0644);
893 894 895 896 897 898 899
	if (fd < 0)
		return -errno;
	close(fd);

	return 0;
}

900 901 902 903
static void handle_alarm(int sig)
{
}

904
int apk_db_open(struct apk_database *db, struct apk_db_options *dbopts)
905
{
906 907
	const char *msg = NULL;
	struct apk_repository_list *repo = NULL;
908
	struct stat64 st;
Timo Teräs's avatar
Timo Teräs committed
909
	apk_blob_t blob;
910
	int r, rr = 0;
911

912
	memset(db, 0, sizeof(*db));
913 914 915 916 917 918
	if (dbopts->open_flags == 0) {
		msg = "Invalid open flags (internal error)";
		r = -1;
		goto ret_r;
	}

919 920
	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
921 922
	apk_hash_init(&db->installed.dirs, &dir_hash_ops, 2000);
	apk_hash_init(&db->installed.files, &file_hash_ops, 10000);
923
	list_init(&db->installed.packages);
Timo Teräs's avatar
Timo Teräs committed
924
	db->cache_dir = apk_static_cache_dir;
925
	db->permanent = 1;
926

927
	db->root = strdup(dbopts->root ?: "/");
928
	db->root_fd = openat(AT_FDCWD, db->root, O_RDONLY);
929
	if (db->root_fd < 0 && (dbopts->open_flags & APK_OPENF_CREATE)) {
930
		mkdirat(AT_FDCWD, db->root, 0755);
931
		db->root_fd = openat(AT_FDCWD, db->root, O_RDONLY);
932 933 934 935 936 937 938 939 940 941 942 943
	}
	if (db->root_fd < 0) {
		msg = "Unable to open root";
		goto ret_errno;
	}
	if (fstat64(db->root_fd, &st) != 0 || major(st.st_dev) == 0)
		db->permanent = 0;

	if (fstatat64(db->root_fd, apk_linked_cache_dir, &st, 0) == 0 &&
	    S_ISDIR(st.st_mode))
		db->cache_dir = apk_linked_cache_dir;

944
	if (dbopts->open_flags & APK_OPENF_WRITE) {
945 946 947
		db->lock_fd = openat(db->root_fd, "var/lib/apk/lock",
				     O_CREAT | O_RDWR, 0400);
		if (db->lock_fd < 0 && errno == ENOENT &&
948
		    (dbopts->open_flags & APK_OPENF_CREATE)) {
949 950 951 952 953
			r = apk_db_create(db);
			if (r != 0) {
				msg = "Unable to create database";
				goto ret_r;
			}
954 955
			db->lock_fd = openat(db->root_fd, "var/lib/apk/lock",
					     O_CREAT | O_RDWR, 0400);
956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
		}
		if (db->lock_fd < 0 ||
		    flock(db->lock_fd, LOCK_EX | LOCK_NB) < 0) {
			msg = "Unable to lock database";
			if (apk_wait) {
				struct sigaction sa, old_sa;

				apk_message("Waiting for repository lock");
				memset(&sa, 0, sizeof sa);
				sa.sa_handler = handle_alarm;
				sa.sa_flags   = SA_ONESHOT;
				sigaction(SIGALRM, &sa, &old_sa);

				alarm(apk_wait);
				if (flock(db->lock_fd, LOCK_EX) < 0)
Timo Teräs's avatar
Timo Teräs committed
971
					goto ret_errno;
972 973 974 975 976

				alarm(0);
				sigaction(SIGALRM, &old_sa, NULL);
			} else
				goto ret_errno;
977 978
		}
	}
979

980
	blob = APK_BLOB_STR("etc:*etc/init.d");
981 982
	apk_blob_for_each_segment(blob, ":", add_protected_path, db);

983 984 985
	db->cache_fd = openat(db->root_fd, db->cache_dir, O_RDONLY);
	mkdirat(db->cache_fd, "tmp", 0644);
	db->cachetmp_fd = openat(db->cache_fd, "tmp", O_RDONLY);
986 987 988
	db->keys_fd = openat(db->root_fd,
			     dbopts->keys_dir ?: "etc/apk/keys",
			     O_RDONLY);
989

990 991
	r = apk_db_read_state(db, dbopts->open_flags);
	if (r == -ENOENT && (dbopts->open_flags & APK_OPENF_CREATE)) {
992
		r = apk_db_create(db);
Timo Teräs's avatar
Timo Teräs committed
993
		if (r != 0) {
994
			msg = "Unable to create database";
Timo Teräs's avatar
Timo Teräs committed
995
			goto ret_r;
996
		}
997
		r = apk_db_read_state(db, dbopts->open_flags);
998 999 1000 1001
	}
	if (r != 0) {
		msg = "Unable to read database state";
		goto ret_r;
1002 1003
	}

1004 1005
	if (!(dbopts->open_flags & APK_OPENF_NO_REPOS)) {
		list_for_each_entry(repo, &dbopts->repository_list, list) {
1006 1007 1008
			r = apk_db_add_repository(db, APK_BLOB_STR(repo->url));
			rr = r ?: rr;
		}
1009 1010 1011
		blob = apk_blob_from_file(
			db->root_fd,
			dbopts->repositories_file ?: "etc/apk/repositories");
1012 1013 1014 1015 1016 1017 1018
		if (!APK_BLOB_IS_NULL(blob)) {
			r = apk_blob_for_each_segment(
				blob, "\n",
				apk_db_add_repository, db);
			rr = r ?: rr;
			free(blob.ptr);
		}
1019 1020
		if (apk_flags & APK_UPDATE_CACHE)
			apk_db_index_write_nr_cache(db);
1021
	}
1022 1023 1024 1025
	if (rr != 0) {
		r = rr;
		goto ret_r;
	}
1026

1027
	return rr;
1028 1029 1030 1031

ret_errno:
	r = -errno;
ret_r:
Natanael Copa's avatar
Natanael Copa committed
1032 1033
	if (msg != NULL)
		apk_error("%s: %s", msg, strerror(-r));
1034
	apk_db_close(db);
1035

1036
	return r;
1037 1038
}

1039 1040 1041 1042 1043
struct write_ctx {
	struct apk_database *db;
	int fd;
};

1044
int apk_db_write_config(struct apk_database *db)
1045
{
Timo Teräs's avatar
Timo Teräs committed
1046
	struct apk_ostream *os;
1047
	int r;
1048 1049

	if (db->root == NULL)
1050
		return 0;
1051

1052 1053 1054 1055 1056
	if (db->lock_fd == 0) {
		apk_error("Refusing to write db without write lock!");
		return -1;
	}

1057 1058 1059 1060
	os = apk_ostream_to_file(db->root_fd,
				 "var/lib/apk/world",
				 "var/lib/apk/world.new",
				 0644);
Timo Teräs's avatar
Timo Teräs committed
1061
	if (os == NULL)
1062
		return -1;
1063

1064 1065
	apk_deps_write(db->world, os);
	os->write(os, "\n", 1);
1066 1067 1068
	r = os->close(os);
	if (r < 0)
		return r;
1069

1070 1071 1072 1073
	os = apk_ostream_to_file(db->root_fd,
				 "var/lib/apk/installed",
				 "var/lib/apk/installed.new",
				 0644);
Timo Teräs's avatar
Timo Teräs committed
1074
	if (os == NULL)
1075
		return -1;
Timo Teräs's avatar
Timo Teräs committed
1076
	apk_db_write_fdb(db, os);
1077 1078 1079
	r = os->close(os);
	if (r < 0)
		return r;
1080

1081 1082 1083 1084
	os = apk_ostream_to_file(db->root_fd,
				 "var/lib/apk/scripts.tar",
				 "var/lib/apk/scripts.tar.new",
				 0644);
Timo Teräs's avatar
Timo Teräs committed
1085
	if (os == NULL)
1086
		return -1;
Timo Teräs's avatar
Timo Teräs committed
1087
	apk_db_scriptdb_write(db, os);
1088 1089 1090
	r = os->close(os);
	if (r < 0)
		return r;
Timo Teräs's avatar
Timo Teräs committed
1091

1092
	unlinkat(db->root_fd, "var/lib/apk/scripts", 0);
1093
	apk_db_index_write_nr_cache(db);
1094 1095 1096 1097

	return 0;
}

1098
void apk_db_close(struct apk_database *db)
1099
{
1100
	struct apk_installed_package *ipkg;
1101
	struct apk_db_dir_instance *diri;
1102
	struct hlist_node *dc, *dn;
1103 1104
	int i;

1105 1106
	list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
		hlist_for_each_entry_safe(diri, dc, dn, &ipkg->owned_dirs, pkg_dirs_list) {
1107 1108 1109 1110
			apk_db_diri_free(db, diri);
		}
	}

1111
	for (i = 0; i < db->num_repos; i++) {
1112
		free(db->repos[i].url);
1113
	}
1114 1115 1116 1117 1118 1119 1120
	if (db->protected_paths) {
		for (i = 0; i < db->protected_paths->num; i++)
			free(db->protected_paths->item[i]);
		free(db->protected_paths);
	}
	if (db->world)
		free(db->world);
1121

1122 1123
	apk_hash_free(&db->available.names);
	apk_hash_free(&db->available.packages);