2008-04-17 14:09:13 +00:00
|
|
|
/* database.c - Alpine Package Keeper (APK)
|
|
|
|
*
|
|
|
|
* Copyright (C) 2005-2008 Natanael Copa <n@tanael.org>
|
2009-07-24 11:00:57 +00:00
|
|
|
* Copyright (C) 2008-2009 Timo Teräs <timo.teras@iki.fi>
|
2008-04-17 14:09:13 +00:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
2009-06-28 15:05:17 +00:00
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
2008-04-17 14:09:13 +00:00
|
|
|
* 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>
|
2011-03-16 12:55:08 +00:00
|
|
|
#include <mntent.h>
|
2008-11-14 12:26:59 +00:00
|
|
|
#include <limits.h>
|
2008-04-17 14:09:13 +00:00
|
|
|
#include <unistd.h>
|
|
|
|
#include <malloc.h>
|
|
|
|
#include <string.h>
|
2009-01-08 07:15:16 +00:00
|
|
|
#include <stdlib.h>
|
2009-07-07 07:30:54 +00:00
|
|
|
#include <signal.h>
|
2009-08-13 11:10:30 +00:00
|
|
|
#include <fnmatch.h>
|
2011-03-16 11:18:54 +00:00
|
|
|
#include <sys/vfs.h>
|
2009-01-17 09:07:56 +00:00
|
|
|
#include <sys/file.h>
|
2011-03-16 12:55:08 +00:00
|
|
|
#include <sys/wait.h>
|
2010-08-30 13:04:25 +00:00
|
|
|
#include <sys/stat.h>
|
2011-03-16 12:55:08 +00:00
|
|
|
#include <sys/statvfs.h>
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
#include "apk_defines.h"
|
|
|
|
#include "apk_package.h"
|
|
|
|
#include "apk_database.h"
|
|
|
|
#include "apk_state.h"
|
2008-04-21 16:30:10 +00:00
|
|
|
#include "apk_applet.h"
|
2009-07-20 08:13:03 +00:00
|
|
|
#include "apk_archive.h"
|
2010-03-05 08:13:25 +00:00
|
|
|
#include "apk_print.h"
|
|
|
|
|
2010-12-14 15:04:26 +00:00
|
|
|
#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
|
|
|
|
|
2010-09-22 14:16:18 +00:00
|
|
|
enum {
|
|
|
|
APK_DISALLOW_RMDIR = 0,
|
|
|
|
APK_ALLOW_RMDIR = 1
|
|
|
|
};
|
|
|
|
|
2010-03-05 08:13:25 +00:00
|
|
|
int apk_verbosity = 1;
|
|
|
|
unsigned int apk_flags = 0;
|
2010-12-14 15:04:26 +00:00
|
|
|
const char *apk_arch = APK_DEFAULT_ARCH;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-07-20 08:13:03 +00:00
|
|
|
const char * const apkindex_tar_gz = "APKINDEX.tar.gz";
|
2011-03-16 14:52:14 +00:00
|
|
|
static const char * const apk_static_cache_dir = "var/cache/apk";
|
2009-06-28 17:36:16 +00:00
|
|
|
static const char * const apk_linked_cache_dir = "etc/apk/cache";
|
2011-03-16 14:52:14 +00:00
|
|
|
|
2011-03-16 13:39:36 +00:00
|
|
|
static const char * const apk_lock_file = "var/lock/apkdb";
|
2009-06-28 17:36:16 +00:00
|
|
|
|
2011-03-16 14:52:14 +00:00
|
|
|
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";
|
|
|
|
|
|
|
|
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";
|
|
|
|
|
|
|
|
static const char * const apk_installed_file = "lib/apk/db/installed";
|
|
|
|
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";
|
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
struct install_ctx {
|
|
|
|
struct apk_database *db;
|
|
|
|
struct apk_package *pkg;
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
int script;
|
2009-08-12 16:17:46 +00:00
|
|
|
char **script_args;
|
2009-07-21 11:06:35 +00:00
|
|
|
int script_pending : 1;
|
2009-08-12 16:17:46 +00:00
|
|
|
|
2009-01-06 17:44:54 +00:00
|
|
|
struct apk_db_dir_instance *diri;
|
2009-07-14 16:14:05 +00:00
|
|
|
struct apk_checksum data_csum;
|
2009-07-21 10:49:35 +00:00
|
|
|
struct apk_sign_ctx sctx;
|
2009-08-04 13:54:15 +00:00
|
|
|
struct apk_name_array *replaces;
|
2009-01-06 17:44:54 +00:00
|
|
|
|
2009-01-07 19:45:11 +00:00
|
|
|
apk_progress_cb cb;
|
|
|
|
void *cb_ctx;
|
|
|
|
size_t installed_size;
|
|
|
|
size_t current_file_size;
|
|
|
|
|
2009-01-06 17:44:54 +00:00
|
|
|
struct hlist_node **diri_node;
|
|
|
|
struct hlist_node **file_diri_node;
|
2008-04-17 14:09:13 +00:00
|
|
|
};
|
|
|
|
|
2008-11-27 18:25:01 +00:00
|
|
|
static apk_blob_t pkg_name_get_key(apk_hash_item item)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2008-11-27 18:25:01 +00:00
|
|
|
return APK_BLOB_STR(((struct apk_name *) item)->name);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 17:48:30 +00:00
|
|
|
static void pkg_name_free(struct apk_name *name)
|
|
|
|
{
|
|
|
|
free(name->name);
|
2010-06-05 09:06:41 +00:00
|
|
|
apk_package_array_free(&name->pkgs);
|
|
|
|
apk_name_array_free(&name->rdepends);
|
2011-01-04 08:05:20 +00:00
|
|
|
apk_name_array_free(&name->rinstall_if);
|
2009-01-14 17:48:30 +00:00
|
|
|
free(name);
|
|
|
|
}
|
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
static const struct apk_hash_ops pkg_name_hash_ops = {
|
|
|
|
.node_offset = offsetof(struct apk_name, hash_node),
|
|
|
|
.get_key = pkg_name_get_key,
|
2008-11-27 18:25:01 +00:00
|
|
|
.hash_key = apk_blob_hash,
|
|
|
|
.compare = apk_blob_compare,
|
2009-01-14 17:48:30 +00:00
|
|
|
.delete_item = (apk_hash_delete_f) pkg_name_free,
|
2008-04-17 14:09:13 +00:00
|
|
|
};
|
|
|
|
|
2008-11-27 18:25:01 +00:00
|
|
|
static apk_blob_t pkg_info_get_key(apk_hash_item item)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2009-07-14 16:14:05 +00:00
|
|
|
return APK_BLOB_CSUM(((struct apk_package *) item)->csum);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2008-11-27 18:25:01 +00:00
|
|
|
static unsigned long csum_hash(apk_blob_t csum)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2008-11-27 18:25:01 +00:00
|
|
|
/* Checksum's highest bits have the most "randomness", use that
|
|
|
|
* directly as hash */
|
2008-11-28 11:15:06 +00:00
|
|
|
return *(unsigned long *) csum.ptr;
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct apk_hash_ops pkg_info_hash_ops = {
|
|
|
|
.node_offset = offsetof(struct apk_package, hash_node),
|
|
|
|
.get_key = pkg_info_get_key,
|
2008-11-27 18:25:01 +00:00
|
|
|
.hash_key = csum_hash,
|
|
|
|
.compare = apk_blob_compare,
|
2008-04-17 14:09:13 +00:00
|
|
|
.delete_item = (apk_hash_delete_f) apk_pkg_free,
|
|
|
|
};
|
|
|
|
|
2008-11-27 18:25:01 +00:00
|
|
|
static apk_blob_t apk_db_dir_get_key(apk_hash_item item)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2009-07-14 08:55:08 +00:00
|
|
|
struct apk_db_dir *dir = (struct apk_db_dir *) item;
|
|
|
|
return APK_BLOB_PTR_LEN(dir->name, dir->namelen);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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,
|
2008-11-27 18:25:01 +00:00
|
|
|
.hash_key = apk_blob_hash,
|
|
|
|
.compare = apk_blob_compare,
|
2008-04-17 14:09:13 +00:00
|
|
|
.delete_item = (apk_hash_delete_f) free,
|
|
|
|
};
|
|
|
|
|
2009-01-14 08:44:47 +00:00
|
|
|
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)
|
2009-01-13 18:32:18 +00:00
|
|
|
{
|
2009-01-14 08:44:47 +00:00
|
|
|
struct apk_db_file_hash_key *key = (struct apk_db_file_hash_key *) _key.ptr;
|
|
|
|
|
2009-07-14 08:55:08 +00:00
|
|
|
return apk_blob_hash_seed(key->filename, apk_blob_hash(key->dirname));
|
2009-01-14 08:44:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long apk_db_file_hash_item(apk_hash_item item)
|
|
|
|
{
|
|
|
|
struct apk_db_file *dbf = (struct apk_db_file *) item;
|
|
|
|
|
2009-07-14 08:55:08 +00:00
|
|
|
return apk_blob_hash_seed(APK_BLOB_PTR_LEN(dbf->name, dbf->namelen),
|
|
|
|
dbf->diri->dir->hash);
|
2009-01-14 08:44:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
2009-07-14 08:55:08 +00:00
|
|
|
struct apk_db_dir *dir = dbf->diri->dir;
|
2009-01-14 08:44:47 +00:00
|
|
|
int r;
|
|
|
|
|
2009-07-14 08:55:08 +00:00
|
|
|
r = apk_blob_compare(key->filename,
|
|
|
|
APK_BLOB_PTR_LEN(dbf->name, dbf->namelen));
|
2009-01-14 08:44:47 +00:00
|
|
|
if (r != 0)
|
|
|
|
return r;
|
|
|
|
|
2009-07-14 08:55:08 +00:00
|
|
|
r = apk_blob_compare(key->dirname,
|
|
|
|
APK_BLOB_PTR_LEN(dir->name, dir->namelen));
|
|
|
|
return r;
|
2009-01-13 18:32:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct apk_hash_ops file_hash_ops = {
|
|
|
|
.node_offset = offsetof(struct apk_db_file, hash_node),
|
2009-01-14 08:44:47 +00:00
|
|
|
.hash_key = apk_db_file_hash_key,
|
|
|
|
.hash_item = apk_db_file_hash_item,
|
|
|
|
.compare_item = apk_db_file_compare_item,
|
2009-01-13 18:32:18 +00:00
|
|
|
.delete_item = (apk_hash_delete_f) free,
|
|
|
|
};
|
|
|
|
|
2009-01-13 12:09:45 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2008-11-27 18:25:01 +00:00
|
|
|
struct apk_name *apk_db_get_name(struct apk_database *db, apk_blob_t name)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
|
|
|
struct apk_name *pn;
|
2009-07-14 07:47:20 +00:00
|
|
|
unsigned long hash = apk_hash_from_key(&db->available.names, name);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-07-14 07:47:20 +00:00
|
|
|
pn = (struct apk_name *) apk_hash_get_hashed(&db->available.names, name, hash);
|
2008-04-17 14:09:13 +00:00
|
|
|
if (pn != NULL)
|
|
|
|
return pn;
|
|
|
|
|
|
|
|
pn = calloc(1, sizeof(struct apk_name));
|
|
|
|
if (pn == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2008-11-27 18:25:01 +00:00
|
|
|
pn->name = apk_blob_cstr(name);
|
2009-04-14 15:48:02 +00:00
|
|
|
pn->id = db->name_id++;
|
2010-06-05 09:06:41 +00:00
|
|
|
apk_package_array_init(&pn->pkgs);
|
|
|
|
apk_name_array_init(&pn->rdepends);
|
2011-01-04 08:05:20 +00:00
|
|
|
apk_name_array_init(&pn->rinstall_if);
|
2009-07-14 07:47:20 +00:00
|
|
|
apk_hash_insert_hashed(&db->available.names, pn, hash);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
return pn;
|
|
|
|
}
|
|
|
|
|
2010-09-22 14:16:18 +00:00
|
|
|
static void apk_db_dir_unref(struct apk_database *db, struct apk_db_dir *dir,
|
|
|
|
int allow_rmdir)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
|
|
|
dir->refs--;
|
|
|
|
if (dir->refs > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
db->installed.stats.dirs--;
|
2010-09-22 14:16:18 +00:00
|
|
|
if (allow_rmdir)
|
|
|
|
unlinkat(db->root_fd, dir->name, AT_REMOVEDIR);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
if (dir->parent != NULL)
|
2010-09-22 14:16:18 +00:00
|
|
|
apk_db_dir_unref(db, dir->parent, allow_rmdir);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-01-13 18:32:18 +00:00
|
|
|
static struct apk_db_dir *apk_db_dir_ref(struct apk_db_dir *dir)
|
2009-01-06 17:44:54 +00:00
|
|
|
{
|
|
|
|
dir->refs++;
|
|
|
|
return dir;
|
|
|
|
}
|
|
|
|
|
2009-01-14 17:48:30 +00:00
|
|
|
struct apk_db_dir *apk_db_dir_query(struct apk_database *db,
|
|
|
|
apk_blob_t name)
|
2009-01-13 13:22:14 +00:00
|
|
|
{
|
|
|
|
return (struct apk_db_dir *) apk_hash_get(&db->installed.dirs, name);
|
|
|
|
}
|
|
|
|
|
2009-01-13 18:32:18 +00:00
|
|
|
static struct apk_db_dir *apk_db_dir_get(struct apk_database *db,
|
|
|
|
apk_blob_t name)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
|
|
|
struct apk_db_dir *dir;
|
|
|
|
apk_blob_t bparent;
|
2009-07-14 07:47:20 +00:00
|
|
|
unsigned long hash = apk_hash_from_key(&db->installed.dirs, name);
|
2008-11-14 12:26:59 +00:00
|
|
|
int i;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2008-04-21 16:30:10 +00:00
|
|
|
if (name.len && name.ptr[name.len-1] == '/')
|
2008-04-17 14:09:13 +00:00
|
|
|
name.len--;
|
|
|
|
|
2009-07-14 07:47:20 +00:00
|
|
|
dir = (struct apk_db_dir *) apk_hash_get_hashed(&db->installed.dirs, name, hash);
|
2008-04-17 14:09:13 +00:00
|
|
|
if (dir != NULL)
|
2009-01-13 18:32:18 +00:00
|
|
|
return apk_db_dir_ref(dir);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-01-06 17:44:54 +00:00
|
|
|
db->installed.stats.dirs++;
|
2009-07-14 06:33:32 +00:00
|
|
|
dir = malloc(sizeof(*dir) + name.len + 1);
|
|
|
|
memset(dir, 0, sizeof(*dir));
|
2009-01-06 17:44:54 +00:00
|
|
|
dir->refs = 1;
|
2009-08-13 11:10:30 +00:00
|
|
|
dir->rooted_name[0] = '/';
|
2009-07-14 08:55:08 +00:00
|
|
|
memcpy(dir->name, name.ptr, name.len);
|
|
|
|
dir->name[name.len] = 0;
|
|
|
|
dir->namelen = name.len;
|
|
|
|
dir->hash = hash;
|
2009-07-14 07:47:20 +00:00
|
|
|
apk_hash_insert_hashed(&db->installed.dirs, dir, hash);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2008-04-21 16:30:10 +00:00
|
|
|
if (name.len == 0)
|
|
|
|
dir->parent = NULL;
|
2008-11-14 12:26:59 +00:00
|
|
|
else if (apk_blob_rsplit(name, '/', &bparent, NULL))
|
2009-01-13 18:32:18 +00:00
|
|
|
dir->parent = apk_db_dir_get(db, bparent);
|
2008-04-21 16:30:10 +00:00
|
|
|
else
|
2009-01-13 18:32:18 +00:00
|
|
|
dir->parent = apk_db_dir_get(db, APK_BLOB_NULL);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2008-11-14 12:26:59 +00:00
|
|
|
if (dir->parent != NULL)
|
|
|
|
dir->flags = dir->parent->flags;
|
|
|
|
|
|
|
|
for (i = 0; i < db->protected_paths->num; i++) {
|
2009-07-30 07:42:20 +00:00
|
|
|
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;
|
2008-11-14 12:26:59 +00:00
|
|
|
}
|
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
return dir;
|
|
|
|
}
|
|
|
|
|
2009-01-06 17:44:54 +00:00
|
|
|
static struct apk_db_dir_instance *apk_db_diri_new(struct apk_database *db,
|
|
|
|
struct apk_package *pkg,
|
|
|
|
apk_blob_t name,
|
2009-01-16 07:32:04 +00:00
|
|
|
struct hlist_node ***after)
|
2009-01-06 17:44:54 +00:00
|
|
|
{
|
|
|
|
struct apk_db_dir_instance *diri;
|
|
|
|
|
|
|
|
diri = calloc(1, sizeof(struct apk_db_dir_instance));
|
2009-01-07 19:45:11 +00:00
|
|
|
if (diri != NULL) {
|
2009-01-16 07:32:04 +00:00
|
|
|
hlist_add_after(&diri->pkg_dirs_list, *after);
|
|
|
|
*after = &diri->pkg_dirs_list.next;
|
2009-01-13 18:32:18 +00:00
|
|
|
diri->dir = apk_db_dir_get(db, name);
|
2009-01-07 19:45:11 +00:00
|
|
|
diri->pkg = pkg;
|
|
|
|
}
|
2009-01-06 17:44:54 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-07-31 13:08:09 +00:00
|
|
|
static void apk_db_diri_mkdir(struct apk_database *db, struct apk_db_dir_instance *diri)
|
2009-01-06 17:44:54 +00:00
|
|
|
{
|
2010-06-11 10:42:21 +00:00
|
|
|
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)
|
|
|
|
;
|
|
|
|
}
|
2009-01-06 17:44:54 +00:00
|
|
|
}
|
|
|
|
|
2009-01-06 18:30:22 +00:00
|
|
|
static void apk_db_diri_free(struct apk_database *db,
|
2010-09-22 14:16:18 +00:00
|
|
|
struct apk_db_dir_instance *diri,
|
|
|
|
int allow_rmdir)
|
2009-01-06 18:30:22 +00:00
|
|
|
{
|
2010-09-22 14:16:18 +00:00
|
|
|
apk_db_dir_unref(db, diri->dir, allow_rmdir);
|
2009-01-06 18:30:22 +00:00
|
|
|
free(diri);
|
|
|
|
}
|
|
|
|
|
2009-01-14 17:48:30 +00:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
|
2009-07-22 08:36:55 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-01-13 18:32:18 +00:00
|
|
|
static struct apk_db_file *apk_db_file_get(struct apk_database *db,
|
2009-01-14 08:44:47 +00:00
|
|
|
struct apk_db_dir_instance *diri,
|
2009-01-16 07:32:04 +00:00
|
|
|
apk_blob_t name,
|
|
|
|
struct hlist_node ***after)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
|
|
|
struct apk_db_file *file;
|
2009-01-14 08:44:47 +00:00
|
|
|
struct apk_db_file_hash_key key;
|
2009-07-14 08:55:08 +00:00
|
|
|
struct apk_db_dir *dir = diri->dir;
|
|
|
|
unsigned long hash;
|
2009-01-14 08:44:47 +00:00
|
|
|
|
|
|
|
key = (struct apk_db_file_hash_key) {
|
2009-07-14 08:55:08 +00:00
|
|
|
.dirname = APK_BLOB_PTR_LEN(dir->name, dir->namelen),
|
2009-01-14 08:44:47 +00:00
|
|
|
.filename = name,
|
|
|
|
};
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-07-14 08:55:08 +00:00
|
|
|
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);
|
2009-01-13 18:32:18 +00:00
|
|
|
if (file != NULL)
|
|
|
|
return file;
|
|
|
|
|
2009-07-22 08:36:55 +00:00
|
|
|
file = apk_db_file_new(diri, name, after);
|
2009-07-14 08:55:08 +00:00
|
|
|
apk_hash_insert_hashed(&db->installed.files, file, hash);
|
2009-01-16 07:32:04 +00:00
|
|
|
db->installed.stats.files++;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
|
2009-04-14 06:21:30 +00:00
|
|
|
static void apk_db_pkg_rdepends(struct apk_database *db, struct apk_package *pkg)
|
|
|
|
{
|
|
|
|
int i, j;
|
2011-01-04 08:05:20 +00:00
|
|
|
struct apk_name *rname;
|
2009-04-14 06:21:30 +00:00
|
|
|
|
|
|
|
for (i = 0; i < pkg->depends->num; i++) {
|
2011-01-04 08:05:20 +00:00
|
|
|
rname = pkg->depends->item[i].name;
|
2010-06-05 09:06:41 +00:00
|
|
|
for (j = 0; j < rname->rdepends->num; j++)
|
|
|
|
if (rname->rdepends->item[j] == pkg->name)
|
2011-01-04 08:05:20 +00:00
|
|
|
goto rdeps_done;
|
2009-04-14 06:21:30 +00:00
|
|
|
*apk_name_array_add(&rname->rdepends) = pkg->name;
|
|
|
|
}
|
2011-01-04 08:05:20 +00:00
|
|
|
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;
|
2009-04-14 06:21:30 +00:00
|
|
|
}
|
|
|
|
|
2009-05-14 12:01:09 +00:00
|
|
|
struct apk_package *apk_db_pkg_add(struct apk_database *db, struct apk_package *pkg)
|
2008-11-28 11:15:06 +00:00
|
|
|
{
|
|
|
|
struct apk_package *idb;
|
|
|
|
|
2011-01-04 09:45:34 +00:00
|
|
|
if (pkg->license == NULL)
|
2011-03-16 12:51:44 +00:00
|
|
|
pkg->license = apk_blob_atomize(APK_BLOB_NULL);
|
2011-01-04 09:45:34 +00:00
|
|
|
|
2009-07-14 16:14:05 +00:00
|
|
|
idb = apk_hash_get(&db->available.packages, APK_BLOB_CSUM(pkg->csum));
|
2008-11-28 11:15:06 +00:00
|
|
|
if (idb == NULL) {
|
|
|
|
idb = pkg;
|
|
|
|
apk_hash_insert(&db->available.packages, pkg);
|
|
|
|
*apk_package_array_add(&pkg->name->pkgs) = pkg;
|
2009-04-14 06:21:30 +00:00
|
|
|
apk_db_pkg_rdepends(db, pkg);
|
2008-11-28 11:15:06 +00:00
|
|
|
} else {
|
|
|
|
idb->repos |= pkg->repos;
|
2009-04-16 11:03:17 +00:00
|
|
|
if (idb->filename == NULL && pkg->filename != NULL) {
|
|
|
|
idb->filename = pkg->filename;
|
|
|
|
pkg->filename = NULL;
|
|
|
|
}
|
2009-08-12 16:29:14 +00:00
|
|
|
if (idb->ipkg == NULL && pkg->ipkg != NULL) {
|
|
|
|
idb->ipkg = pkg->ipkg;
|
|
|
|
idb->ipkg->pkg = idb;
|
|
|
|
pkg->ipkg = NULL;
|
|
|
|
}
|
2008-11-28 11:15:06 +00:00
|
|
|
apk_pkg_free(pkg);
|
|
|
|
}
|
|
|
|
return idb;
|
|
|
|
}
|
|
|
|
|
2010-12-10 14:42:25 +00:00
|
|
|
void apk_cache_format_index(apk_blob_t to, struct apk_repository *repo)
|
2009-07-24 11:00:57 +00:00
|
|
|
{
|
2009-07-31 13:08:09 +00:00
|
|
|
/* APKINDEX.12345678.tar.gz */
|
2010-12-10 14:42:25 +00:00
|
|
|
apk_blob_push_blob(&to, APK_BLOB_STR("APKINDEX."));
|
2009-07-31 13:08:09 +00:00
|
|
|
apk_blob_push_hexdump(&to, APK_BLOB_PTR_LEN((char *) repo->csum.data,
|
|
|
|
APK_CACHE_CSUM_BYTES));
|
2010-12-10 14:42:25 +00:00
|
|
|
apk_blob_push_blob(&to, APK_BLOB_STR(".tar.gz"));
|
2009-07-31 13:08:09 +00:00
|
|
|
apk_blob_push_blob(&to, APK_BLOB_PTR_LEN("", 1));
|
|
|
|
}
|
|
|
|
|
2011-03-16 12:51:44 +00:00
|
|
|
int apk_cache_download(struct apk_database *db, const char *url, apk_blob_t *arch,
|
2009-07-31 13:08:09 +00:00
|
|
|
const char *item, const char *cacheitem, int verify)
|
|
|
|
{
|
|
|
|
char fullurl[PATH_MAX];
|
|
|
|
int r;
|
|
|
|
|
2011-04-07 11:14:27 +00:00
|
|
|
apk_repo_format_filename(fullurl, sizeof(fullurl), url, arch, item);
|
2009-07-31 13:08:09 +00:00
|
|
|
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);
|
|
|
|
|
2010-10-08 12:36:54 +00:00
|
|
|
r = apk_tar_parse(is, apk_sign_ctx_verify_tar, &sctx, FALSE, &db->id_cache);
|
2009-07-31 13:08:09 +00:00
|
|
|
is->close(is);
|
|
|
|
apk_sign_ctx_free(&sctx);
|
|
|
|
if (r != 0) {
|
|
|
|
unlinkat(db->cachetmp_fd, cacheitem, 0);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
2009-07-24 11:00:57 +00:00
|
|
|
|
2011-03-16 12:55:08 +00:00
|
|
|
if (db->cachetmp_fd != db->cache_fd) {
|
|
|
|
if (renameat(db->cachetmp_fd, cacheitem, db->cache_fd, cacheitem) < 0)
|
|
|
|
return -errno;
|
|
|
|
}
|
2009-07-24 11:00:57 +00:00
|
|
|
|
2009-07-31 13:08:09 +00:00
|
|
|
return 0;
|
2009-07-24 11:00:57 +00:00
|
|
|
}
|
|
|
|
|
2009-12-21 12:30:33 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-12-21 12:14:02 +00:00
|
|
|
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;
|
|
|
|
} else {
|
2009-12-21 12:30:33 +00:00
|
|
|
diri = find_diri(ipkg, bdir, diri, &file_diri_node);
|
|
|
|
if (diri == NULL) {
|
2009-12-21 14:31:58 +00:00
|
|
|
diri = apk_db_diri_new(db, pkg, bdir, &diri_node);
|
|
|
|
file_diri_node = &diri->owned_files.first;
|
2009-12-21 12:30:33 +00:00
|
|
|
}
|
2011-03-27 00:51:51 +00:00
|
|
|
(void) apk_db_file_get(db, diri, bfile, &file_diri_node);
|
2009-12-21 12:14:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-14 06:33:32 +00:00
|
|
|
int apk_db_index_read(struct apk_database *db, struct apk_bstream *bs, int repo)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
|
|
|
struct apk_package *pkg = NULL;
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg = NULL;
|
2009-01-06 17:44:54 +00:00
|
|
|
struct apk_db_dir_instance *diri = NULL;
|
2008-04-17 14:09:13 +00:00
|
|
|
struct apk_db_file *file = NULL;
|
2009-01-06 17:44:54 +00:00
|
|
|
struct hlist_node **diri_node = NULL;
|
|
|
|
struct hlist_node **file_diri_node = NULL;
|
2009-07-14 06:33:32 +00:00
|
|
|
apk_blob_t token = APK_BLOB_STR("\n"), l;
|
2011-01-03 19:06:41 +00:00
|
|
|
int field, r;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-07-14 06:33:32 +00:00
|
|
|
while (!APK_BLOB_IS_NULL(l = bs->read(bs, token))) {
|
|
|
|
if (l.len < 2 || l.ptr[1] != ':') {
|
|
|
|
if (pkg == NULL)
|
|
|
|
continue;
|
2008-11-28 11:15:06 +00:00
|
|
|
|
2009-07-24 11:00:57 +00:00
|
|
|
if (repo >= 0)
|
2009-07-14 06:33:32 +00:00
|
|
|
pkg->repos |= BIT(repo);
|
2008-11-28 11:15:06 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
if (apk_db_pkg_add(db, pkg) == NULL) {
|
2009-07-14 06:33:32 +00:00
|
|
|
apk_error("Installed database load failed");
|
|
|
|
return -1;
|
2008-11-28 11:15:06 +00:00
|
|
|
}
|
2009-07-14 06:33:32 +00:00
|
|
|
pkg = NULL;
|
2009-08-12 16:17:46 +00:00
|
|
|
ipkg = NULL;
|
2009-07-14 06:33:32 +00:00
|
|
|
continue;
|
|
|
|
}
|
2008-11-28 11:15:06 +00:00
|
|
|
|
2009-07-14 06:33:32 +00:00
|
|
|
/* Get field */
|
|
|
|
field = l.ptr[0];
|
|
|
|
l.ptr += 2;
|
|
|
|
l.len -= 2;
|
|
|
|
|
|
|
|
/* If no package, create new */
|
|
|
|
if (pkg == NULL) {
|
|
|
|
pkg = apk_pkg_new();
|
2011-01-03 19:06:41 +00:00
|
|
|
ipkg = NULL;
|
2009-07-14 06:33:32 +00:00
|
|
|
diri = NULL;
|
|
|
|
file_diri_node = NULL;
|
|
|
|
}
|
2008-11-28 11:15:06 +00:00
|
|
|
|
2009-07-14 06:33:32 +00:00
|
|
|
/* Standard index line? */
|
2011-01-03 19:06:41 +00:00
|
|
|
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);
|
|
|
|
}
|
2009-07-14 06:33:32 +00:00
|
|
|
continue;
|
|
|
|
}
|
2011-01-03 19:06:41 +00:00
|
|
|
if (repo != -1 || ipkg == NULL)
|
|
|
|
continue;
|
2008-11-28 11:15:06 +00:00
|
|
|
|
2009-07-14 06:33:32 +00:00
|
|
|
/* Check FDB special entries */
|
|
|
|
switch (field) {
|
|
|
|
case 'F':
|
|
|
|
if (pkg->name == NULL) {
|
|
|
|
apk_error("FDB directory entry before package entry");
|
2008-11-28 11:15:06 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2009-07-14 06:33:32 +00:00
|
|
|
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;
|
|
|
|
}
|
2009-07-14 10:27:21 +00:00
|
|
|
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);
|
2009-07-14 06:33:32 +00:00
|
|
|
break;
|
|
|
|
case 'R':
|
|
|
|
if (diri == NULL) {
|
|
|
|
apk_error("FDB file entry before directory entry");
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-22 08:36:55 +00:00
|
|
|
file = apk_db_file_get(db, diri, l, &file_diri_node);
|
2009-07-14 06:33:32 +00:00
|
|
|
break;
|
|
|
|
case 'Z':
|
|
|
|
if (file == NULL) {
|
|
|
|
apk_error("FDB checksum entry before file entry");
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-14 16:14:05 +00:00
|
|
|
apk_blob_pull_csum(&l, &file->csum);
|
2009-07-14 06:33:32 +00:00
|
|
|
break;
|
|
|
|
default:
|
2011-01-03 19:06:41 +00:00
|
|
|
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;
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
2009-07-14 10:27:21 +00:00
|
|
|
if (APK_BLOB_IS_NULL(l)) {
|
|
|
|
apk_error("FDB format error in entry '%c'", field);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-01-13 18:32:18 +00:00
|
|
|
return 0;
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2008-11-28 14:28:54 +00:00
|
|
|
static int apk_db_write_fdb(struct apk_database *db, struct apk_ostream *os)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg;
|
2008-04-17 14:09:13 +00:00
|
|
|
struct apk_package *pkg;
|
2009-01-06 17:44:54 +00:00
|
|
|
struct apk_db_dir_instance *diri;
|
2008-04-17 14:09:13 +00:00
|
|
|
struct apk_db_file *file;
|
2009-01-06 17:44:54 +00:00
|
|
|
struct hlist_node *c1, *c2;
|
2008-04-17 14:09:13 +00:00
|
|
|
char buf[1024];
|
2009-07-14 10:27:21 +00:00
|
|
|
apk_blob_t bbuf = APK_BLOB_BUF(buf);
|
|
|
|
int r;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
|
|
|
|
pkg = ipkg->pkg;
|
2009-04-16 14:05:27 +00:00
|
|
|
r = apk_pkg_write_index_entry(pkg, os);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
hlist_for_each_entry(diri, c1, &ipkg->owned_dirs, pkg_dirs_list) {
|
2009-07-14 10:27:21 +00:00
|
|
|
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"));
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-01-06 17:44:54 +00:00
|
|
|
hlist_for_each_entry(file, c2, &diri->owned_files, diri_files_list) {
|
2009-07-14 10:27:21 +00:00
|
|
|
apk_blob_push_blob(&bbuf, APK_BLOB_STR("R:"));
|
|
|
|
apk_blob_push_blob(&bbuf, APK_BLOB_PTR_LEN(file->name, file->namelen));
|
2009-07-14 16:14:05 +00:00
|
|
|
if (file->csum.type != APK_CHECKSUM_NONE) {
|
2009-07-14 10:27:21 +00:00
|
|
|
apk_blob_push_blob(&bbuf, APK_BLOB_STR("\nZ:"));
|
2009-07-14 16:14:05 +00:00
|
|
|
apk_blob_push_csum(&bbuf, &file->csum);
|
2009-01-06 17:44:54 +00:00
|
|
|
}
|
2009-07-14 10:27:21 +00:00
|
|
|
apk_blob_push_blob(&bbuf, APK_BLOB_STR("\n"));
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-07-14 10:27:21 +00:00
|
|
|
if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
|
2009-01-06 17:44:54 +00:00
|
|
|
return -1;
|
2009-07-14 10:27:21 +00:00
|
|
|
bbuf = APK_BLOB_BUF(buf);
|
2008-11-14 12:26:59 +00:00
|
|
|
}
|
2009-07-14 10:27:21 +00:00
|
|
|
if (os->write(os, buf, bbuf.ptr - buf) != bbuf.ptr - buf)
|
2009-01-07 19:45:11 +00:00
|
|
|
return -1;
|
2009-07-14 10:27:21 +00:00
|
|
|
bbuf = APK_BLOB_BUF(buf);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
2008-11-28 14:28:54 +00:00
|
|
|
os->write(os, "\n", 1);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-28 14:28:54 +00:00
|
|
|
static int apk_db_scriptdb_write(struct apk_database *db, struct apk_ostream *os)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg;
|
2008-04-17 14:09:13 +00:00
|
|
|
struct apk_package *pkg;
|
2009-07-14 16:14:05 +00:00
|
|
|
struct apk_file_info fi;
|
|
|
|
char filename[256];
|
|
|
|
apk_blob_t bfn;
|
2009-08-12 16:17:46 +00:00
|
|
|
int r, i;
|
2009-12-21 09:42:39 +00:00
|
|
|
time_t now = time(NULL);
|
2009-08-12 16:17:46 +00:00
|
|
|
|
|
|
|
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;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-07-14 16:14:05 +00:00
|
|
|
fi = (struct apk_file_info) {
|
|
|
|
.name = filename,
|
2009-08-12 16:17:46 +00:00
|
|
|
.size = ipkg->script[i].len,
|
2009-07-14 16:14:05 +00:00
|
|
|
.mode = 0755 | S_IFREG,
|
2009-12-21 09:42:39 +00:00
|
|
|
.mtime = now,
|
2009-07-14 16:14:05 +00:00
|
|
|
};
|
|
|
|
/* 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("-"));
|
2010-12-14 17:51:16 +00:00
|
|
|
apk_blob_push_blob(&bfn, *pkg->version);
|
2009-07-14 16:14:05 +00:00
|
|
|
apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
|
|
|
|
apk_blob_push_csum(&bfn, &pkg->csum);
|
|
|
|
apk_blob_push_blob(&bfn, APK_BLOB_STR("."));
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_blob_push_blob(&bfn, APK_BLOB_STR(apk_script_types[i]));
|
2009-07-14 16:14:05 +00:00
|
|
|
apk_blob_push_blob(&bfn, APK_BLOB_PTR_LEN("", 1));
|
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
r = apk_tar_write_entry(os, &fi, ipkg->script[i].ptr);
|
2009-07-14 16:14:05 +00:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-16 12:16:05 +00:00
|
|
|
return apk_tar_write_entry(os, NULL, NULL);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-07-14 16:14:05 +00:00
|
|
|
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);
|
2009-08-12 16:17:46 +00:00
|
|
|
if (pkg != NULL && pkg->ipkg != NULL)
|
|
|
|
apk_ipkg_add_script(pkg->ipkg, is, type, ae->size);
|
2009-07-14 16:14:05 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-08-13 11:10:30 +00:00
|
|
|
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);
|
2010-06-01 13:46:53 +00:00
|
|
|
bfn = apk_blob_pushed(APK_BLOB_BUF(buf), bfn);
|
|
|
|
os->write(os, bfn.ptr, bfn.len);
|
2009-08-13 15:41:03 +00:00
|
|
|
|
2009-08-13 11:10:30 +00:00
|
|
|
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);
|
2010-06-05 09:06:41 +00:00
|
|
|
if (ipkg->triggers->num != 0 &&
|
|
|
|
!list_hashed(&ipkg->trigger_pkgs_list))
|
2009-08-13 11:10:30 +00:00
|
|
|
list_add_tail(&ipkg->trigger_pkgs_list,
|
|
|
|
&db->installed.triggers);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-07 06:27:56 +00:00
|
|
|
static int apk_db_read_state(struct apk_database *db, int flags)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2008-11-07 15:11:08 +00:00
|
|
|
struct apk_istream *is;
|
2009-07-14 06:33:32 +00:00
|
|
|
struct apk_bstream *bs;
|
2008-11-27 14:59:04 +00:00
|
|
|
apk_blob_t blob;
|
2011-01-03 19:06:41 +00:00
|
|
|
int i, r;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
/* Read:
|
|
|
|
* 1. installed repository
|
|
|
|
* 2. source repositories
|
|
|
|
* 3. master dependencies
|
|
|
|
* 4. package statuses
|
|
|
|
* 5. files db
|
|
|
|
* 6. script db
|
|
|
|
*/
|
2009-07-07 06:27:56 +00:00
|
|
|
if (!(flags & APK_OPENF_NO_WORLD)) {
|
2011-03-16 14:52:14 +00:00
|
|
|
blob = apk_blob_from_file(db->root_fd, apk_world_file);
|
2009-07-07 06:27:56 +00:00
|
|
|
if (APK_BLOB_IS_NULL(blob))
|
|
|
|
return -ENOENT;
|
|
|
|
apk_deps_parse(db, &db->world, blob);
|
|
|
|
free(blob.ptr);
|
2008-04-21 16:30:10 +00:00
|
|
|
|
2010-06-05 09:06:41 +00:00
|
|
|
for (i = 0; i < db->world->num; i++)
|
2009-07-07 06:27:56 +00:00
|
|
|
db->world->item[i].name->flags |= APK_NAME_TOPLEVEL;
|
|
|
|
}
|
2009-04-14 15:48:02 +00:00
|
|
|
|
2009-07-07 06:27:56 +00:00
|
|
|
if (!(flags & APK_OPENF_NO_INSTALLED)) {
|
2011-03-16 14:52:14 +00:00
|
|
|
bs = apk_bstream_from_file(db->root_fd, apk_installed_file);
|
2009-07-14 06:33:32 +00:00
|
|
|
if (bs != NULL) {
|
2011-01-03 19:06:41 +00:00
|
|
|
r = apk_db_index_read(db, bs, -1);
|
2009-07-14 06:33:32 +00:00
|
|
|
bs->close(bs, NULL);
|
2011-01-03 19:06:41 +00:00
|
|
|
if (r != 0)
|
|
|
|
return -1;
|
2009-07-07 06:27:56 +00:00
|
|
|
}
|
2009-07-24 11:00:57 +00:00
|
|
|
|
2011-03-16 14:52:14 +00:00
|
|
|
bs = apk_bstream_from_file(db->root_fd, apk_triggers_file);
|
2009-08-13 11:10:30 +00:00
|
|
|
if (bs != NULL) {
|
|
|
|
apk_db_triggers_read(db, bs);
|
|
|
|
bs->close(bs, NULL);
|
|
|
|
}
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-07-07 06:27:56 +00:00
|
|
|
if (!(flags & APK_OPENF_NO_SCRIPTS)) {
|
2011-03-16 14:52:14 +00:00
|
|
|
is = apk_istream_from_file(db->root_fd, apk_scripts_file);
|
2009-07-07 06:27:56 +00:00
|
|
|
if (is != NULL) {
|
2009-07-29 16:16:04 +00:00
|
|
|
apk_tar_parse(is, apk_read_script_archive_entry, db,
|
2010-10-08 12:36:54 +00:00
|
|
|
FALSE, &db->id_cache);
|
2009-07-14 16:14:05 +00:00
|
|
|
is->close(is);
|
2011-03-16 14:52:14 +00:00
|
|
|
}
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-24 11:00:57 +00:00
|
|
|
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 };
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg;
|
2009-07-24 11:00:57 +00:00
|
|
|
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 */
|
2009-08-12 08:05:09 +00:00
|
|
|
os = apk_ostream_to_file(db->cache_fd,
|
|
|
|
"installed",
|
|
|
|
"installed.new",
|
|
|
|
0644);
|
2009-07-24 11:00:57 +00:00
|
|
|
if (os == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2009-07-31 13:08:09 +00:00
|
|
|
ctx.os = os;
|
2009-08-12 16:17:46 +00:00
|
|
|
list_for_each_entry(ipkg, &db->installed.packages, installed_pkgs_list) {
|
|
|
|
if (ipkg->pkg->repos != 0)
|
2009-07-24 11:00:57 +00:00
|
|
|
continue;
|
2009-08-12 16:17:46 +00:00
|
|
|
r = write_index_entry(ipkg->pkg, &ctx);
|
2009-07-24 11:00:57 +00:00
|
|
|
if (r != 0)
|
|
|
|
return r;
|
|
|
|
}
|
2009-08-12 08:05:09 +00:00
|
|
|
r = os->close(os);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2009-07-24 11:00:57 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-11-14 12:26:59 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2009-01-17 09:07:56 +00:00
|
|
|
static int apk_db_create(struct apk_database *db)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
|
2009-07-31 13:08:09 +00:00
|
|
|
mkdirat(db->root_fd, "tmp", 01777);
|
|
|
|
mkdirat(db->root_fd, "dev", 0755);
|
|
|
|
mknodat(db->root_fd, "dev/null", 0666, makedev(1, 3));
|
2011-03-16 14:52:14 +00:00
|
|
|
mkdirat(db->root_fd, "etc", 0755);
|
|
|
|
mkdirat(db->root_fd, "etc/apk", 0755);
|
|
|
|
mkdirat(db->root_fd, "lib", 0755);
|
|
|
|
mkdirat(db->root_fd, "lib/apk", 0755);
|
|
|
|
mkdirat(db->root_fd, "lib/apk/db", 0755);
|
2009-07-31 13:08:09 +00:00
|
|
|
mkdirat(db->root_fd, "var", 0755);
|
2009-08-11 14:56:24 +00:00
|
|
|
mkdirat(db->root_fd, "var/cache", 0755);
|
2011-03-16 14:52:14 +00:00
|
|
|
mkdirat(db->root_fd, "var/cache/apk", 0755);
|
2009-08-11 14:56:24 +00:00
|
|
|
mkdirat(db->root_fd, "var/cache/misc", 0755);
|
2011-03-16 13:39:36 +00:00
|
|
|
mkdirat(db->root_fd, "var/lock", 0755);
|
2009-01-17 09:07:56 +00:00
|
|
|
|
2011-03-16 14:52:14 +00:00
|
|
|
fd = openat(db->root_fd, apk_world_file, O_CREAT|O_RDWR|O_TRUNC|O_CLOEXEC, 0644);
|
2009-01-17 09:07:56 +00:00
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-07 07:30:54 +00:00
|
|
|
static void handle_alarm(int sig)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-03-16 12:55:08 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2011-03-16 14:52:14 +00:00
|
|
|
static void relocate_database(struct apk_database *db)
|
|
|
|
{
|
|
|
|
mkdirat(db->root_fd, "etc", 0755);
|
|
|
|
mkdirat(db->root_fd, "etc/apk", 0755);
|
|
|
|
mkdirat(db->root_fd, "lib", 0755);
|
|
|
|
mkdirat(db->root_fd, "lib/apk", 0755);
|
|
|
|
mkdirat(db->root_fd, "lib/apk/db", 0755);
|
|
|
|
mkdirat(db->root_fd, "var", 0755);
|
|
|
|
mkdirat(db->root_fd, "var/cache", 0755);
|
|
|
|
mkdirat(db->root_fd, "var/cache/apk", 0755);
|
|
|
|
mkdirat(db->root_fd, "var/cache/misc", 0755);
|
|
|
|
mkdirat(db->root_fd, "var/lock", 0755);
|
|
|
|
apk_move_file(db->root_fd, apk_world_file_old, apk_world_file);
|
|
|
|
apk_move_file(db->root_fd, apk_scripts_file_old, apk_scripts_file);
|
|
|
|
apk_move_file(db->root_fd, apk_triggers_file_old, apk_triggers_file);
|
|
|
|
apk_move_file(db->root_fd, apk_installed_file_old, apk_installed_file);
|
|
|
|
}
|
|
|
|
|
2010-03-06 19:22:01 +00:00
|
|
|
int apk_db_open(struct apk_database *db, struct apk_db_options *dbopts)
|
2008-04-21 16:30:10 +00:00
|
|
|
{
|
2009-08-06 11:25:03 +00:00
|
|
|
const char *msg = NULL;
|
|
|
|
struct apk_repository_list *repo = NULL;
|
2010-03-01 09:26:45 +00:00
|
|
|
struct apk_bstream *bs;
|
2011-03-16 11:18:54 +00:00
|
|
|
struct statfs stfs;
|
2009-06-28 17:36:16 +00:00
|
|
|
apk_blob_t blob;
|
2011-03-16 12:55:08 +00:00
|
|
|
int r, fd, rr = 0;
|
2008-11-14 12:26:59 +00:00
|
|
|
|
2008-04-21 16:30:10 +00:00
|
|
|
memset(db, 0, sizeof(*db));
|
2010-06-12 10:48:42 +00:00
|
|
|
if (apk_flags & APK_SIMULATE) {
|
|
|
|
dbopts->open_flags &= ~(APK_OPENF_CREATE | APK_OPENF_WRITE);
|
|
|
|
dbopts->open_flags |= APK_OPENF_READ;
|
|
|
|
}
|
2009-08-06 11:25:03 +00:00
|
|
|
if (dbopts->open_flags == 0) {
|
|
|
|
msg = "Invalid open flags (internal error)";
|
|
|
|
r = -1;
|
|
|
|
goto ret_r;
|
|
|
|
}
|
|
|
|
|
2008-04-21 16:30:10 +00:00
|
|
|
apk_hash_init(&db->available.names, &pkg_name_hash_ops, 1000);
|
|
|
|
apk_hash_init(&db->available.packages, &pkg_info_hash_ops, 4000);
|
2009-07-21 11:26:06 +00:00
|
|
|
apk_hash_init(&db->installed.dirs, &dir_hash_ops, 2000);
|
|
|
|
apk_hash_init(&db->installed.files, &file_hash_ops, 10000);
|
2008-11-27 18:25:01 +00:00
|
|
|
list_init(&db->installed.packages);
|
2009-08-13 11:10:30 +00:00
|
|
|
list_init(&db->installed.triggers);
|
2010-06-05 09:06:41 +00:00
|
|
|
apk_dependency_array_init(&db->world);
|
|
|
|
apk_string_array_init(&db->protected_paths);
|
2009-07-24 11:00:57 +00:00
|
|
|
db->permanent = 1;
|
2008-04-21 16:30:10 +00:00
|
|
|
|
2009-08-06 11:25:03 +00:00
|
|
|
db->root = strdup(dbopts->root ?: "/");
|
2010-06-11 10:42:21 +00:00
|
|
|
db->root_fd = openat(AT_FDCWD, db->root, O_RDONLY | O_CLOEXEC);
|
2009-08-06 11:25:03 +00:00
|
|
|
if (db->root_fd < 0 && (dbopts->open_flags & APK_OPENF_CREATE)) {
|
2009-08-06 07:17:28 +00:00
|
|
|
mkdirat(AT_FDCWD, db->root, 0755);
|
2010-06-11 10:42:21 +00:00
|
|
|
db->root_fd = openat(AT_FDCWD, db->root, O_RDONLY | O_CLOEXEC);
|
2009-08-06 07:17:28 +00:00
|
|
|
}
|
|
|
|
if (db->root_fd < 0) {
|
|
|
|
msg = "Unable to open root";
|
|
|
|
goto ret_errno;
|
|
|
|
}
|
2011-03-16 11:18:54 +00:00
|
|
|
if (fstatfs(db->root_fd, &stfs) == 0 &&
|
|
|
|
stfs.f_type == 0x01021994 /* TMPFS_MAGIC */)
|
2009-08-06 07:17:28 +00:00
|
|
|
db->permanent = 0;
|
|
|
|
|
2010-10-08 13:09:03 +00:00
|
|
|
apk_id_cache_init(&db->id_cache, db->root_fd);
|
|
|
|
|
2009-08-06 11:25:03 +00:00
|
|
|
if (dbopts->open_flags & APK_OPENF_WRITE) {
|
2011-03-16 14:52:14 +00:00
|
|
|
if (faccessat(db->root_fd, apk_installed_file_old, F_OK, 0) == 0)
|
|
|
|
relocate_database(db);
|
|
|
|
|
2011-03-16 13:39:36 +00:00
|
|
|
db->lock_fd = openat(db->root_fd, apk_lock_file,
|
2010-06-11 10:42:21 +00:00
|
|
|
O_CREAT | O_RDWR | O_CLOEXEC, 0400);
|
2009-08-06 07:17:28 +00:00
|
|
|
if (db->lock_fd < 0 && errno == ENOENT &&
|
2009-08-06 11:25:03 +00:00
|
|
|
(dbopts->open_flags & APK_OPENF_CREATE)) {
|
2009-08-06 07:17:28 +00:00
|
|
|
r = apk_db_create(db);
|
|
|
|
if (r != 0) {
|
|
|
|
msg = "Unable to create database";
|
|
|
|
goto ret_r;
|
|
|
|
}
|
2011-03-16 13:39:36 +00:00
|
|
|
db->lock_fd = openat(db->root_fd, apk_lock_file,
|
2010-06-11 10:42:21 +00:00
|
|
|
O_CREAT | O_RDWR | O_CLOEXEC, 0400);
|
2009-08-06 07:17:28 +00:00
|
|
|
}
|
|
|
|
if (db->lock_fd < 0 ||
|
|
|
|
flock(db->lock_fd, LOCK_EX | LOCK_NB) < 0) {
|
|
|
|
msg = "Unable to lock database";
|
2010-03-06 19:22:01 +00:00
|
|
|
if (dbopts->lock_wait) {
|
2009-08-06 07:17:28 +00:00
|
|
|
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);
|
|
|
|
|
2010-03-06 19:22:01 +00:00
|
|
|
alarm(dbopts->lock_wait);
|
2009-08-06 07:17:28 +00:00
|
|
|
if (flock(db->lock_fd, LOCK_EX) < 0)
|
2009-07-24 11:12:59 +00:00
|
|
|
goto ret_errno;
|
2009-08-06 07:17:28 +00:00
|
|
|
|
|
|
|
alarm(0);
|
|
|
|
sigaction(SIGALRM, &old_sa, NULL);
|
|
|
|
} else
|
|
|
|
goto ret_errno;
|
2008-04-21 16:30:10 +00:00
|
|
|
}
|
|
|
|
}
|
2008-11-28 11:15:06 +00:00
|
|
|
|
2009-07-30 07:42:20 +00:00
|
|
|
blob = APK_BLOB_STR("etc:*etc/init.d");
|
2008-11-28 11:15:06 +00:00
|
|
|
apk_blob_for_each_segment(blob, ":", add_protected_path, db);
|
|
|
|
|
2011-03-16 12:55:08 +00:00
|
|
|
/* figure out where to have the cache */
|
|
|
|
fd = openat(db->root_fd, apk_linked_cache_dir, O_RDONLY | O_CLOEXEC);
|
2011-03-16 13:21:41 +00:00
|
|
|
if (fd >= 0 && fstatfs(fd, &stfs) == 0 && stfs.f_type != 0x01021994 /* TMPFS_MAGIC */) {
|
2011-03-16 12:55:08 +00:00
|
|
|
struct statvfs stvfs;
|
|
|
|
|
|
|
|
db->cache_dir = apk_linked_cache_dir;
|
|
|
|
db->cache_fd = fd;
|
|
|
|
mkdirat(db->cache_fd, "tmp", 0644);
|
|
|
|
db->cachetmp_fd = openat(db->cache_fd, "tmp", O_RDONLY | O_CLOEXEC);
|
|
|
|
if (fstatvfs(fd, &stvfs) == 0 && (stvfs.f_flag & ST_RDONLY) != 0)
|
|
|
|
db->ro_cache = 1;
|
|
|
|
} else {
|
|
|
|
if (fd >= 0)
|
|
|
|
close(fd);
|
|
|
|
db->cache_dir = apk_static_cache_dir;
|
|
|
|
db->cache_fd = openat(db->root_fd, db->cache_dir, O_RDONLY | O_CLOEXEC);
|
|
|
|
db->cachetmp_fd = db->cache_fd;
|
|
|
|
}
|
|
|
|
|
2010-12-14 17:51:16 +00:00
|
|
|
db->arch = apk_blob_atomize(APK_BLOB_STR(apk_arch));
|
2009-08-06 11:25:03 +00:00
|
|
|
db->keys_fd = openat(db->root_fd,
|
|
|
|
dbopts->keys_dir ?: "etc/apk/keys",
|
2010-06-11 10:42:21 +00:00
|
|
|
O_RDONLY | O_CLOEXEC);
|
2009-07-31 13:08:09 +00:00
|
|
|
|
2009-12-21 12:14:02 +00:00
|
|
|
if (apk_flags & APK_OVERLAY_FROM_STDIN) {
|
|
|
|
apk_flags &= ~APK_OVERLAY_FROM_STDIN;
|
|
|
|
apk_db_read_overlay(db, apk_bstream_from_istream(
|
|
|
|
apk_istream_from_fd(STDIN_FILENO)));
|
|
|
|
}
|
|
|
|
|
2009-08-06 11:25:03 +00:00
|
|
|
r = apk_db_read_state(db, dbopts->open_flags);
|
|
|
|
if (r == -ENOENT && (dbopts->open_flags & APK_OPENF_CREATE)) {
|
2009-08-06 07:17:28 +00:00
|
|
|
r = apk_db_create(db);
|
2009-07-07 06:27:56 +00:00
|
|
|
if (r != 0) {
|
2009-08-06 07:17:28 +00:00
|
|
|
msg = "Unable to create database";
|
2009-07-07 06:27:56 +00:00
|
|
|
goto ret_r;
|
2009-01-17 09:07:56 +00:00
|
|
|
}
|
2009-08-06 11:25:03 +00:00
|
|
|
r = apk_db_read_state(db, dbopts->open_flags);
|
2009-08-06 07:17:28 +00:00
|
|
|
}
|
|
|
|
if (r != 0) {
|
|
|
|
msg = "Unable to read database state";
|
|
|
|
goto ret_r;
|
2009-01-16 14:25:19 +00:00
|
|
|
}
|
|
|
|
|
2010-03-04 12:01:37 +00:00
|
|
|
if (!(dbopts->open_flags & APK_OPENF_NO_INSTALLED_REPO)) {
|
2010-03-01 09:20:17 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
2010-03-04 12:01:37 +00:00
|
|
|
}
|
|
|
|
if (!(dbopts->open_flags & APK_OPENF_NO_SYS_REPOS)) {
|
2009-08-06 11:25:03 +00:00
|
|
|
list_for_each_entry(repo, &dbopts->repository_list, list) {
|
2009-08-04 08:08:19 +00:00
|
|
|
r = apk_db_add_repository(db, APK_BLOB_STR(repo->url));
|
|
|
|
rr = r ?: rr;
|
|
|
|
}
|
2009-08-06 11:25:03 +00:00
|
|
|
blob = apk_blob_from_file(
|
|
|
|
db->root_fd,
|
|
|
|
dbopts->repositories_file ?: "etc/apk/repositories");
|
2009-08-06 07:17:28 +00:00
|
|
|
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);
|
|
|
|
}
|
2009-07-24 11:00:57 +00:00
|
|
|
if (apk_flags & APK_UPDATE_CACHE)
|
|
|
|
apk_db_index_write_nr_cache(db);
|
2009-01-17 09:07:56 +00:00
|
|
|
}
|
2009-08-06 07:17:28 +00:00
|
|
|
if (rr != 0) {
|
|
|
|
r = rr;
|
|
|
|
goto ret_r;
|
|
|
|
}
|
2008-04-21 16:30:10 +00:00
|
|
|
|
2011-01-03 19:06:41 +00:00
|
|
|
if (db->compat_newfeatures) {
|
|
|
|
apk_warning("This apk-tools is OLD! Some packages %s.",
|
|
|
|
db->compat_notinstallable ?
|
|
|
|
"are not installable" :
|
|
|
|
"might not function properly");
|
|
|
|
}
|
|
|
|
|
2011-03-16 12:55:08 +00:00
|
|
|
if ((dbopts->open_flags & (APK_OPENF_WRITE | APK_OPENF_CACHE_WRITE)) &&
|
|
|
|
db->ro_cache) {
|
|
|
|
/* remount cache read-write */
|
|
|
|
db->cache_remount_dir = find_mountpoint(db->root_fd, db->cache_dir);
|
|
|
|
if (db->cache_remount_dir == NULL) {
|
|
|
|
apk_warning("Unable to find cache directory mount point");
|
|
|
|
} else if (do_remount(db->cache_remount_dir, "rw") != 0) {
|
|
|
|
free(db->cache_remount_dir);
|
|
|
|
db->cache_remount_dir = NULL;
|
|
|
|
apk_error("Unable to remount cache read-write");
|
|
|
|
r = EROFS;
|
|
|
|
goto ret_r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-04 08:08:19 +00:00
|
|
|
return rr;
|
2009-01-17 09:07:56 +00:00
|
|
|
|
|
|
|
ret_errno:
|
|
|
|
r = -errno;
|
|
|
|
ret_r:
|
2009-04-21 08:17:17 +00:00
|
|
|
if (msg != NULL)
|
|
|
|
apk_error("%s: %s", msg, strerror(-r));
|
2009-01-17 09:07:56 +00:00
|
|
|
apk_db_close(db);
|
2009-07-31 13:08:09 +00:00
|
|
|
|
2009-01-17 09:07:56 +00:00
|
|
|
return r;
|
2008-04-21 16:30:10 +00:00
|
|
|
}
|
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
struct write_ctx {
|
|
|
|
struct apk_database *db;
|
|
|
|
int fd;
|
|
|
|
};
|
|
|
|
|
2009-04-14 15:48:02 +00:00
|
|
|
int apk_db_write_config(struct apk_database *db)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2008-11-28 14:28:54 +00:00
|
|
|
struct apk_ostream *os;
|
2009-08-12 08:05:09 +00:00
|
|
|
int r;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-08-13 11:10:30 +00:00
|
|
|
if ((apk_flags & APK_SIMULATE) || db->root == NULL)
|
2008-04-21 16:30:10 +00:00
|
|
|
return 0;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-01-17 09:07:56 +00:00
|
|
|
if (db->lock_fd == 0) {
|
|
|
|
apk_error("Refusing to write db without write lock!");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-08-12 08:05:09 +00:00
|
|
|
os = apk_ostream_to_file(db->root_fd,
|
2011-03-16 14:52:14 +00:00
|
|
|
apk_world_file,
|
|
|
|
apk_world_file_tmp,
|
2009-08-12 08:05:09 +00:00
|
|
|
0644);
|
2008-11-28 14:28:54 +00:00
|
|
|
if (os == NULL)
|
2008-04-17 14:09:13 +00:00
|
|
|
return -1;
|
2009-08-12 08:05:09 +00:00
|
|
|
|
2009-03-17 11:19:06 +00:00
|
|
|
apk_deps_write(db->world, os);
|
|
|
|
os->write(os, "\n", 1);
|
2009-08-12 08:05:09 +00:00
|
|
|
r = os->close(os);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-08-12 08:05:09 +00:00
|
|
|
os = apk_ostream_to_file(db->root_fd,
|
2011-03-16 14:52:14 +00:00
|
|
|
apk_installed_file,
|
|
|
|
apk_installed_file_tmp,
|
2009-08-12 08:05:09 +00:00
|
|
|
0644);
|
2008-11-28 14:28:54 +00:00
|
|
|
if (os == NULL)
|
2008-04-17 14:09:13 +00:00
|
|
|
return -1;
|
2008-11-28 14:28:54 +00:00
|
|
|
apk_db_write_fdb(db, os);
|
2009-08-12 08:05:09 +00:00
|
|
|
r = os->close(os);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2009-01-17 09:07:56 +00:00
|
|
|
|
2009-08-12 08:05:09 +00:00
|
|
|
os = apk_ostream_to_file(db->root_fd,
|
2011-03-16 14:52:14 +00:00
|
|
|
apk_scripts_file,
|
|
|
|
apk_scripts_file_tmp,
|
2009-08-12 08:05:09 +00:00
|
|
|
0644);
|
2008-11-28 14:28:54 +00:00
|
|
|
if (os == NULL)
|
2008-04-17 14:09:13 +00:00
|
|
|
return -1;
|
2008-11-28 14:28:54 +00:00
|
|
|
apk_db_scriptdb_write(db, os);
|
2009-08-12 08:05:09 +00:00
|
|
|
r = os->close(os);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2009-07-14 16:14:05 +00:00
|
|
|
|
2009-07-24 11:00:57 +00:00
|
|
|
apk_db_index_write_nr_cache(db);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-08-13 11:10:30 +00:00
|
|
|
os = apk_ostream_to_file(db->root_fd,
|
2011-03-16 14:52:14 +00:00
|
|
|
apk_triggers_file,
|
|
|
|
apk_triggers_file_tmp,
|
2009-08-13 11:10:30 +00:00
|
|
|
0644);
|
|
|
|
if (os == NULL)
|
|
|
|
return -1;
|
|
|
|
apk_db_triggers_write(db, os);
|
|
|
|
r = os->close(os);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-21 16:30:10 +00:00
|
|
|
void apk_db_close(struct apk_database *db)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg;
|
2009-01-06 18:30:22 +00:00
|
|
|
struct apk_db_dir_instance *diri;
|
2009-01-13 18:32:18 +00:00
|
|
|
struct hlist_node *dc, *dn;
|
2009-01-06 18:30:22 +00:00
|
|
|
int i;
|
|
|
|
|
2011-03-16 12:55:08 +00:00
|
|
|
if (db->cache_remount_dir) {
|
|
|
|
do_remount(db->cache_remount_dir, "ro");
|
|
|
|
free(db->cache_remount_dir);
|
|
|
|
db->cache_remount_dir = NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-08 12:36:54 +00:00
|
|
|
apk_id_cache_free(&db->id_cache);
|
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
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) {
|
2010-09-22 14:16:18 +00:00
|
|
|
apk_db_diri_free(db, diri, APK_DISALLOW_RMDIR);
|
2009-01-06 18:30:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-04-16 17:05:22 +00:00
|
|
|
for (i = 0; i < db->num_repos; i++) {
|
2009-01-06 18:30:22 +00:00
|
|
|
free(db->repos[i].url);
|
2009-04-16 17:05:22 +00:00
|
|
|
}
|
2010-06-05 09:06:41 +00:00
|
|
|
for (i = 0; i < db->protected_paths->num; i++)
|
|
|
|
free(db->protected_paths->item[i]);
|
|
|
|
apk_dependency_array_free(&db->world);
|
|
|
|
apk_string_array_free(&db->protected_paths);
|
2009-01-06 18:30:22 +00:00
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
apk_hash_free(&db->available.packages);
|
2010-06-01 13:46:53 +00:00
|
|
|
apk_hash_free(&db->available.names);
|
2009-01-13 18:32:18 +00:00
|
|
|
apk_hash_free(&db->installed.files);
|
2008-04-17 14:09:13 +00:00
|
|
|
apk_hash_free(&db->installed.dirs);
|
2009-01-13 18:32:18 +00:00
|
|
|
|
2009-07-31 13:08:09 +00:00
|
|
|
if (db->keys_fd)
|
|
|
|
close(db->keys_fd);
|
2011-03-16 12:55:08 +00:00
|
|
|
if (db->cachetmp_fd && db->cachetmp_fd != db->cache_fd)
|
2009-07-31 13:08:09 +00:00
|
|
|
close(db->cachetmp_fd);
|
|
|
|
if (db->cache_fd)
|
|
|
|
close(db->cache_fd);
|
2009-01-17 09:07:56 +00:00
|
|
|
if (db->root_fd)
|
2008-04-21 16:30:10 +00:00
|
|
|
close(db->root_fd);
|
2009-01-17 09:07:56 +00:00
|
|
|
if (db->lock_fd)
|
|
|
|
close(db->lock_fd);
|
|
|
|
if (db->root != NULL)
|
2008-04-17 14:09:13 +00:00
|
|
|
free(db->root);
|
|
|
|
}
|
|
|
|
|
2009-08-13 11:10:30 +00:00
|
|
|
static int fire_triggers(apk_hash_item item, void *ctx)
|
|
|
|
{
|
|
|
|
struct apk_database *db = (struct apk_database *) ctx;
|
|
|
|
struct apk_db_dir *dbd = (struct apk_db_dir *) item;
|
|
|
|
struct apk_installed_package *ipkg;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
list_for_each_entry(ipkg, &db->installed.triggers, trigger_pkgs_list) {
|
|
|
|
if (((ipkg->flags & APK_IPKGF_RUN_ALL_TRIGGERS) == 0) &&
|
|
|
|
((dbd->flags & APK_DBDIRF_MODIFIED) == 0))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (i = 0; i < ipkg->triggers->num; i++) {
|
|
|
|
if (ipkg->triggers->item[i][0] != '/')
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (fnmatch(ipkg->triggers->item[i], dbd->rooted_name,
|
|
|
|
FNM_PATHNAME) != 0)
|
|
|
|
continue;
|
|
|
|
|
2010-06-05 09:06:41 +00:00
|
|
|
/* And place holder for script name */
|
|
|
|
if (ipkg->pending_triggers->num == 0)
|
2009-08-13 16:21:31 +00:00
|
|
|
*apk_string_array_add(&ipkg->pending_triggers) =
|
|
|
|
NULL;
|
2009-08-13 11:10:30 +00:00
|
|
|
*apk_string_array_add(&ipkg->pending_triggers) =
|
|
|
|
dbd->rooted_name;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int apk_db_run_triggers(struct apk_database *db)
|
|
|
|
{
|
|
|
|
struct apk_installed_package *ipkg;
|
|
|
|
|
|
|
|
apk_hash_foreach(&db->installed.dirs, fire_triggers, db);
|
|
|
|
|
|
|
|
list_for_each_entry(ipkg, &db->installed.triggers, trigger_pkgs_list) {
|
2010-06-05 09:06:41 +00:00
|
|
|
if (ipkg->pending_triggers->num == 0)
|
2009-08-13 11:10:30 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
*apk_string_array_add(&ipkg->pending_triggers) = NULL;
|
2010-10-08 12:36:54 +00:00
|
|
|
apk_ipkg_run_script(ipkg, db, APK_SCRIPT_TRIGGER,
|
2009-08-13 11:10:30 +00:00
|
|
|
ipkg->pending_triggers->item);
|
2010-06-05 09:06:41 +00:00
|
|
|
apk_string_array_free(&ipkg->pending_triggers);
|
2009-08-13 11:10:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-29 08:22:55 +00:00
|
|
|
int apk_db_cache_active(struct apk_database *db)
|
|
|
|
{
|
|
|
|
return db->cache_dir != apk_static_cache_dir;
|
|
|
|
}
|
|
|
|
|
2009-07-22 17:47:21 +00:00
|
|
|
int apk_db_permanent(struct apk_database *db)
|
|
|
|
{
|
2009-07-24 11:00:57 +00:00
|
|
|
return db->permanent;
|
2009-07-22 17:47:21 +00:00
|
|
|
}
|
|
|
|
|
2009-07-14 16:14:05 +00:00
|
|
|
struct apk_package *apk_db_get_pkg(struct apk_database *db,
|
|
|
|
struct apk_checksum *csum)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2009-07-14 16:14:05 +00:00
|
|
|
return apk_hash_get(&db->available.packages, APK_BLOB_CSUM(*csum));
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-01-13 13:22:14 +00:00
|
|
|
struct apk_package *apk_db_get_file_owner(struct apk_database *db,
|
|
|
|
apk_blob_t filename)
|
|
|
|
{
|
2009-01-13 18:32:18 +00:00
|
|
|
struct apk_db_file *dbf;
|
2009-01-14 08:44:47 +00:00
|
|
|
struct apk_db_file_hash_key key;
|
2009-01-13 13:22:14 +00:00
|
|
|
|
2009-01-13 18:32:18 +00:00
|
|
|
if (filename.len && filename.ptr[0] == '/')
|
|
|
|
filename.len--, filename.ptr++;
|
2009-01-13 13:22:14 +00:00
|
|
|
|
2009-01-14 08:44:47 +00:00
|
|
|
if (!apk_blob_rsplit(filename, '/', &key.dirname, &key.filename))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
dbf = (struct apk_db_file *) apk_hash_get(&db->installed.files,
|
|
|
|
APK_BLOB_BUF(&key));
|
2009-01-13 18:32:18 +00:00
|
|
|
if (dbf == NULL)
|
2009-01-13 13:22:14 +00:00
|
|
|
return NULL;
|
|
|
|
|
2009-01-13 18:32:18 +00:00
|
|
|
return dbf->diri->pkg;
|
2009-01-13 13:22:14 +00:00
|
|
|
}
|
|
|
|
|
2011-04-07 11:14:27 +00:00
|
|
|
int apk_repo_format_filename(char *buf, size_t len,
|
|
|
|
const char *repourl, apk_blob_t *arch,
|
|
|
|
const char *item)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if (arch != NULL)
|
|
|
|
n = snprintf(buf, len, "%s%s" BLOB_FMT "/%s",
|
|
|
|
repourl, repourl[strlen(repourl)-1] == '/' ? "" : "/",
|
|
|
|
BLOB_PRINTF(*arch), item);
|
|
|
|
else
|
|
|
|
n = snprintf(buf, len, "%s%s%s",
|
|
|
|
repourl, repourl[strlen(repourl)-1] == '/' ? "" : "/",
|
|
|
|
item);
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2009-08-11 15:28:22 +00:00
|
|
|
static int apk_repo_is_remote(struct apk_repository *repo)
|
|
|
|
{
|
|
|
|
return repo->csum.type != APK_CHECKSUM_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct apk_bstream *apk_repo_file_open(struct apk_repository *repo,
|
2011-03-16 12:51:44 +00:00
|
|
|
apk_blob_t *arch,
|
2010-12-09 09:10:12 +00:00
|
|
|
const char *file,
|
|
|
|
char *buf, int buflen)
|
2009-04-16 17:05:22 +00:00
|
|
|
{
|
2009-07-22 08:36:55 +00:00
|
|
|
const char *url = repo->url;
|
2009-04-16 17:05:22 +00:00
|
|
|
|
2011-04-07 11:14:27 +00:00
|
|
|
apk_repo_format_filename(buf, buflen, url, arch, file);
|
2010-12-09 09:10:12 +00:00
|
|
|
|
2009-08-11 15:28:22 +00:00
|
|
|
if ((apk_flags & APK_NO_NETWORK) && apk_repo_is_remote(repo))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* We should not get called for non-repository files */
|
|
|
|
if (strcmp(repo->url, "cache") == 0)
|
|
|
|
return NULL;
|
|
|
|
|
2010-12-09 09:10:12 +00:00
|
|
|
return apk_bstream_from_url(buf);
|
2009-04-16 17:05:22 +00:00
|
|
|
}
|
|
|
|
|
2009-08-06 13:00:20 +00:00
|
|
|
struct apk_repository *apk_db_select_repo(struct apk_database *db,
|
|
|
|
struct apk_package *pkg)
|
|
|
|
{
|
2009-08-11 15:28:22 +00:00
|
|
|
static struct apk_repository cache_repo = {
|
|
|
|
.url = "cache",
|
|
|
|
.csum.data = {
|
|
|
|
0xb0,0x35,0x92,0x80,0x6e,0xfa,0xbf,0xee,0xb7,0x09,
|
|
|
|
0xf5,0xa7,0x0a,0x7c,0x17,0x26,0x69,0xb0,0x05,0x38 },
|
|
|
|
.csum.type = APK_CHECKSUM_SHA1,
|
|
|
|
};
|
2009-08-06 13:00:20 +00:00
|
|
|
unsigned int repos = pkg->repos;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* Always prefer local repositories */
|
|
|
|
if ((repos & db->local_repos) != 0)
|
|
|
|
repos &= db->local_repos;
|
|
|
|
|
|
|
|
/* Pick first repository providing this package */
|
|
|
|
for (i = 0; i < APK_MAX_REPOS; i++)
|
|
|
|
if (repos & BIT(i))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* If this is a remote repository, and we have no network,
|
|
|
|
* check that we have it in cache */
|
2009-08-11 15:28:22 +00:00
|
|
|
if ((i >= APK_MAX_REPOS) ||
|
|
|
|
((db->local_repos & BIT(i)) == 0 && (apk_flags & APK_NO_NETWORK))) {
|
2009-08-06 13:00:20 +00:00
|
|
|
char cacheitem[PATH_MAX];
|
|
|
|
|
|
|
|
apk_pkg_format_cache(pkg, APK_BLOB_BUF(cacheitem));
|
|
|
|
if (faccessat(db->cache_fd, cacheitem, R_OK, 0) != 0)
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-08-11 15:28:22 +00:00
|
|
|
if (i >= APK_MAX_REPOS)
|
|
|
|
return &cache_repo;
|
|
|
|
|
2009-08-06 13:00:20 +00:00
|
|
|
return &db->repos[i];
|
|
|
|
}
|
|
|
|
|
2009-06-29 08:22:55 +00:00
|
|
|
int apk_repository_update(struct apk_database *db, struct apk_repository *repo)
|
|
|
|
{
|
2009-07-31 13:08:09 +00:00
|
|
|
char cacheitem[PATH_MAX];
|
2009-07-20 08:13:03 +00:00
|
|
|
int r;
|
|
|
|
|
2009-08-11 15:28:22 +00:00
|
|
|
if (!apk_repo_is_remote(repo))
|
2009-06-29 08:22:55 +00:00
|
|
|
return 0;
|
|
|
|
|
2010-12-10 14:42:25 +00:00
|
|
|
apk_cache_format_index(APK_BLOB_BUF(cacheitem), repo);
|
2011-03-16 12:51:44 +00:00
|
|
|
r = apk_cache_download(db, repo->url, db->arch, apkindex_tar_gz, cacheitem,
|
2009-07-30 19:16:37 +00:00
|
|
|
(apk_flags & APK_ALLOW_UNTRUSTED) ?
|
|
|
|
APK_SIGN_NONE : APK_SIGN_VERIFY);
|
2009-07-20 08:41:45 +00:00
|
|
|
if (r != 0)
|
2010-12-10 14:42:25 +00:00
|
|
|
apk_error("%s: %s", repo->url, apk_error_str(r));
|
|
|
|
|
2009-07-20 08:41:45 +00:00
|
|
|
return r;
|
2009-07-20 08:13:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct apkindex_ctx {
|
|
|
|
struct apk_database *db;
|
|
|
|
struct apk_sign_ctx sctx;
|
2009-07-23 08:41:10 +00:00
|
|
|
int repo, found;
|
2009-07-20 08:13:03 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int load_apkindex(void *sctx, const struct apk_file_info *fi,
|
|
|
|
struct apk_istream *is)
|
|
|
|
{
|
|
|
|
struct apkindex_ctx *ctx = (struct apkindex_ctx *) sctx;
|
|
|
|
struct apk_bstream *bs;
|
2009-09-03 10:56:24 +00:00
|
|
|
struct apk_repository *repo;
|
2009-07-20 08:13:03 +00:00
|
|
|
|
|
|
|
if (apk_sign_ctx_process_file(&ctx->sctx, fi, is) == 0)
|
|
|
|
return 0;
|
|
|
|
|
2009-09-03 10:56:24 +00:00
|
|
|
repo = &ctx->db->repos[ctx->repo];
|
2009-07-20 08:13:03 +00:00
|
|
|
|
2009-09-03 10:56:24 +00:00
|
|
|
if (strcmp(fi->name, "DESCRIPTION") == 0) {
|
|
|
|
repo->description = apk_blob_from_istream(is, fi->size);
|
|
|
|
} else if (strcmp(fi->name, "APKINDEX") == 0) {
|
|
|
|
ctx->found = 1;
|
|
|
|
bs = apk_bstream_from_istream(is);
|
|
|
|
apk_db_index_read(ctx->db, bs, ctx->repo);
|
|
|
|
bs->close(bs, NULL);
|
|
|
|
}
|
2009-07-20 08:13:03 +00:00
|
|
|
|
2009-07-23 08:41:10 +00:00
|
|
|
return 0;
|
2009-06-29 08:22:55 +00:00
|
|
|
}
|
|
|
|
|
2009-07-21 14:59:08 +00:00
|
|
|
static int load_index(struct apk_database *db, struct apk_bstream *bs,
|
|
|
|
int targz, int repo)
|
|
|
|
{
|
2009-07-23 08:35:40 +00:00
|
|
|
int r = 0;
|
|
|
|
|
2009-07-21 14:59:08 +00:00
|
|
|
if (targz) {
|
|
|
|
struct apk_istream *is;
|
|
|
|
struct apkindex_ctx ctx;
|
|
|
|
|
|
|
|
ctx.db = db;
|
|
|
|
ctx.repo = repo;
|
2009-07-23 08:41:10 +00:00
|
|
|
ctx.found = 0;
|
2009-07-31 13:08:09 +00:00
|
|
|
apk_sign_ctx_init(&ctx.sctx, APK_SIGN_VERIFY, NULL, db->keys_fd);
|
2009-07-21 14:59:08 +00:00
|
|
|
is = apk_bstream_gunzip_mpart(bs, apk_sign_ctx_mpart_cb, &ctx.sctx);
|
2010-10-08 12:36:54 +00:00
|
|
|
r = apk_tar_parse(is, load_apkindex, &ctx, FALSE, &db->id_cache);
|
2009-07-21 14:59:08 +00:00
|
|
|
is->close(is);
|
|
|
|
apk_sign_ctx_free(&ctx.sctx);
|
2009-07-23 08:41:10 +00:00
|
|
|
if (ctx.found == 0)
|
2009-07-23 08:35:40 +00:00
|
|
|
r = -ENOMSG;
|
2009-07-21 14:59:08 +00:00
|
|
|
} else {
|
|
|
|
bs = apk_bstream_from_istream(apk_bstream_gunzip(bs));
|
|
|
|
apk_db_index_read(db, bs, repo);
|
|
|
|
bs->close(bs, NULL);
|
|
|
|
}
|
2009-07-23 08:35:40 +00:00
|
|
|
return r;
|
2009-07-21 14:59:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int apk_db_index_read_file(struct apk_database *db, const char *file, int repo)
|
|
|
|
{
|
|
|
|
int targz = 1;
|
|
|
|
|
|
|
|
if (strstr(file, ".tar.gz") == NULL && strstr(file, ".gz") != NULL)
|
|
|
|
targz = 0;
|
|
|
|
|
2009-07-31 13:08:09 +00:00
|
|
|
return load_index(db, apk_bstream_from_file(AT_FDCWD, file), targz, repo);
|
2009-07-21 14:59:08 +00:00
|
|
|
}
|
|
|
|
|
2009-04-16 17:05:22 +00:00
|
|
|
int apk_db_add_repository(apk_database_t _db, apk_blob_t repository)
|
|
|
|
{
|
|
|
|
struct apk_database *db = _db.db;
|
2009-06-28 17:36:16 +00:00
|
|
|
struct apk_bstream *bs = NULL;
|
|
|
|
struct apk_repository *repo;
|
2009-07-20 08:13:03 +00:00
|
|
|
int r, targz = 1;
|
2010-12-09 09:10:12 +00:00
|
|
|
char buf[PATH_MAX];
|
2009-04-16 17:05:22 +00:00
|
|
|
|
2009-08-11 13:01:29 +00:00
|
|
|
if (repository.ptr == NULL || repository.len == 0 ||
|
|
|
|
*repository.ptr == '#')
|
2009-01-08 09:12:39 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
if (db->num_repos >= APK_MAX_REPOS)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
r = db->num_repos++;
|
2009-06-28 17:36:16 +00:00
|
|
|
|
|
|
|
repo = &db->repos[r];
|
|
|
|
*repo = (struct apk_repository) {
|
2009-04-16 17:05:22 +00:00
|
|
|
.url = apk_blob_cstr(repository),
|
2008-04-17 14:09:13 +00:00
|
|
|
};
|
|
|
|
|
2009-06-28 17:36:16 +00:00
|
|
|
if (apk_url_local_file(repo->url) == NULL) {
|
2009-08-11 16:02:22 +00:00
|
|
|
apk_blob_checksum(repository, apk_checksum_default(), &repo->csum);
|
2009-04-16 17:05:22 +00:00
|
|
|
|
2009-07-07 09:12:24 +00:00
|
|
|
if (apk_flags & APK_UPDATE_CACHE)
|
2009-07-20 08:13:03 +00:00
|
|
|
apk_repository_update(db, repo);
|
2009-07-07 09:12:24 +00:00
|
|
|
|
2010-12-10 14:42:25 +00:00
|
|
|
apk_cache_format_index(APK_BLOB_BUF(buf), repo);
|
2010-12-09 09:10:12 +00:00
|
|
|
bs = apk_bstream_from_file(db->cache_fd, buf);
|
2009-04-16 17:05:22 +00:00
|
|
|
} else {
|
2009-08-06 13:00:20 +00:00
|
|
|
db->local_repos |= BIT(r);
|
2011-03-16 12:51:44 +00:00
|
|
|
bs = apk_repo_file_open(repo, db->arch, apkindex_tar_gz, buf, sizeof(buf));
|
2009-04-16 17:05:22 +00:00
|
|
|
}
|
2009-07-14 06:33:32 +00:00
|
|
|
if (bs == NULL) {
|
2011-01-05 12:32:01 +00:00
|
|
|
apk_warning("%s: index failed to open", buf);
|
2009-08-06 10:12:26 +00:00
|
|
|
return 0;
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-07-21 14:59:08 +00:00
|
|
|
r = load_index(db, bs, targz, r);
|
|
|
|
if (r != 0)
|
2011-01-05 12:32:01 +00:00
|
|
|
apk_error("%s: BAD signature", buf);
|
2009-07-21 14:59:08 +00:00
|
|
|
return r;
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
|
2009-01-07 19:45:11 +00:00
|
|
|
static void extract_cb(void *_ctx, size_t progress)
|
|
|
|
{
|
|
|
|
struct install_ctx *ctx = (struct install_ctx *) _ctx;
|
|
|
|
|
|
|
|
if (ctx->cb) {
|
|
|
|
size_t size = ctx->installed_size;
|
|
|
|
|
|
|
|
size += muldiv(progress, ctx->current_file_size, APK_PROGRESS_SCALE);
|
|
|
|
if (size > ctx->pkg->installed_size)
|
|
|
|
size = ctx->pkg->installed_size;
|
|
|
|
|
|
|
|
ctx->cb(ctx->cb_ctx, muldiv(APK_PROGRESS_SCALE, size, ctx->pkg->installed_size));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-21 11:06:35 +00:00
|
|
|
static int apk_db_run_pending_script(struct install_ctx *ctx)
|
|
|
|
{
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (!ctx->script_pending)
|
|
|
|
return 0;
|
|
|
|
if (!ctx->sctx.control_verified)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ctx->script_pending = FALSE;
|
2010-10-08 12:36:54 +00:00
|
|
|
r = apk_ipkg_run_script(ctx->ipkg, ctx->db, ctx->script,
|
2009-08-12 16:17:46 +00:00
|
|
|
ctx->script_args);
|
2009-07-21 11:06:35 +00:00
|
|
|
if (r != 0)
|
|
|
|
apk_error("%s-%s: Failed to execute "
|
|
|
|
"pre-install/upgrade script",
|
|
|
|
ctx->pkg->name->name, ctx->pkg->version);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2009-08-04 13:54:15 +00:00
|
|
|
static int parse_replaces(void *_ctx, apk_blob_t blob)
|
|
|
|
{
|
|
|
|
struct install_ctx *ctx = (struct install_ctx *) _ctx;
|
|
|
|
|
|
|
|
if (blob.len == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
*apk_name_array_add(&ctx->replaces) = apk_db_get_name(ctx->db, blob);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int read_info_line(void *_ctx, apk_blob_t line)
|
|
|
|
{
|
|
|
|
struct install_ctx *ctx = (struct install_ctx *) _ctx;
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg = ctx->ipkg;
|
|
|
|
struct apk_database *db = ctx->db;
|
2009-08-04 13:54:15 +00:00
|
|
|
apk_blob_t l, r;
|
|
|
|
|
|
|
|
if (line.ptr == NULL || line.len < 1 || line.ptr[0] == '#')
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!apk_blob_split(line, APK_BLOB_STR(" = "), &l, &r))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (apk_blob_compare(APK_BLOB_STR("replaces"), l) == 0) {
|
|
|
|
apk_blob_for_each_segment(r, " ", parse_replaces, ctx);
|
2009-08-12 16:17:46 +00:00
|
|
|
} else if (apk_blob_compare(APK_BLOB_STR("triggers"), l) == 0) {
|
2010-06-05 09:06:41 +00:00
|
|
|
apk_string_array_resize(&ipkg->triggers, 0);
|
2009-08-13 11:10:30 +00:00
|
|
|
apk_blob_for_each_segment(r, " ", parse_triggers, ctx->ipkg);
|
2009-08-13 15:41:03 +00:00
|
|
|
|
2010-06-05 09:06:41 +00:00
|
|
|
if (ctx->ipkg->triggers->num != 0 &&
|
|
|
|
!list_hashed(&ipkg->trigger_pkgs_list))
|
2009-08-13 11:10:30 +00:00
|
|
|
list_add_tail(&ipkg->trigger_pkgs_list,
|
|
|
|
&db->installed.triggers);
|
2009-08-12 16:17:46 +00:00
|
|
|
} else {
|
|
|
|
apk_sign_ctx_parse_pkginfo_line(&ctx->sctx, line);
|
2009-08-04 13:54:15 +00:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-07 15:11:08 +00:00
|
|
|
static int apk_db_install_archive_entry(void *_ctx,
|
2008-11-14 12:26:59 +00:00
|
|
|
const struct apk_file_info *ae,
|
2008-11-07 15:11:08 +00:00
|
|
|
struct apk_istream *is)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2008-11-07 15:11:08 +00:00
|
|
|
struct install_ctx *ctx = (struct install_ctx *) _ctx;
|
2008-04-17 14:09:13 +00:00
|
|
|
struct apk_database *db = ctx->db;
|
2009-01-06 17:44:54 +00:00
|
|
|
struct apk_package *pkg = ctx->pkg, *opkg;
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg = pkg->ipkg;
|
2009-01-06 17:44:54 +00:00
|
|
|
apk_blob_t name = APK_BLOB_STR(ae->name), bdir, bfile;
|
|
|
|
struct apk_db_dir_instance *diri = ctx->diri;
|
2008-04-17 14:09:13 +00:00
|
|
|
struct apk_db_file *file;
|
2008-11-07 11:05:55 +00:00
|
|
|
int r = 0, type = APK_SCRIPT_INVALID;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-08-10 05:47:05 +00:00
|
|
|
if (apk_sign_ctx_process_file(&ctx->sctx, ae, is) == 0)
|
|
|
|
return 0;
|
|
|
|
|
2008-11-07 11:05:55 +00:00
|
|
|
/* Package metainfo and script processing */
|
|
|
|
if (ae->name[0] == '.') {
|
|
|
|
/* APK 2.0 format */
|
2009-08-04 13:54:15 +00:00
|
|
|
if (strcmp(ae->name, ".PKGINFO") == 0) {
|
|
|
|
apk_blob_t blob = apk_blob_from_istream(is, ae->size);
|
|
|
|
apk_blob_for_each_segment(blob, "\n", read_info_line, ctx);
|
|
|
|
free(blob.ptr);
|
|
|
|
return 0;
|
|
|
|
}
|
2009-07-16 05:52:22 +00:00
|
|
|
type = apk_script_type(&ae->name[1]);
|
2009-02-27 09:18:15 +00:00
|
|
|
if (type == APK_SCRIPT_INVALID)
|
2008-11-07 11:05:55 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2008-11-07 11:05:55 +00:00
|
|
|
/* Handle script */
|
|
|
|
if (type != APK_SCRIPT_INVALID) {
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_ipkg_add_script(ipkg, is, type, ae->size);
|
2009-07-21 11:06:35 +00:00
|
|
|
if (type == ctx->script)
|
|
|
|
ctx->script_pending = TRUE;
|
|
|
|
return apk_db_run_pending_script(ctx);
|
|
|
|
}
|
|
|
|
r = apk_db_run_pending_script(ctx);
|
|
|
|
if (r != 0)
|
2008-04-17 14:09:13 +00:00
|
|
|
return r;
|
2009-07-21 11:06:35 +00:00
|
|
|
|
2009-01-07 19:45:11 +00:00
|
|
|
/* Show progress */
|
|
|
|
if (ctx->cb) {
|
|
|
|
size_t size = ctx->installed_size;
|
|
|
|
if (size > pkg->installed_size)
|
|
|
|
size = pkg->installed_size;
|
|
|
|
ctx->cb(ctx->cb_ctx, muldiv(APK_PROGRESS_SCALE, size, pkg->installed_size));
|
|
|
|
}
|
|
|
|
|
2008-11-07 11:05:55 +00:00
|
|
|
/* Installable entry */
|
2009-01-07 19:45:11 +00:00
|
|
|
ctx->current_file_size = apk_calc_installed_size(ae->size);
|
2008-04-17 14:09:13 +00:00
|
|
|
if (!S_ISDIR(ae->mode)) {
|
2009-01-06 17:44:54 +00:00
|
|
|
if (!apk_blob_rsplit(name, '/', &bdir, &bfile))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (bfile.len > 6 && memcmp(bfile.ptr, ".keep_", 6) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Make sure the file is part of the cached directory tree */
|
2009-08-12 16:17:46 +00:00
|
|
|
diri = find_diri(ipkg, bdir, diri, &ctx->file_diri_node);
|
2009-07-31 17:05:04 +00:00
|
|
|
if (diri == NULL) {
|
|
|
|
apk_error("%s: File '%*s' entry without directory entry.\n",
|
|
|
|
pkg->name->name, name.len, name.ptr);
|
|
|
|
return -1;
|
2009-01-06 17:44:54 +00:00
|
|
|
}
|
|
|
|
|
2009-08-04 12:19:29 +00:00
|
|
|
opkg = NULL;
|
2009-07-22 08:36:55 +00:00
|
|
|
file = apk_db_file_query(db, bdir, bfile);
|
|
|
|
if (file != NULL) {
|
2009-08-04 13:54:15 +00:00
|
|
|
int i;
|
|
|
|
|
2009-01-06 17:44:54 +00:00
|
|
|
opkg = file->diri->pkg;
|
2009-08-04 13:54:15 +00:00
|
|
|
do {
|
2009-12-21 12:14:02 +00:00
|
|
|
/* Overlay file? */
|
|
|
|
if (opkg->name == NULL)
|
|
|
|
break;
|
|
|
|
/* Upgrading package? */
|
2009-08-04 13:54:15 +00:00
|
|
|
if (opkg->name == pkg->name)
|
|
|
|
break;
|
2009-12-21 12:14:02 +00:00
|
|
|
/* Overwriting with permission? */
|
2010-06-07 14:45:04 +00:00
|
|
|
for (i = 0; i < ctx->replaces->num; i++)
|
2009-08-04 13:54:15 +00:00
|
|
|
if (opkg->name == ctx->replaces->item[i])
|
|
|
|
break;
|
2010-06-07 14:45:04 +00:00
|
|
|
if (i < ctx->replaces->num)
|
2009-08-04 13:54:15 +00:00
|
|
|
break;
|
|
|
|
|
2009-04-14 15:48:02 +00:00
|
|
|
if (!(apk_flags & APK_FORCE)) {
|
2009-03-04 06:36:56 +00:00
|
|
|
apk_error("%s: Trying to overwrite %s "
|
2009-07-21 10:49:35 +00:00
|
|
|
"owned by %s.",
|
2009-03-04 06:36:56 +00:00
|
|
|
pkg->name->name, ae->name,
|
|
|
|
opkg->name->name);
|
|
|
|
return -1;
|
|
|
|
}
|
2009-07-21 10:49:35 +00:00
|
|
|
apk_warning("%s: Overwriting %s owned by %s.",
|
2009-03-04 06:36:56 +00:00
|
|
|
pkg->name->name, ae->name,
|
|
|
|
opkg->name->name);
|
2009-08-04 13:54:15 +00:00
|
|
|
} while (0);
|
2009-01-16 07:32:04 +00:00
|
|
|
}
|
2009-06-28 15:05:17 +00:00
|
|
|
|
2009-08-04 12:19:29 +00:00
|
|
|
if (opkg != pkg) {
|
|
|
|
/* Create the file entry without adding it to hash */
|
|
|
|
file = apk_db_file_new(diri, bfile, &ctx->file_diri_node);
|
|
|
|
}
|
2009-07-22 08:36:55 +00:00
|
|
|
|
2009-07-24 11:04:57 +00:00
|
|
|
if (apk_verbosity >= 3)
|
|
|
|
apk_message("%s", ae->name);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-07-22 08:36:55 +00:00
|
|
|
/* Extract the file as name.apk-new */
|
2009-07-31 13:08:09 +00:00
|
|
|
r = apk_archive_entry_extract(db->root_fd, ae, ".apk-new", is,
|
2009-07-22 08:36:55 +00:00
|
|
|
extract_cb, ctx);
|
2009-07-31 17:05:04 +00:00
|
|
|
|
|
|
|
/* Hardlinks need special care for checksum */
|
|
|
|
if (ae->csum.type == APK_CHECKSUM_NONE &&
|
|
|
|
ae->link_target != NULL) {
|
|
|
|
do {
|
|
|
|
struct apk_db_file *lfile;
|
|
|
|
struct apk_db_dir_instance *ldiri;
|
|
|
|
struct hlist_node *n;
|
|
|
|
|
|
|
|
if (!apk_blob_rsplit(APK_BLOB_STR(ae->link_target),
|
|
|
|
'/', &bdir, &bfile))
|
|
|
|
break;
|
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
ldiri = find_diri(ipkg, bdir, diri, NULL);
|
2009-07-31 17:05:04 +00:00
|
|
|
if (ldiri == NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
hlist_for_each_entry(lfile, n, &ldiri->owned_files,
|
|
|
|
diri_files_list) {
|
|
|
|
if (apk_blob_compare(APK_BLOB_PTR_LEN(lfile->name, lfile->namelen),
|
|
|
|
bfile) == 0) {
|
|
|
|
memcpy(&file->csum, &lfile->csum,
|
|
|
|
sizeof(file->csum));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
} else
|
|
|
|
memcpy(&file->csum, &ae->csum, sizeof(file->csum));
|
2008-04-17 14:09:13 +00:00
|
|
|
} else {
|
2009-07-24 11:04:57 +00:00
|
|
|
if (apk_verbosity >= 3)
|
|
|
|
apk_message("%s", ae->name);
|
2009-01-22 15:55:27 +00:00
|
|
|
|
2008-04-17 14:09:13 +00:00
|
|
|
if (name.ptr[name.len-1] == '/')
|
|
|
|
name.len--;
|
2009-01-06 17:44:54 +00:00
|
|
|
|
|
|
|
if (ctx->diri_node == NULL)
|
2009-08-12 16:17:46 +00:00
|
|
|
ctx->diri_node = hlist_tail_ptr(&ipkg->owned_dirs);
|
2009-01-06 17:44:54 +00:00
|
|
|
ctx->diri = diri = apk_db_diri_new(db, pkg, name,
|
2009-01-16 07:32:04 +00:00
|
|
|
&ctx->diri_node);
|
|
|
|
ctx->file_diri_node = hlist_tail_ptr(&diri->owned_files);
|
2009-01-06 17:44:54 +00:00
|
|
|
|
|
|
|
apk_db_diri_set(diri, ae->mode & 0777, ae->uid, ae->gid);
|
2009-07-31 13:08:09 +00:00
|
|
|
apk_db_diri_mkdir(db, diri);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
2009-01-07 19:45:11 +00:00
|
|
|
ctx->installed_size += ctx->current_file_size;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
static void apk_db_purge_pkg(struct apk_database *db,
|
|
|
|
struct apk_installed_package *ipkg,
|
2009-07-22 08:36:55 +00:00
|
|
|
const char *exten)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
2009-01-06 17:44:54 +00:00
|
|
|
struct apk_db_dir_instance *diri;
|
2008-04-17 14:09:13 +00:00
|
|
|
struct apk_db_file *file;
|
2009-01-16 07:32:04 +00:00
|
|
|
struct apk_db_file_hash_key key;
|
2009-07-22 18:34:25 +00:00
|
|
|
struct apk_file_info fi;
|
2009-01-06 17:44:54 +00:00
|
|
|
struct hlist_node *dc, *dn, *fc, *fn;
|
2009-07-14 08:55:08 +00:00
|
|
|
unsigned long hash;
|
2009-08-13 15:41:03 +00:00
|
|
|
char name[PATH_MAX];
|
2009-01-06 17:44:54 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
hlist_for_each_entry_safe(diri, dc, dn, &ipkg->owned_dirs, pkg_dirs_list) {
|
|
|
|
if (exten == NULL)
|
|
|
|
diri->dir->flags |= APK_DBDIRF_MODIFIED;
|
|
|
|
|
2009-01-06 17:44:54 +00:00
|
|
|
hlist_for_each_entry_safe(file, fc, fn, &diri->owned_files, diri_files_list) {
|
2009-07-22 08:36:55 +00:00
|
|
|
snprintf(name, sizeof(name), "%s/%s%s",
|
|
|
|
diri->dir->name, file->name, exten ?: "");
|
2009-01-16 07:32:04 +00:00
|
|
|
|
|
|
|
key = (struct apk_db_file_hash_key) {
|
2009-07-14 08:55:08 +00:00
|
|
|
.dirname = APK_BLOB_PTR_LEN(diri->dir->name, diri->dir->namelen),
|
|
|
|
.filename = APK_BLOB_PTR_LEN(file->name, file->namelen),
|
2009-01-16 07:32:04 +00:00
|
|
|
};
|
2009-07-14 08:55:08 +00:00
|
|
|
hash = apk_blob_hash_seed(key.filename, diri->dir->hash);
|
2009-07-22 18:34:25 +00:00
|
|
|
if (!(diri->dir->flags & APK_DBDIRF_PROTECTED) ||
|
|
|
|
(apk_flags & APK_PURGE) ||
|
2009-07-30 08:55:59 +00:00
|
|
|
(file->csum.type != APK_CHECKSUM_NONE &&
|
2009-10-26 07:46:09 +00:00
|
|
|
apk_file_get_info(db->root_fd, name, APK_FI_NOFOLLOW | file->csum.type, &fi) == 0 &&
|
2009-07-22 18:34:25 +00:00
|
|
|
apk_checksum_compare(&file->csum, &fi.csum) == 0))
|
2009-07-31 13:08:09 +00:00
|
|
|
unlinkat(db->root_fd, name, 0);
|
2009-07-24 11:04:57 +00:00
|
|
|
if (apk_verbosity >= 3)
|
|
|
|
apk_message("%s", name);
|
2009-01-06 17:44:54 +00:00
|
|
|
__hlist_del(fc, &diri->owned_files.first);
|
2009-07-22 08:36:55 +00:00
|
|
|
if (exten == NULL) {
|
|
|
|
apk_hash_delete_hashed(&db->installed.files, APK_BLOB_BUF(&key), hash);
|
|
|
|
db->installed.stats.files--;
|
|
|
|
}
|
2009-01-06 17:44:54 +00:00
|
|
|
}
|
2009-08-12 16:17:46 +00:00
|
|
|
__hlist_del(dc, &ipkg->owned_dirs.first);
|
2010-09-22 14:16:18 +00:00
|
|
|
apk_db_diri_free(db, diri, APK_ALLOW_RMDIR);
|
2008-04-17 14:09:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-07-22 08:36:55 +00:00
|
|
|
|
|
|
|
static void apk_db_migrate_files(struct apk_database *db,
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg)
|
2009-07-22 08:36:55 +00:00
|
|
|
{
|
|
|
|
struct apk_db_dir_instance *diri;
|
|
|
|
struct apk_db_dir *dir;
|
|
|
|
struct apk_db_file *file, *ofile;
|
|
|
|
struct apk_db_file_hash_key key;
|
|
|
|
struct apk_file_info fi;
|
|
|
|
struct hlist_node *dc, *dn, *fc, *fn;
|
|
|
|
unsigned long hash;
|
2009-08-04 12:19:29 +00:00
|
|
|
char name[PATH_MAX], tmpname[PATH_MAX];
|
2009-07-29 16:39:59 +00:00
|
|
|
int cstype, r;
|
2009-07-22 08:36:55 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
hlist_for_each_entry_safe(diri, dc, dn, &ipkg->owned_dirs, pkg_dirs_list) {
|
2009-07-22 08:36:55 +00:00
|
|
|
dir = diri->dir;
|
2009-08-12 16:17:46 +00:00
|
|
|
dir->flags |= APK_DBDIRF_MODIFIED;
|
2009-07-22 08:36:55 +00:00
|
|
|
|
|
|
|
hlist_for_each_entry_safe(file, fc, fn, &diri->owned_files, diri_files_list) {
|
|
|
|
snprintf(name, sizeof(name), "%s/%s",
|
|
|
|
diri->dir->name, file->name);
|
|
|
|
snprintf(tmpname, sizeof(tmpname), "%s/%s.apk-new",
|
|
|
|
diri->dir->name, file->name);
|
|
|
|
|
|
|
|
key = (struct apk_db_file_hash_key) {
|
|
|
|
.dirname = APK_BLOB_PTR_LEN(dir->name, dir->namelen),
|
|
|
|
.filename = APK_BLOB_PTR_LEN(file->name, file->namelen),
|
|
|
|
};
|
|
|
|
|
|
|
|
hash = apk_blob_hash_seed(key.filename, dir->hash);
|
|
|
|
|
|
|
|
/* check for existing file */
|
|
|
|
ofile = (struct apk_db_file *) apk_hash_get_hashed(
|
|
|
|
&db->installed.files, APK_BLOB_BUF(&key), hash);
|
|
|
|
|
2009-07-29 16:39:59 +00:00
|
|
|
/* We want to compare checksums only if one exists
|
|
|
|
* in db, and the file is in a protected path */
|
|
|
|
cstype = APK_CHECKSUM_NONE;
|
|
|
|
if (ofile != NULL &&
|
|
|
|
(diri->dir->flags & APK_DBDIRF_PROTECTED))
|
|
|
|
cstype = ofile->csum.type;
|
2009-10-26 07:46:09 +00:00
|
|
|
cstype |= APK_FI_NOFOLLOW;
|
2009-07-29 16:39:59 +00:00
|
|
|
|
2009-07-31 13:08:09 +00:00
|
|
|
r = apk_file_get_info(db->root_fd, name, cstype, &fi);
|
2009-12-21 16:39:53 +00:00
|
|
|
if (ofile && ofile->diri->pkg->name == NULL) {
|
2009-12-21 16:12:45 +00:00
|
|
|
/* File was from overlay, delete the
|
|
|
|
* packages version */
|
|
|
|
unlinkat(db->root_fd, tmpname, 0);
|
|
|
|
} else if ((diri->dir->flags & APK_DBDIRF_PROTECTED) &&
|
|
|
|
(r == 0) &&
|
|
|
|
(ofile == NULL ||
|
|
|
|
ofile->csum.type == APK_CHECKSUM_NONE ||
|
|
|
|
apk_checksum_compare(&ofile->csum, &fi.csum) != 0)) {
|
2009-07-22 09:00:56 +00:00
|
|
|
/* Protected directory, with file without
|
|
|
|
* db entry, or local modifications.
|
|
|
|
*
|
|
|
|
* Delete the apk-new if it's identical with the
|
|
|
|
* existing file */
|
|
|
|
if (ofile == NULL ||
|
|
|
|
ofile->csum.type != file->csum.type)
|
2009-10-26 07:46:09 +00:00
|
|
|
apk_file_get_info(db->root_fd, name,
|
|
|
|
APK_FI_NOFOLLOW | file->csum.type, &fi);
|
2009-07-22 13:00:14 +00:00
|
|
|
if ((apk_flags & APK_CLEAN_PROTECTED) ||
|
2009-07-30 08:55:59 +00:00
|
|
|
(file->csum.type != APK_CHECKSUM_NONE &&
|
|
|
|
apk_checksum_compare(&file->csum, &fi.csum) == 0))
|
2009-07-31 13:08:09 +00:00
|
|
|
unlinkat(db->root_fd, tmpname, 0);
|
2009-07-22 08:36:55 +00:00
|
|
|
} else {
|
2009-12-21 16:12:45 +00:00
|
|
|
/* Overwrite the old file */
|
|
|
|
renameat(db->root_fd, tmpname,
|
|
|
|
db->root_fd, name);
|
2009-07-22 08:36:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Claim ownership of the file in db */
|
2009-08-04 12:19:29 +00:00
|
|
|
if (ofile != file) {
|
|
|
|
if (ofile != NULL) {
|
|
|
|
hlist_del(&ofile->diri_files_list,
|
|
|
|
&ofile->diri->owned_files);
|
|
|
|
apk_hash_delete_hashed(&db->installed.files,
|
|
|
|
APK_BLOB_BUF(&key), hash);
|
|
|
|
} else
|
|
|
|
db->installed.stats.files++;
|
|
|
|
|
|
|
|
apk_hash_insert_hashed(&db->installed.files, file, hash);
|
|
|
|
}
|
2009-07-22 08:36:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-14 12:01:09 +00:00
|
|
|
static int apk_db_unpack_pkg(struct apk_database *db,
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg,
|
2009-08-04 12:19:29 +00:00
|
|
|
int upgrade, int reinstall,
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_progress_cb cb, void *cb_ctx,
|
|
|
|
char **script_args)
|
2008-04-17 14:09:13 +00:00
|
|
|
{
|
|
|
|
struct install_ctx ctx;
|
2009-06-28 17:36:16 +00:00
|
|
|
struct apk_bstream *bs = NULL;
|
2009-07-13 17:37:03 +00:00
|
|
|
struct apk_istream *tar;
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_package *pkg = ipkg->pkg;
|
2010-12-09 09:10:12 +00:00
|
|
|
char file[PATH_MAX], item[128];
|
2009-08-06 13:00:20 +00:00
|
|
|
int r, need_copy = FALSE;
|
2009-06-28 17:36:16 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
if (pkg->filename == NULL) {
|
2009-06-28 17:36:16 +00:00
|
|
|
struct apk_repository *repo;
|
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
repo = apk_db_select_repo(db, pkg);
|
2009-08-06 13:00:20 +00:00
|
|
|
if (repo == NULL) {
|
|
|
|
apk_error("%s-%s: package is not currently available",
|
2009-08-12 16:17:46 +00:00
|
|
|
pkg->name->name, pkg->version);
|
2009-01-16 13:38:04 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2009-08-11 15:28:22 +00:00
|
|
|
if (apk_db_cache_active(db) && apk_repo_is_remote(repo)) {
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_pkg_format_cache(pkg, APK_BLOB_BUF(file));
|
2009-07-31 13:08:09 +00:00
|
|
|
bs = apk_bstream_from_file(db->cache_fd, file);
|
|
|
|
}
|
2009-06-28 17:36:16 +00:00
|
|
|
|
|
|
|
if (bs == NULL) {
|
2010-12-09 09:10:12 +00:00
|
|
|
apk_pkg_format_plain(pkg, APK_BLOB_BUF(item));
|
2011-03-16 12:51:44 +00:00
|
|
|
bs = apk_repo_file_open(repo, pkg->arch,
|
|
|
|
item, file, sizeof(file));
|
2009-08-11 15:28:22 +00:00
|
|
|
if (apk_repo_is_remote(repo))
|
2009-06-28 17:36:16 +00:00
|
|
|
need_copy = TRUE;
|
|
|
|
}
|
|
|
|
} else {
|
2009-08-12 16:17:46 +00:00
|
|
|
bs = apk_bstream_from_file(AT_FDCWD, pkg->filename);
|
2010-12-09 09:10:12 +00:00
|
|
|
strncpy(file, pkg->filename, sizeof(file));
|
2009-06-28 17:36:16 +00:00
|
|
|
need_copy = TRUE;
|
|
|
|
}
|
2009-06-29 08:22:55 +00:00
|
|
|
if (!apk_db_cache_active(db))
|
|
|
|
need_copy = FALSE;
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2008-11-28 13:03:27 +00:00
|
|
|
if (bs == NULL) {
|
2008-10-26 11:35:34 +00:00
|
|
|
apk_error("%s: %s", file, strerror(errno));
|
2008-04-17 14:09:13 +00:00
|
|
|
return errno;
|
2008-10-26 11:35:34 +00:00
|
|
|
}
|
2010-12-09 09:10:12 +00:00
|
|
|
if (need_copy) {
|
|
|
|
apk_pkg_format_cache(pkg, APK_BLOB_BUF(item));
|
|
|
|
bs = apk_bstream_tee(bs, db->cachetmp_fd, item);
|
|
|
|
if (bs == NULL) {
|
|
|
|
apk_error("Unable to cache %s: %s",
|
|
|
|
file, strerror(errno));
|
|
|
|
return errno;
|
|
|
|
}
|
|
|
|
}
|
2008-04-17 14:09:13 +00:00
|
|
|
|
|
|
|
ctx = (struct install_ctx) {
|
|
|
|
.db = db,
|
2009-08-12 16:17:46 +00:00
|
|
|
.pkg = pkg,
|
|
|
|
.ipkg = ipkg,
|
2009-06-28 15:05:17 +00:00
|
|
|
.script = upgrade ?
|
2009-05-14 12:01:09 +00:00
|
|
|
APK_SCRIPT_PRE_UPGRADE : APK_SCRIPT_PRE_INSTALL,
|
2009-08-12 16:17:46 +00:00
|
|
|
.script_args = script_args,
|
2009-01-07 19:45:11 +00:00
|
|
|
.cb = cb,
|
|
|
|
.cb_ctx = cb_ctx,
|
2008-04-17 14:09:13 +00:00
|
|
|
};
|
2010-06-07 14:45:04 +00:00
|
|
|
apk_name_array_init(&ctx.replaces);
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_sign_ctx_init(&ctx.sctx, APK_SIGN_VERIFY_IDENTITY, &pkg->csum, db->keys_fd);
|
2009-07-21 10:49:35 +00:00
|
|
|
tar = apk_bstream_gunzip_mpart(bs, apk_sign_ctx_mpart_cb, &ctx.sctx);
|
2010-10-08 12:36:54 +00:00
|
|
|
r = apk_tar_parse(tar, apk_db_install_archive_entry, &ctx, TRUE, &db->id_cache);
|
2009-07-21 10:49:35 +00:00
|
|
|
apk_sign_ctx_free(&ctx.sctx);
|
2010-06-07 14:45:04 +00:00
|
|
|
apk_name_array_free(&ctx.replaces);
|
2009-07-16 10:47:26 +00:00
|
|
|
tar->close(tar);
|
2009-07-13 17:37:03 +00:00
|
|
|
|
2009-08-12 08:05:09 +00:00
|
|
|
if (need_copy) {
|
|
|
|
if (r == 0)
|
2011-01-21 07:37:19 +00:00
|
|
|
renameat(db->cachetmp_fd, item, db->cache_fd, item);
|
2009-08-12 08:05:09 +00:00
|
|
|
else
|
2011-01-21 07:37:19 +00:00
|
|
|
unlinkat(db->cachetmp_fd, item, 0);
|
2009-08-12 08:05:09 +00:00
|
|
|
}
|
|
|
|
|
2009-07-21 10:49:35 +00:00
|
|
|
if (r != 0) {
|
2010-12-09 09:10:12 +00:00
|
|
|
apk_error("%s: %s", file, apk_error_str(r));
|
2009-07-22 08:36:55 +00:00
|
|
|
goto err;
|
2009-07-21 10:49:35 +00:00
|
|
|
}
|
2009-07-21 11:06:35 +00:00
|
|
|
r = apk_db_run_pending_script(&ctx);
|
|
|
|
if (r != 0)
|
2009-07-22 08:36:55 +00:00
|
|
|
goto err;
|
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_db_migrate_files(db, ipkg);
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-05-14 12:01:09 +00:00
|
|
|
return 0;
|
2009-07-22 08:36:55 +00:00
|
|
|
err:
|
2009-08-04 12:19:29 +00:00
|
|
|
if (!reinstall)
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_db_purge_pkg(db, ipkg, ".apk-new");
|
2009-07-22 08:36:55 +00:00
|
|
|
return r;
|
2009-05-14 12:01:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int apk_db_install_pkg(struct apk_database *db,
|
|
|
|
struct apk_package *oldpkg,
|
|
|
|
struct apk_package *newpkg,
|
|
|
|
apk_progress_cb cb, void *cb_ctx)
|
|
|
|
{
|
2009-08-13 16:21:31 +00:00
|
|
|
char *script_args[] = { NULL, NULL, NULL, NULL };
|
2009-08-12 16:17:46 +00:00
|
|
|
struct apk_installed_package *ipkg;
|
2010-12-14 17:51:16 +00:00
|
|
|
int r = 0;
|
2009-05-14 12:01:09 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
/* Upgrade script gets two args: <new-pkg> <old-pkg> */
|
|
|
|
if (oldpkg != NULL && newpkg != NULL) {
|
2010-12-14 17:51:16 +00:00
|
|
|
script_args[1] = apk_blob_cstr(*newpkg->version);
|
|
|
|
script_args[2] = apk_blob_cstr(*oldpkg->version);
|
2009-08-12 16:17:46 +00:00
|
|
|
} else {
|
2010-12-14 17:51:16 +00:00
|
|
|
script_args[1] = apk_blob_cstr(*(oldpkg ? oldpkg->version : newpkg->version));
|
2009-08-12 16:17:46 +00:00
|
|
|
}
|
|
|
|
|
2009-05-14 12:01:09 +00:00
|
|
|
/* Just purging? */
|
|
|
|
if (oldpkg != NULL && newpkg == NULL) {
|
2009-08-12 16:17:46 +00:00
|
|
|
ipkg = oldpkg->ipkg;
|
|
|
|
|
|
|
|
if (ipkg == NULL)
|
2010-12-14 17:51:16 +00:00
|
|
|
goto ret_r;
|
2009-08-12 16:17:46 +00:00
|
|
|
|
2010-10-08 12:36:54 +00:00
|
|
|
r = apk_ipkg_run_script(ipkg, db,
|
2009-08-12 16:17:46 +00:00
|
|
|
APK_SCRIPT_PRE_DEINSTALL, script_args);
|
2009-05-14 12:01:09 +00:00
|
|
|
if (r != 0)
|
2010-12-14 17:51:16 +00:00
|
|
|
goto ret_r;
|
2009-05-14 12:01:09 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
apk_db_purge_pkg(db, ipkg, NULL);
|
2010-10-08 12:36:54 +00:00
|
|
|
r = apk_ipkg_run_script(ipkg, db,
|
2009-08-12 16:17:46 +00:00
|
|
|
APK_SCRIPT_POST_DEINSTALL, script_args);
|
|
|
|
apk_pkg_uninstall(db, oldpkg);
|
2010-12-14 17:51:16 +00:00
|
|
|
goto ret_r;
|
2009-05-14 12:01:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Install the new stuff */
|
2009-08-12 16:17:46 +00:00
|
|
|
ipkg = apk_pkg_install(db, newpkg);
|
2010-06-10 17:50:11 +00:00
|
|
|
ipkg->flags |= APK_IPKGF_RUN_ALL_TRIGGERS;
|
|
|
|
if (ipkg->triggers->num != 0) {
|
|
|
|
list_del(&ipkg->trigger_pkgs_list);
|
2010-06-15 11:40:46 +00:00
|
|
|
list_init(&ipkg->trigger_pkgs_list);
|
2010-06-10 17:50:11 +00:00
|
|
|
apk_string_array_free(&ipkg->triggers);
|
|
|
|
}
|
|
|
|
|
2009-07-24 11:02:56 +00:00
|
|
|
if (newpkg->installed_size != 0) {
|
2009-08-12 16:17:46 +00:00
|
|
|
r = apk_db_unpack_pkg(db, ipkg, (oldpkg != NULL),
|
|
|
|
(oldpkg == newpkg), cb, cb_ctx,
|
|
|
|
script_args);
|
|
|
|
if (r != 0) {
|
|
|
|
apk_pkg_uninstall(db, newpkg);
|
2010-12-14 17:51:16 +00:00
|
|
|
goto ret_r;
|
2009-08-12 16:17:46 +00:00
|
|
|
}
|
2009-05-14 12:01:09 +00:00
|
|
|
}
|
2008-04-17 14:09:13 +00:00
|
|
|
|
2009-08-12 16:17:46 +00:00
|
|
|
if (oldpkg != NULL && oldpkg != newpkg && oldpkg->ipkg != NULL) {
|
|
|
|
apk_db_purge_pkg(db, oldpkg->ipkg, NULL);
|
|
|
|
apk_pkg_uninstall(db, oldpkg);
|
|
|
|
}
|
2009-01-16 07:32:04 +00:00
|
|
|
|
2010-10-08 12:36:54 +00:00
|
|
|
r = apk_ipkg_run_script(ipkg, db,
|
2009-08-12 16:17:46 +00:00
|
|
|
(oldpkg == NULL) ?
|
|
|
|
APK_SCRIPT_POST_INSTALL : APK_SCRIPT_POST_UPGRADE,
|
|
|
|
script_args);
|
2008-04-22 06:04:20 +00:00
|
|
|
if (r != 0) {
|
2008-04-17 14:09:13 +00:00
|
|
|
apk_error("%s-%s: Failed to execute post-install/upgrade script",
|
|
|
|
newpkg->name->name, newpkg->version);
|
2008-04-22 06:04:20 +00:00
|
|
|
}
|
2010-12-14 17:51:16 +00:00
|
|
|
ret_r:
|
|
|
|
free(script_args[1]);
|
|
|
|
free(script_args[2]);
|
2008-04-17 14:09:13 +00:00
|
|
|
return r;
|
|
|
|
}
|