/**
* call-seq:
* dbpath() → a_string
*
* Returns the path under which permanent information like
* the list of installed packages is stored.
*/
static VALUE dbpath(VALUE self)
{
alpm_handle_t* p_alpm = NULL;
Data_Get_Struct(self, alpm_handle_t, p_alpm);
return rb_str_new2(alpm_option_get_dbpath(p_alpm));
}
static char *get_db_path(alpm_pkg_t *pkg, const char *path)
{
static char dbpath[PATH_MAX];
ssize_t len = snprintf(dbpath, PATH_MAX, "%slocal/%s-%s/%s",
alpm_option_get_dbpath(handle),
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg), path);
if(len < 0 || len >= PATH_MAX) { errno = ERANGE; return NULL; } /* TODO */
return dbpath;
}
/**
* Open a package changelog for reading. Similar to fopen in functionality,
* except that the returned 'file stream' is from the database.
* @param pkg the package (from db) to read the changelog
* @return a 'file stream' to the package changelog
*/
static void *_cache_changelog_open(pmpkg_t *pkg)
{
char clfile[PATH_MAX];
snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog",
alpm_option_get_dbpath(pkg->handle),
alpm_db_get_name(alpm_pkg_get_db(pkg)),
alpm_pkg_get_name(pkg),
alpm_pkg_get_version(pkg));
return fopen(clfile, "r");
}
pu_mtree_reader_t *pu_mtree_reader_open_package( alpm_handle_t *h, alpm_pkg_t *p) {
pu_mtree_reader_t *reader;
struct archive *mtree;
char path[PATH_MAX];
struct archive_entry *entry = NULL;
char *buf, rbuf[256];
size_t len;
FILE *fbuf;
const char *dbpath = alpm_option_get_dbpath(h);
const char *pkgname = alpm_pkg_get_name(p);
const char *pkgver = alpm_pkg_get_version(p);
if((fbuf = open_memstream(&buf, &len)) == NULL) { return NULL; }
sprintf(path, "%slocal/%s-%s/mtree", dbpath, pkgname, pkgver);
if((mtree = archive_read_new()) == NULL) { return NULL; }
archive_read_support_filter_all(mtree);
archive_read_support_format_raw(mtree);
if(archive_read_open_filename(mtree, path, 64) != ARCHIVE_OK) {
archive_read_free(mtree);
return NULL;
}
if(archive_read_next_header(mtree, &entry) != ARCHIVE_OK) {
archive_read_free(mtree);
return NULL;
}
while(1) {
ssize_t size;
while((size = archive_read_data(mtree, rbuf, 256)) == ARCHIVE_RETRY);
if(size < 0) { fclose(fbuf); free(buf); return NULL; }
if(size == 0) { break; }
fwrite(rbuf, size, 1, fbuf);
}
archive_read_free(mtree);
fclose(fbuf);
if((fbuf = fmemopen(buf, len, "r")) == NULL) {
free(buf);
return NULL;
} else if((reader = pu_mtree_reader_open_stream(fbuf)) == NULL) {
free(buf);
fclose(fbuf);
return NULL;
} else {
reader->_stream_buf = buf;
reader->_close_stream = 1;
return reader;
}
}
/**
* call-seq:
* inspect() → a_string
*
* Human-readable description.
*/
static VALUE inspect(VALUE self)
{
alpm_handle_t* p_alpm = NULL;
char buf[256];
int len;
Data_Get_Struct(self, alpm_handle_t, p_alpm);
len = sprintf(buf, "#<%s target=%s db=%s>",
rb_obj_classname(self),
alpm_option_get_root(p_alpm),
alpm_option_get_dbpath(p_alpm));
return rb_str_new(buf, len);
}
static gboolean
pk_alpm_initialize_monitor (PkBackend *backend, GError **error)
{
PkBackendAlpmPrivate *priv = pk_backend_get_user_data (backend);
_cleanup_free_ gchar * path = NULL;
_cleanup_object_unref_ GFile *directory = NULL;
path = g_strconcat (alpm_option_get_dbpath (priv->alpm) ,"/local", NULL);
directory = g_file_new_for_path (path);
priv->monitor = g_file_monitor_directory (directory, 0, NULL, error);
if (priv->monitor == NULL)
return FALSE;
g_signal_connect (priv->monitor, "changed",
G_CALLBACK (pk_backend_context_invalidate_cb), backend);
return TRUE;
}
/* Loop though files in a package and perform full file property checking. */
int check_pkg_full(alpm_pkg_t *pkg)
{
const char *root, *pkgname;
size_t errors = 0;
size_t rootlen;
char filepath[PATH_MAX];
struct archive *mtree;
struct archive_entry *entry = NULL;
size_t file_count = 0;
const alpm_list_t *lp;
root = alpm_option_get_root(config->handle);
rootlen = strlen(root);
if(rootlen + 1 > PATH_MAX) {
/* we are in trouble here */
pm_printf(ALPM_LOG_ERROR, _("path too long: %s%s\n"), root, "");
return 1;
}
strcpy(filepath, root);
pkgname = alpm_pkg_get_name(pkg);
mtree = alpm_pkg_mtree_open(pkg);
if(mtree == NULL) {
/* TODO: check error to confirm failure due to no mtree file */
if(!config->quiet) {
printf(_("%s: no mtree file\n"), pkgname);
}
return 0;
}
while(alpm_pkg_mtree_next(pkg, mtree, &entry) == ARCHIVE_OK) {
struct stat st;
const char *path = archive_entry_pathname(entry);
mode_t type;
size_t file_errors = 0;
int backup = 0;
/* strip leading "./" from path entries */
if(path[0] == '.' && path[1] == '/') {
path += 2;
}
if(strcmp(path, ".INSTALL") == 0) {
char filename[PATH_MAX];
snprintf(filename, PATH_MAX, "%slocal/%s-%s/install",
alpm_option_get_dbpath(config->handle) + 1,
pkgname, alpm_pkg_get_version(pkg));
archive_entry_set_pathname(entry, filename);
path = archive_entry_pathname(entry);
} else if(strcmp(path, ".CHANGELOG") == 0) {
char filename[PATH_MAX];
snprintf(filename, PATH_MAX, "%slocal/%s-%s/changelog",
alpm_option_get_dbpath(config->handle) + 1,
pkgname, alpm_pkg_get_version(pkg));
archive_entry_set_pathname(entry, filename);
path = archive_entry_pathname(entry);
} else if(*path == '.') {
continue;
}
file_count++;
if(rootlen + 1 + strlen(path) > PATH_MAX) {
pm_printf(ALPM_LOG_WARNING, _("path too long: %s%s\n"), root, path);
continue;
}
strcpy(filepath + rootlen, path);
if(check_file_exists(pkgname, filepath, &st) == 1) {
errors++;
continue;
}
type = archive_entry_filetype(entry);
if(type != AE_IFDIR && type != AE_IFREG && type != AE_IFLNK) {
pm_printf(ALPM_LOG_WARNING, _("file type not recognized: %s%s\n"), root, path);
continue;
}
if(check_file_type(pkgname, filepath, &st, entry) == 1) {
errors++;
continue;
}
file_errors += check_file_permissions(pkgname, filepath, &st, entry);
if(type == AE_IFLNK) {
file_errors += check_file_link(pkgname, filepath, &st, entry);
}
/* the following checks are expected to fail if a backup file has been
modified */
for(lp = alpm_pkg_get_backup(pkg); lp; lp = lp->next) {
alpm_backup_t *bl = lp->data;
if(strcmp(path, bl->name) == 0) {
backup = 1;
break;
}
}
if(type != AE_IFDIR) {
/* file or symbolic link */
file_errors += check_file_time(pkgname, filepath, &st, entry, backup);
}
if(type == AE_IFREG) {
/* TODO: these are expected to be changed with backup files */
file_errors += check_file_size(pkgname, filepath, &st, entry, backup);
/* file_errors += check_file_md5sum(pkgname, filepath, &st, entry, backup); */
}
if(config->quiet && file_errors) {
printf("%s %s\n", pkgname, filepath);
}
errors += (file_errors != 0 ? 1 : 0);
}
alpm_pkg_mtree_close(pkg, mtree);
if(!config->quiet) {
printf(_n("%s: %jd total file, ", "%s: %jd total files, ",
(unsigned long)file_count), pkgname, (intmax_t)file_count);
printf(_n("%jd altered file\n", "%jd altered files\n",
(unsigned long)errors), (intmax_t)errors);
}
return (errors != 0 ? 1 : 0);
}
/**
* pacman_manager_get_database_path:
* @manager: A #PacmanManager.
*
* Gets the directory where package databases are stored.
*
* Returns: A directory name. Do not free.
*/
const gchar *pacman_manager_get_database_path (PacmanManager *manager) {
g_return_val_if_fail (manager != NULL, NULL);
return alpm_option_get_dbpath ();
}
