marko10_000
/
flatpak-builder
forked from Mirrors/flatpak-builder
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
flatpak-builder/document-portal/xdp-fuse.c

2235 lines
53 KiB
C
Raw Blame History

#include "config.h"
#define FUSE_USE_VERSION 26
#include <glib-unix.h>
#include <fuse_lowlevel.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <assert.h>
#include <glib/gprintf.h>
#include <gio/gio.h>
#include <pthread.h>
#include "xdg-app-portal-error.h"
#include "xdp-fuse.h"
#include "xdp-util.h"
#include "xdg-app-utils.h"
/* Layout:
"/ (STD_DIRS:1)
"by-app/" (STD_DIRS:2)
"org.gnome.gedit/" (APP_DIR:app id)
"$id/" (APP_DOC_DIR:app_id<<32|doc_id)
<same as DOC_DIR>
"$id" (APP_DOC_DIR:(app_id==0)<<32|doc_idid)
$basename (APP_DOC_FILE:app_id<<32|doc_id) (app id == 0 if not in app dir)
$tmpfile (TMPFILE:tmp_id)
*/
#define BY_APP_INO 2
#define NON_DOC_DIR_PERMS 0500
#define DOC_DIR_PERMS 0700
/* The (fake) directories don't really change */
#define DIRS_ATTR_CACHE_TIME 60.0
/* We pretend that the file is hardlinked. This causes most apps to do
a truncating overwrite, which suits us better, as we do the atomic
rename ourselves anyway. This way we don't weirdly change the inode
after the rename. */
#define DOC_FILE_NLINK 2
typedef enum {
STD_DIRS_INO_CLASS,
TMPFILE_INO_CLASS,
APP_DIR_INO_CLASS,
APP_DOC_DIR_INO_CLASS,
APP_DOC_FILE_INO_CLASS,
} XdpInodeClass;
#define BY_APP_NAME "by-app"
static GHashTable *app_name_to_id;
static GHashTable *app_id_to_name;
static guint32 next_app_id = 1;
G_LOCK_DEFINE(app_id);
static GThread *fuse_thread = NULL;
static struct fuse_session *session = NULL;
static struct fuse_chan *main_ch = NULL;
static char *mount_path = NULL;
static pthread_t fuse_pthread = 0;
static int
steal_fd (int *fdp)
{
int fd = *fdp;
*fdp = -1;
return fd;
}
static int
get_user_perms (const struct stat *stbuf)
{
/* Strip out exec and setuid bits */
return stbuf->st_mode & 0666;
}
static double
get_attr_cache_time (int st_mode)
{
if (S_ISDIR (st_mode))
return DIRS_ATTR_CACHE_TIME;
return 0.0;
}
static double
get_entry_cache_time (fuse_ino_t inode)
{
/* We have to disable entry caches because otherwise we have a race
on rename. The kernel set the target inode as NOEXIST after a
rename, which breaks in the tmp over real case due to us reusing
the old non-temp inode. */
return 0.0;
}
/******************************* XdpTmp *******************************
*
* XdpTmp is a ref-counted object representing a temporary file created
* on the outer filesystem which is stored next to a real file in the fuse
* filesystem. Its useful to support write-to-tmp-then-rename-over-target
* operations.
*
* locking:
*
* The global list of outstanding Tmp are protected by the tmp_files
* lock. Use it when doing lookups by name or id, or when changing
* the list (add/remove) or name of a tmpfile.
*
* Each instance has a mutex that locks access to the backing path,
* as it can be removed at runtime. Use get/steal_backing_basename() to
* safely access it.
*
******************************* XdpTmp *******************************/
static volatile gint next_tmp_id = 1;
typedef struct
{
volatile gint ref_count;
/* These are immutable, no lock needed */
guint64 parent_inode;
guint32 tmp_id;
XdgAppDbEntry *entry;
/* Changes always done under tmp_files lock */
char *name;
GMutex mutex;
/* protected by mutex */
char *backing_basename;
} XdpTmp;
/* Owns a ref to the files */
static GList *tmp_files = NULL;
G_LOCK_DEFINE(tmp_files);
static XdpTmp *
xdp_tmp_ref (XdpTmp *tmp)
{
g_atomic_int_inc (&tmp->ref_count);
return tmp;
}
static void
xdp_tmp_unref (XdpTmp *tmp)
{
if (g_atomic_int_dec_and_test (&tmp->ref_count))
{
xdg_app_db_entry_unref (tmp->entry);
g_free (tmp->name);
g_free (tmp->backing_basename);
g_free (tmp);
}
}
char *
xdp_tmp_get_backing_basename (XdpTmp *tmp)
{
char *res;
g_mutex_lock (&tmp->mutex);
res = g_strdup (tmp->backing_basename);
g_mutex_unlock (&tmp->mutex);
return res;
}
char *
xdp_tmp_steal_backing_basename (XdpTmp *tmp)
{
char *res;
g_mutex_lock (&tmp->mutex);
res = tmp->backing_basename;
tmp->backing_basename = NULL;
g_mutex_unlock (&tmp->mutex);
return res;
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC(XdpTmp, xdp_tmp_unref)
/* Must first take tmp_files lock */
static XdpTmp *
find_tmp_by_name_nolock (guint64 parent_inode,
const char *name)
{
GList *l;
for (l = tmp_files; l != NULL; l = l->next)
{
XdpTmp *tmp = l->data;
if (tmp->parent_inode == parent_inode &&
strcmp (tmp->name, name) == 0)
return xdp_tmp_ref (tmp);
}
return NULL;
}
/* Takes tmp_files lock */
static XdpTmp *
find_tmp_by_name (guint64 parent_inode,
const char *name)
{
AUTOLOCK(tmp_files);
return find_tmp_by_name_nolock (parent_inode, name);
}
/* Takes tmp_files lock */
static XdpTmp *
find_tmp_by_id (guint32 tmp_id)
{
GList *l;
AUTOLOCK(tmp_files);
for (l = tmp_files; l != NULL; l = l->next)
{
XdpTmp *tmp = l->data;
if (tmp->tmp_id == tmp_id)
return xdp_tmp_ref (tmp);
}
return NULL;
}
/* Caller must hold tmp_files lock */
static XdpTmp *
xdp_tmp_new_nolock (fuse_ino_t parent,
XdgAppDbEntry *entry,
const char *name,
const char *tmp_basename)
{
XdpTmp *tmp;
g_autofree char *tmp_dirname = NULL;
/* We store the pathname instead of dir_fd + basename, because
its very easy to get a lot of tempfiles leaking and that would
mean quite a lot of open fds */
tmp_dirname = xdp_entry_dup_dirname (entry);
tmp = g_new0 (XdpTmp, 1);
tmp->ref_count = 2; /* One owned by tmp_files */
tmp->tmp_id = g_atomic_int_add (&next_tmp_id, 1);
tmp->parent_inode = parent;
tmp->name = g_strdup (name);
tmp->entry = xdg_app_db_entry_ref (entry);
tmp->backing_basename = g_strdup (tmp_basename);
tmp_files = g_list_prepend (tmp_files, tmp);
return tmp;
}
/* Caller must own tmp_files lock */
static void
xdp_tmp_unlink_nolock (XdpTmp *tmp)
{
g_autofree char *backing_basename = NULL;
backing_basename = xdp_tmp_steal_backing_basename (tmp);
if (backing_basename)
{
glnx_fd_close int dir_fd = xdp_entry_open_dir (tmp->entry);
if (dir_fd)
unlinkat (dir_fd, backing_basename, 0);
}
tmp_files = g_list_remove (tmp_files, tmp);
xdp_tmp_unref (tmp);
}
/******************************* XdpFh *******************************
*
* XdpFh is a ref-counted object representing an open file on the
* filesystem. Normally it has a regular fd you can do only the allowed
* i/o on, although in the case of a direct write to a document file
* it has two fds, one is the read-only fd to the file, and the other
* is a read-write to a temporary file which is only used once the
* file is truncated (and is renamed over the real file on close).
*
* locking:
*
* The global list of outstanding Fh is protected by the open_files
* lock. Use it when doing lookups by inode, or when changing
* the list (add/remove), or when otherwise traversing the list.
*
* Each instance has a mutex that must be locked when doing some
* kind of operation on the file handle, to serialize both lower
* layer i/o as well as access to the members.
*
* To avoid deadlocks or just slow locking, never aquire the
* open_files lock and a lock on a Fh at the same time.
*
******************************* XdpFh *******************************/
typedef struct
{
volatile gint ref_count;
/* These are immutable, no lock needed */
guint32 tmp_id;
fuse_ino_t inode;
int dir_fd;
char *trunc_basename;
char *real_basename;
gboolean can_write;
/* These need a lock whenever they are used */
int fd;
int trunc_fd;
gboolean truncated;
gboolean readonly;
GMutex mutex;
} XdpFh;
static GList *open_files = NULL;
G_LOCK_DEFINE(open_files);
static XdpFh *
xdp_fh_ref (XdpFh *fh)
{
g_atomic_int_inc (&fh->ref_count);
return fh;
}
static void
xdp_fh_finalize (XdpFh *fh)
{
if (fh->truncated)
{
fsync (fh->trunc_fd);
if (renameat (fh->dir_fd, fh->trunc_basename,
fh->dir_fd, fh->real_basename) != 0)
g_warning ("Unable to replace truncated document");
}
else if (fh->trunc_basename)
unlinkat (fh->dir_fd, fh->trunc_basename, 0);
if (fh->fd >= 0)
close (fh->fd);
if (fh->trunc_fd >= 0)
close (fh->trunc_fd);
if (fh->dir_fd >= 0)
close (fh->dir_fd);
g_clear_pointer (&fh->trunc_basename, g_free);
g_clear_pointer (&fh->real_basename, g_free);
g_free (fh);
}
static void
xdp_fh_unref (XdpFh *fh)
{
if (g_atomic_int_dec_and_test (&fh->ref_count))
{
/* There is a tiny race here where fhs can be on the open_files list
with refcount 0, so make sure to skip such while under the open_files
lock */
{
AUTOLOCK (open_files);
open_files = g_list_remove (open_files, fh);
}
xdp_fh_finalize (fh);
}
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC(XdpFh, xdp_fh_unref)
static void
xdp_fh_lock (XdpFh *fh)
{
g_mutex_lock (&fh->mutex);
}
static void
xdp_fh_unlock (XdpFh *fh)
{
g_mutex_unlock (&fh->mutex);
}
static inline void xdp_fh_auto_unlock_helper (XdpFh **fhp)
{
if (*fhp)
xdp_fh_unlock (*fhp);
}
static inline XdpFh *xdp_fh_auto_lock_helper (XdpFh *fh)
{
if (fh)
xdp_fh_lock (fh);
return fh;
}
#define XDP_FH_AUTOLOCK(_fh) G_GNUC_UNUSED __attribute__((cleanup(xdp_fh_auto_unlock_helper))) XdpFh * G_PASTE(xdp_fh_auto_unlock, __LINE__) = xdp_fh_auto_lock_helper (fh)
static XdpFh *
xdp_fh_new (fuse_ino_t inode,
struct fuse_file_info *fi,
int fd,
XdpTmp *tmp)
{
XdpFh *fh = g_new0 (XdpFh, 1);
fh->inode = inode;
fh->fd = fd;
if (tmp)
fh->tmp_id = tmp->tmp_id;
fh->dir_fd = -1;
fh->trunc_fd = -1;
fh->ref_count = 1; /* Owned by fuse_file_info fi */
fi->fh = (gsize)fh;
AUTOLOCK (open_files);
open_files = g_list_prepend (open_files, fh);
return fh;
}
static int
xdp_fh_get_fd_nolock (XdpFh *fh)
{
if (fh->truncated)
return fh->trunc_fd;
else
return fh->fd;
}
static int
xdp_fh_fstat (XdpFh *fh,
struct stat *stbuf)
{
struct stat tmp_stbuf;
int fd;
fd = xdp_fh_get_fd_nolock (fh);
if (fd < 0)
return -ENOSYS;
if (fstat (fd, &tmp_stbuf) != 0)
return -errno;
stbuf->st_nlink = DOC_FILE_NLINK;
stbuf->st_mode = S_IFREG | get_user_perms (&tmp_stbuf);
if (!fh->can_write)
stbuf->st_mode &= ~(0222);
stbuf->st_size = tmp_stbuf.st_size;
stbuf->st_uid = tmp_stbuf.st_uid;
stbuf->st_gid = tmp_stbuf.st_gid;
stbuf->st_blksize = tmp_stbuf.st_blksize;
stbuf->st_blocks = tmp_stbuf.st_blocks;
stbuf->st_atim = tmp_stbuf.st_atim;
stbuf->st_mtim = tmp_stbuf.st_mtim;
stbuf->st_ctim = tmp_stbuf.st_ctim;
return 0;
}
static int
xdp_fh_fstat_locked (XdpFh *fh,
struct stat *stbuf)
{
XDP_FH_AUTOLOCK (fh);
return xdp_fh_fstat (fh, stbuf);
}
static int
xdp_fh_truncate_locked (XdpFh *fh, off_t size, struct stat *newattr)
{
int fd;
XDP_FH_AUTOLOCK (fh);
if (fh->trunc_fd >= 0 && !fh->truncated)
{
if (size != 0)
return -EACCES;
fh->truncated = TRUE;
fd = fh->trunc_fd;
}
else
{
fd = xdp_fh_get_fd_nolock (fh);
if (fd == -1)
return -EIO;
if (ftruncate (fd, size) != 0)
return - errno;
}
if (newattr)
{
int res = xdp_fh_fstat (fh, newattr);
if (res < 0)
return res;
}
return 0;
}
static void
mark_open_tmp_file_readonly (guint32 tmp_id)
{
GList *found = NULL;
GList *l;
{
AUTOLOCK (open_files);
for (l = open_files; l != NULL; l = l->next)
{
XdpFh *fh = l->data;
/* See xdp_fh_unref for details of this ref_count check */
if (g_atomic_int_get (&fh->ref_count) > 0 &&
fh->tmp_id == tmp_id && fh->fd >= 0)
found = g_list_prepend (found, xdp_fh_ref (fh));
}
}
/* We do the actual updates outside of the open_files lock to avoid
potentially blocking for a long time with it held */
for (l = found; l != NULL; l = l->next)
{
XdpFh *fh = l->data;
XDP_FH_AUTOLOCK (fh);
fh->readonly = TRUE;
xdp_fh_unref (fh);
}
g_list_free (found);
}
static XdpFh *
find_open_fh (fuse_ino_t ino)
{
GList *l;
AUTOLOCK (open_files);
for (l = open_files; l != NULL; l = l->next)
{
XdpFh *fh = l->data;
/* See xdp_fh_unref for details of this ref_count check */
if (fh->inode == ino &&
g_atomic_int_get (&fh->ref_count) > 0)
return xdp_fh_ref (fh);
}
return NULL;
}
/******************************* Main *******************************/
static XdpInodeClass
get_class (guint64 inode)
{
return (inode >> (64-8)) & 0xff;
}
static guint64
get_class_ino (guint64 inode)
{
return inode & ((1L << (64-8)) - 1);
}
static guint32
get_app_id_from_app_doc_ino (guint64 inode)
{
return inode >> 32;
}
static guint32
get_doc_id_from_app_doc_ino (guint64 inode)
{
return inode & 0xffffffff;
}
static guint64
make_inode (XdpInodeClass class, guint64 inode)
{
return ((guint64)class) << (64-8) | (inode & 0xffffffffffffff);
}
static guint64
make_app_doc_dir_inode (guint32 app_id, guint32 doc_id)
{
return make_inode (APP_DOC_DIR_INO_CLASS,
((guint64)app_id << 32) | (guint64)doc_id);
}
static guint64
make_app_doc_file_inode (guint32 app_id, guint32 doc_id)
{
return make_inode (APP_DOC_FILE_INO_CLASS,
((guint64)app_id << 32) | (guint64)doc_id);
}
static gboolean
name_looks_like_id (const char *name)
{
int i;
/* No zeros in front, we need canonical form */
if (name[0] == '0')
return FALSE;
for (i = 0; i < 8; i++)
{
char c = name[i];
if (c == 0)
break;
if (!g_ascii_isdigit(c) &&
!(c >= 'a' && c <= 'f'))
return FALSE;
}
if (name[i] != 0)
return FALSE;
return TRUE;
}
static guint32
get_app_id_from_name (const char *name)
{
guint32 id;
char *myname;
AUTOLOCK(app_id);
id = GPOINTER_TO_UINT (g_hash_table_lookup (app_name_to_id, name));
if (id != 0)
return id;
id = next_app_id++;
/* We rely this to not overwrap into the high byte in the inode */
g_assert (id < 0x00ffffff);
myname = g_strdup (name);
g_hash_table_insert (app_name_to_id, myname, GUINT_TO_POINTER (id));
g_hash_table_insert (app_id_to_name, GUINT_TO_POINTER (id), myname);
return id;
}
static const char *
get_app_name_from_id (guint32 id)
{
AUTOLOCK(app_id);
return g_hash_table_lookup (app_id_to_name, GUINT_TO_POINTER (id));
}
static void
fill_app_name_hash (void)
{
g_auto(GStrv) keys = NULL;
int i;
keys = xdp_list_apps ();
for (i = 0; keys[i] != NULL; i++)
get_app_id_from_name (keys[i]);
}
static gboolean
app_can_see_doc (XdgAppDbEntry *entry, guint32 app_id)
{
const char *app_name = get_app_name_from_id (app_id);
if (app_id == 0)
return TRUE;
if (app_name != NULL &&
xdp_entry_has_permissions (entry, app_name, XDP_PERMISSION_FLAGS_READ))
return TRUE;
return FALSE;
}
static gboolean
app_can_write_doc (XdgAppDbEntry *entry, guint32 app_id)
{
const char *app_name = get_app_name_from_id (app_id);
if (app_id == 0)
return TRUE;
if (app_name != NULL &&
xdp_entry_has_permissions (entry, app_name, XDP_PERMISSION_FLAGS_WRITE))
return TRUE;
return FALSE;
}
static int
xdp_stat (fuse_ino_t ino,
struct stat *stbuf,
XdgAppDbEntry **entry_out)
{
XdpInodeClass class = get_class (ino);
guint64 class_ino = get_class_ino (ino);
g_autoptr (XdgAppDbEntry) entry = NULL;
struct stat tmp_stbuf;
g_autoptr(XdpTmp) tmp = NULL;
g_autofree char *backing_basename = NULL;
stbuf->st_ino = ino;
switch (class)
{
case STD_DIRS_INO_CLASS:
switch (class_ino)
{
case FUSE_ROOT_ID:
stbuf->st_mode = S_IFDIR | NON_DOC_DIR_PERMS;
stbuf->st_nlink = 2;
break;
case BY_APP_INO:
stbuf->st_mode = S_IFDIR | NON_DOC_DIR_PERMS;
stbuf->st_nlink = 2;
break;
default:
return ENOENT;
}
break;
case APP_DIR_INO_CLASS:
if (get_app_name_from_id (class_ino) == 0)
return ENOENT;
stbuf->st_mode = S_IFDIR | NON_DOC_DIR_PERMS;
stbuf->st_nlink = 2;
break;
case APP_DOC_DIR_INO_CLASS:
{
guint32 app_id = get_app_id_from_app_doc_ino (class_ino);
guint32 doc_id = get_doc_id_from_app_doc_ino (class_ino);
entry = xdp_lookup_doc (doc_id);
if (entry == NULL || !app_can_see_doc (entry, app_id))
return ENOENT;
stbuf->st_mode = S_IFDIR | DOC_DIR_PERMS;
stbuf->st_nlink = 2;
break;
}
case APP_DOC_FILE_INO_CLASS:
{
guint32 app_id = get_app_id_from_app_doc_ino (class_ino);
guint32 doc_id = get_doc_id_from_app_doc_ino (class_ino);
gboolean can_write;
entry = xdp_lookup_doc (doc_id);
if (entry == NULL)
return ENOENT;
can_write = app_can_write_doc (entry, app_id);
stbuf->st_nlink = DOC_FILE_NLINK;
if (xdp_entry_stat (entry, &tmp_stbuf, AT_SYMLINK_NOFOLLOW) != 0)
return ENOENT;
stbuf->st_mode = S_IFREG | get_user_perms (&tmp_stbuf);
if (!can_write)
stbuf->st_mode &= ~(0222);
stbuf->st_size = tmp_stbuf.st_size;
stbuf->st_uid = tmp_stbuf.st_uid;
stbuf->st_gid = tmp_stbuf.st_gid;
stbuf->st_blksize = tmp_stbuf.st_blksize;
stbuf->st_blocks = tmp_stbuf.st_blocks;
stbuf->st_atim = tmp_stbuf.st_atim;
stbuf->st_mtim = tmp_stbuf.st_mtim;
stbuf->st_ctim = tmp_stbuf.st_ctim;
break;
}
case TMPFILE_INO_CLASS:
tmp = find_tmp_by_id (class_ino);
if (tmp == NULL)
return ENOENT;
stbuf->st_mode = S_IFREG;
stbuf->st_nlink = DOC_FILE_NLINK;
backing_basename = xdp_tmp_get_backing_basename (tmp);
{
glnx_fd_close int dir_fd = xdp_entry_open_dir (tmp->entry);
if (backing_basename == NULL ||
dir_fd == -1 ||
fstatat (dir_fd, backing_basename, &tmp_stbuf, 0) != 0)
return ENOENT;
}
stbuf->st_mode = S_IFREG | get_user_perms (&tmp_stbuf);
stbuf->st_size = tmp_stbuf.st_size;
stbuf->st_uid = tmp_stbuf.st_uid;
stbuf->st_gid = tmp_stbuf.st_gid;
stbuf->st_blksize = tmp_stbuf.st_blksize;
stbuf->st_blocks = tmp_stbuf.st_blocks;
stbuf->st_atim = tmp_stbuf.st_atim;
stbuf->st_mtim = tmp_stbuf.st_mtim;
stbuf->st_ctim = tmp_stbuf.st_ctim;
break;
default:
return ENOENT;
}
if (entry && entry_out)
*entry_out = g_steal_pointer (&entry);
return 0;
}
static void
xdp_fuse_getattr (fuse_req_t req,
fuse_ino_t ino,
struct fuse_file_info *fi)
{
struct stat stbuf = { 0 };
g_autoptr(XdpFh) fh = NULL;
int res;
g_debug ("xdp_fuse_getattr %lx (fi=%p)", ino, fi);
/* Fuse passes fi in to verify EOF during read/write/seek, but not during fstat */
if (fi != NULL)
{
XdpFh *fh = (gpointer)fi->fh;
res = xdp_fh_fstat_locked (fh, &stbuf);
if (res == 0)
{
fuse_reply_attr (req, &stbuf, get_attr_cache_time (stbuf.st_mode));
return;
}
}
fh = find_open_fh (ino);
if (fh)
{
res = xdp_fh_fstat_locked (fh, &stbuf);
if (res == 0)
{
fuse_reply_attr (req, &stbuf, get_attr_cache_time (stbuf.st_mode));
return;
}
}
if ((res = xdp_stat (ino, &stbuf, NULL)) != 0)
fuse_reply_err (req, res);
else
fuse_reply_attr (req, &stbuf, get_attr_cache_time (stbuf.st_mode));
}
static int
xdp_lookup (fuse_ino_t parent,
const char *name,
fuse_ino_t *inode,
struct stat *stbuf,
XdgAppDbEntry **entry_out,
XdpTmp **tmp_out)
{
XdpInodeClass parent_class = get_class (parent);
guint64 parent_class_ino = get_class_ino (parent);
g_autoptr (XdgAppDbEntry) entry = NULL;
g_autoptr (XdpTmp) tmp = NULL;
if (entry_out)
*entry_out = NULL;
if (tmp_out)
*tmp_out = NULL;
switch (parent_class)
{
case STD_DIRS_INO_CLASS:
switch (parent_class_ino)
{
case FUSE_ROOT_ID:
if (strcmp (name, BY_APP_NAME) == 0)
{
*inode = make_inode (STD_DIRS_INO_CLASS, BY_APP_INO);
if (xdp_stat (*inode, stbuf, NULL) == 0)
return 0;
}
else if (name_looks_like_id (name))
{
*inode = make_app_doc_dir_inode (0, xdp_id_from_name (name));
if (xdp_stat (*inode, stbuf, NULL) == 0)
return 0;
}
break;
case BY_APP_INO:
if (xdg_app_is_valid_name (name))
{
guint32 app_id = get_app_id_from_name (name);
*inode = make_inode (APP_DIR_INO_CLASS, app_id);
if (xdp_stat (*inode, stbuf, NULL) == 0)
return 0;
}
break;
default:
break;
}
break;
case APP_DIR_INO_CLASS:
{
if (name_looks_like_id (name))
{
*inode = make_app_doc_dir_inode (parent_class_ino,
xdp_id_from_name (name));
if (xdp_stat (*inode, stbuf, NULL) == 0)
return 0;
}
}
break;
case APP_DOC_DIR_INO_CLASS:
{
guint32 app_id = get_app_id_from_app_doc_ino (parent_class_ino);
guint32 doc_id = get_doc_id_from_app_doc_ino (parent_class_ino);
entry = xdp_lookup_doc (doc_id);
if (entry != NULL)
{
g_autofree char *basename = xdp_entry_dup_basename (entry);
if (strcmp (name, basename) == 0)
{
*inode = make_app_doc_file_inode (app_id, doc_id);
if (xdp_stat (*inode, stbuf, NULL) == 0)
{
if (entry_out)
*entry_out = g_steal_pointer (&entry);
return 0;
}
break;
}
}
tmp = find_tmp_by_name (parent, name);
if (tmp != NULL)
{
*inode = make_inode (TMPFILE_INO_CLASS, tmp->tmp_id);
if (xdp_stat (*inode, stbuf, NULL) == 0)
{
if (entry_out)
*entry_out = g_steal_pointer (&entry);
if (tmp_out)
*tmp_out = g_steal_pointer (&tmp);
return 0;
}
break;
}
break;
}
case TMPFILE_INO_CLASS:
case APP_DOC_FILE_INO_CLASS:
return ENOTDIR;
default:
break;
}
return ENOENT;
}
static void
xdp_fuse_lookup (fuse_req_t req,
fuse_ino_t parent,
const char *name)
{
struct fuse_entry_param e = {0};
int res;
g_debug ("xdp_fuse_lookup %lx/%s -> ", parent, name);
memset (&e, 0, sizeof(e));
res = xdp_lookup (parent, name, &e.ino, &e.attr, NULL, NULL);
if (res == 0)
{
g_debug ("xdp_fuse_lookup <- inode %lx", (long)e.ino);
e.attr_timeout = get_attr_cache_time (e.attr.st_mode);
e.entry_timeout = get_entry_cache_time (e.ino);
fuse_reply_entry (req, &e);
}
else
{
g_debug ("xdp_fuse_lookup <- error %s", strerror (res));
fuse_reply_err (req, res);
}
}
struct dirbuf {
char *p;
size_t size;
};
static void
dirbuf_add (fuse_req_t req,
struct dirbuf *b,
const char *name,
fuse_ino_t ino)
{
struct stat stbuf;
size_t oldsize = b->size;
b->size += fuse_add_direntry (req, NULL, 0, name, NULL, 0);
b->p = (char *) g_realloc (b->p, b->size);
memset (&stbuf, 0, sizeof (stbuf));
stbuf.st_ino = ino;
fuse_add_direntry (req, b->p + oldsize,
b->size - oldsize,
name, &stbuf,
b->size);
}
static void
dirbuf_add_docs (fuse_req_t req,
struct dirbuf *b,
guint32 app_id)
{
g_autofree guint32 *docs = NULL;
guint64 inode;
int i;
g_autofree char *doc_name = NULL;
docs = xdp_list_docs ();
for (i = 0; docs[i] != 0; i++)
{
if (app_id)
{
g_autoptr(XdgAppDbEntry) entry = xdp_lookup_doc (docs[i]);
if (entry == NULL ||
!app_can_see_doc (entry, app_id))
continue;
}
inode = make_app_doc_dir_inode (app_id, docs[i]);
doc_name = xdp_name_from_id (docs[i]);
dirbuf_add (req, b, doc_name, inode);
}
}
static void
dirbuf_add_doc_file (fuse_req_t req,
struct dirbuf *b,
XdgAppDbEntry *entry,
guint32 doc_id,
guint32 app_id)
{
struct stat tmp_stbuf;
guint64 inode;
g_autofree char *basename = xdp_entry_dup_basename (entry);
inode = make_app_doc_file_inode (app_id, doc_id);
if (xdp_entry_stat (entry, &tmp_stbuf, AT_SYMLINK_NOFOLLOW) == 0)
dirbuf_add (req, b, basename, inode);
}
static void
dirbuf_add_tmp_files (fuse_req_t req,
struct dirbuf *b,
guint64 dir_inode)
{
GList *l;
AUTOLOCK(tmp_files);
for (l = tmp_files; l != NULL; l = l->next)
{
XdpTmp *tmp = l->data;
if (tmp->parent_inode == dir_inode)
dirbuf_add (req, b, tmp->name,
make_inode (TMPFILE_INO_CLASS, tmp->tmp_id));
}
}
static int
reply_buf_limited (fuse_req_t req,
const char *buf,
size_t bufsize,
off_t off,
size_t maxsize)
{
if (off < bufsize)
return fuse_reply_buf (req, buf + off,
MIN (bufsize - off, maxsize));
else
return fuse_reply_buf (req, NULL, 0);
}
static void
xdp_fuse_readdir (fuse_req_t req, fuse_ino_t ino, size_t size,
off_t off, struct fuse_file_info *fi)
{
struct dirbuf *b = (struct dirbuf *)(fi->fh);
reply_buf_limited (req, b->p, b->size, off, size);
}
static void
xdp_fuse_opendir (fuse_req_t req,
fuse_ino_t ino,
struct fuse_file_info *fi)
{
struct stat stbuf = {0};
struct dirbuf b = {0};
XdpInodeClass class;
guint64 class_ino;
g_autoptr (XdgAppDbEntry) entry = NULL;
int res;
g_debug ("xdp_fuse_opendir %lx", ino);
if ((res = xdp_stat (ino, &stbuf, &entry)) != 0)
{
fuse_reply_err (req, res);
return;
}
if ((stbuf.st_mode & S_IFMT) != S_IFDIR)
{
fuse_reply_err (req, ENOTDIR);
return;
}
class = get_class (ino);
class_ino = get_class_ino (ino);
switch (class)
{
case STD_DIRS_INO_CLASS:
switch (class_ino)
{
case FUSE_ROOT_ID:
dirbuf_add (req, &b, ".", FUSE_ROOT_ID);
dirbuf_add (req, &b, "..", FUSE_ROOT_ID);
dirbuf_add (req, &b, BY_APP_NAME,
make_inode (STD_DIRS_INO_CLASS, BY_APP_INO));
dirbuf_add_docs (req, &b, 0);
break;
case BY_APP_INO:
dirbuf_add (req, &b, ".", ino);
dirbuf_add (req, &b, "..", FUSE_ROOT_ID);
/* Update for any possible new app */
fill_app_name_hash ();
{
GHashTableIter iter;
gpointer key, value;
AUTOLOCK(app_id);
g_hash_table_iter_init (&iter, app_name_to_id);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *name = key;
guint32 id = GPOINTER_TO_UINT(value);
if (strlen (name) > 0)
dirbuf_add (req, &b, name,
make_inode (APP_DIR_INO_CLASS, id));
}
}
break;
default:
break;
}
break;
case APP_DIR_INO_CLASS:
{
dirbuf_add (req, &b, ".", ino);
dirbuf_add (req, &b, "..", make_inode (STD_DIRS_INO_CLASS, BY_APP_INO));
dirbuf_add_docs (req, &b, class_ino);
break;
}
break;
case APP_DOC_DIR_INO_CLASS:
dirbuf_add (req, &b, ".", ino);
if (get_app_id_from_app_doc_ino (class_ino) == 0)
dirbuf_add (req, &b, "..", FUSE_ROOT_ID);
else
dirbuf_add (req, &b, "..", make_inode (APP_DIR_INO_CLASS,
get_app_id_from_app_doc_ino (class_ino)));
dirbuf_add_doc_file (req, &b, entry,
get_doc_id_from_app_doc_ino (class_ino),
get_app_id_from_app_doc_ino (class_ino));
dirbuf_add_tmp_files (req, &b, ino);
break;
case APP_DOC_FILE_INO_CLASS:
case TMPFILE_INO_CLASS:
/* These should have returned ENOTDIR above */
default:
break;
}
if (b.p == NULL)
fuse_reply_err (req, EIO);
else
{
fi->fh = (gsize)g_memdup (&b, sizeof (b));
if (fuse_reply_open (req, fi) == -ENOENT)
{
g_free (b.p);
g_free ((gpointer)(fi->fh));
}
}
}
static void
xdp_fuse_releasedir (fuse_req_t req,
fuse_ino_t ino,
struct fuse_file_info *fi)
{
struct dirbuf *b = (struct dirbuf *)(fi->fh);
g_free (b->p);
g_free (b);
fuse_reply_err (req, 0);
}
static int
get_open_flags (struct fuse_file_info *fi)
{
/* TODO: Maybe limit the flags set more */
return fi->flags & ~(O_EXCL|O_CREAT);
}
static char *
create_tmp_for_doc (XdgAppDbEntry *entry, int dir_fd, int flags, int *fd_out)
{
g_autofree char *basename = xdp_entry_dup_basename (entry);
g_autofree char *template = g_strconcat (".xdp_", basename, ".XXXXXX", NULL);
int fd;
fd = xdg_app_mkstempat (dir_fd, template, flags|O_CLOEXEC, 0600);
if (fd == -1)
return NULL;
*fd_out = fd;
return g_steal_pointer (&template);
}
static void
xdp_fuse_open (fuse_req_t req,
fuse_ino_t ino,
struct fuse_file_info *fi)
{
XdpInodeClass class = get_class (ino);
guint64 class_ino = get_class_ino (ino);
struct stat stbuf = {0};
g_autoptr (XdgAppDbEntry) entry = NULL;
g_autoptr(XdpTmp) tmp = NULL;
glnx_fd_close int fd = -1;
int res;
XdpFh *fh = NULL;
g_debug ("xdp_fuse_open %lx", ino);
if ((res = xdp_stat (ino, &stbuf, &entry)) != 0)
{
fuse_reply_err (req, res);
return;
}
if ((stbuf.st_mode & S_IFMT) != S_IFREG)
{
fuse_reply_err (req, EISDIR);
return;
}
if (entry && class == APP_DOC_FILE_INO_CLASS)
{
g_autofree char *tmp_basename = NULL;
glnx_fd_close int write_fd = -1;
glnx_fd_close int dir_fd = -1;
g_autofree char *basename = xdp_entry_dup_basename (entry);
guint32 app_id = get_app_id_from_app_doc_ino (class_ino);
gboolean can_write;
dir_fd = xdp_entry_open_dir (entry);
if (dir_fd == -1)
{
fuse_reply_err (req, errno);
return;
}
can_write = app_can_write_doc (entry, app_id);
if ((fi->flags & 3) != O_RDONLY)
{
if (!can_write)
{
fuse_reply_err (req, EACCES);
return;
}
if (faccessat (dir_fd, basename, W_OK, 0) != 0)
{
fuse_reply_err (req, errno);
return;
}
tmp_basename = create_tmp_for_doc (entry, dir_fd, O_RDWR, &write_fd);
if (tmp_basename == NULL)
{
fuse_reply_err (req, errno);
return;
}
}
fd = openat (dir_fd, basename, O_RDONLY|O_NOFOLLOW|O_CLOEXEC);
if (fd < 0)
{
fuse_reply_err (req, errno);
return;
}
fh = xdp_fh_new (ino, fi, steal_fd(&fd), NULL);
fh->can_write = can_write;
fh->dir_fd = steal_fd (&dir_fd);
fh->trunc_fd = steal_fd (&write_fd);
fh->trunc_basename = g_steal_pointer (&tmp_basename);
fh->real_basename = g_strdup (basename);
if (fuse_reply_open (req, fi))
xdp_fh_unref (fh);
}
else if (class == TMPFILE_INO_CLASS &&
(tmp = find_tmp_by_id (class_ino)))
{
glnx_fd_close int dir_fd = xdp_entry_open_dir (tmp->entry);
g_autofree char *backing_basename = xdp_tmp_get_backing_basename (tmp);
if (dir_fd == -1 || backing_basename == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
fd = openat (dir_fd, backing_basename, get_open_flags (fi)|O_NOFOLLOW|O_CLOEXEC);
if (fd < 0)
{
fuse_reply_err (req, errno);
return;
}
fh = xdp_fh_new (ino, fi, steal_fd (&fd), tmp);
fh->can_write = TRUE;
if (fuse_reply_open (req, fi))
xdp_fh_unref (fh);
}
else
fuse_reply_err (req, EIO);
}
static void
xdp_fuse_create (fuse_req_t req,
fuse_ino_t parent,
const char *name,
mode_t mode,
struct fuse_file_info *fi)
{
struct fuse_entry_param e = {0};
XdpInodeClass parent_class = get_class (parent);
guint64 parent_class_ino = get_class_ino (parent);
struct stat stbuf;
XdpFh *fh;
g_autoptr(XdgAppDbEntry) entry = NULL;
g_autofree char *basename = NULL;
glnx_fd_close int fd = -1;
gboolean can_write;
int res;
guint32 app_id = 0;
guint32 doc_id;
g_debug ("xdp_fuse_create %lx/%s, flags %o", parent, name, fi->flags);
if ((res = xdp_stat (parent, &stbuf, &entry)) != 0)
{
fuse_reply_err (req, res);
return;
}
if ((stbuf.st_mode & S_IFMT) != S_IFDIR)
{
fuse_reply_err (req, ENOTDIR);
return;
}
if (parent_class != APP_DOC_DIR_INO_CLASS)
{
fuse_reply_err (req, EACCES);
return;
}
app_id = get_app_id_from_app_doc_ino (parent_class_ino);
doc_id = get_doc_id_from_app_doc_ino (parent_class_ino);
can_write = app_can_write_doc (entry, app_id);
basename = xdp_entry_dup_basename (entry);
if (strcmp (name, basename) == 0)
{
g_autofree char *tmp_basename = NULL;
glnx_fd_close int write_fd = -1;
glnx_fd_close int dir_fd = -1;
dir_fd = xdp_entry_open_dir (entry);
if (dir_fd == -1)
{
fuse_reply_err (req, errno);
return;
}
if (!can_write)
{
fuse_reply_err (req, EACCES);
return;
}
tmp_basename = create_tmp_for_doc (entry, dir_fd, O_RDWR, &write_fd);
if (tmp_basename == NULL)
{
fuse_reply_err (req, errno);
return;
}
fd = openat (dir_fd, basename, O_CREAT|O_EXCL|O_RDONLY|O_NOFOLLOW|O_CLOEXEC, mode & 0777);
if (fd < 0)
{
fuse_reply_err (req, errno);
return;
}
e.ino = make_app_doc_file_inode (app_id, doc_id);
fh = xdp_fh_new (e.ino, fi, steal_fd (&fd), NULL);
fh->can_write = TRUE;
fh->dir_fd = steal_fd (&dir_fd);
fh->truncated = TRUE;
fh->trunc_fd = steal_fd (&write_fd);
fh->trunc_basename = g_steal_pointer (&tmp_basename);
fh->real_basename = g_strdup (basename);
if (xdp_fh_fstat_locked (fh, &e.attr) != 0)
{
xdp_fh_unref (fh);
fuse_reply_err (req, EIO);
return;
}
e.attr_timeout = get_attr_cache_time (e.attr.st_mode);
e.entry_timeout = get_entry_cache_time (e.ino);
if (fuse_reply_create (req, &e, fi))
xdp_fh_unref (fh);
}
else
{
g_autoptr(XdpTmp) tmpfile = NULL;
G_LOCK(tmp_files);
tmpfile = find_tmp_by_name_nolock (parent, name);
if (tmpfile != NULL && fi->flags & O_EXCL)
{
G_UNLOCK(tmp_files);
fuse_reply_err (req, EEXIST);
return;
}
if (!can_write)
{
fuse_reply_err (req, EACCES);
return;
}
if (tmpfile)
{
glnx_fd_close int dir_fd = xdp_entry_open_dir (tmpfile->entry);
g_autofree char *backing_basename = NULL;
G_UNLOCK(tmp_files);
backing_basename = xdp_tmp_get_backing_basename (tmpfile);
if (dir_fd == -1 || backing_basename == NULL)
{
fuse_reply_err (req, EINVAL);
return;
}
fd = openat (dir_fd, backing_basename, get_open_flags (fi)|O_NOFOLLOW|O_CLOEXEC);
if (fd == -1)
{
fuse_reply_err (req, errno);
return;
}
}
else
{
int errsv;
g_autofree char *tmp_basename = NULL;
glnx_fd_close int dir_fd = -1;
dir_fd = xdp_entry_open_dir (entry);
if (dir_fd == -1)
{
fuse_reply_err (req, errno);
return;
}
tmp_basename = create_tmp_for_doc (entry, dir_fd, get_open_flags (fi), &fd);
if (tmp_basename == NULL)
return;
tmpfile = xdp_tmp_new_nolock (parent, entry, name, tmp_basename);
errsv = errno;
G_UNLOCK(tmp_files);
if (tmpfile == NULL)
{
fuse_reply_err (req, errsv);
return;
}
}
e.ino = make_inode (TMPFILE_INO_CLASS, tmpfile->tmp_id);
if (xdp_stat (e.ino, &e.attr, NULL) != 0)
{
fuse_reply_err (req, EIO);
return;
}
e.attr_timeout = get_attr_cache_time (e.attr.st_mode);
e.entry_timeout = get_entry_cache_time (e.ino);
fh = xdp_fh_new (e.ino, fi, steal_fd (&fd), tmpfile);
fh->can_write = TRUE;
if (fuse_reply_create (req, &e, fi))
xdp_fh_unref (fh);
}
}
static void
xdp_fuse_read (fuse_req_t req,
fuse_ino_t ino,
size_t size,
off_t off,
struct fuse_file_info *fi)
{
XdpFh *fh = (gpointer)fi->fh;
struct fuse_bufvec bufv = FUSE_BUFVEC_INIT (size);
static char c = 'x';
int fd;
XDP_FH_AUTOLOCK (fh);
fd = xdp_fh_get_fd_nolock (fh);
if (fd == -1)
{
bufv.buf[0].flags = 0;
bufv.buf[0].mem = &c;
bufv.buf[0].size = 0;
fuse_reply_data (req, &bufv, FUSE_BUF_NO_SPLICE);
return;
}
bufv.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
bufv.buf[0].fd = fd;
bufv.buf[0].pos = off;
fuse_reply_data (req, &bufv, FUSE_BUF_SPLICE_MOVE);
}
static void
xdp_fuse_write (fuse_req_t req,
fuse_ino_t ino,
const char *buf,
size_t size,
off_t off,
struct fuse_file_info *fi)
{
XdpFh *fh = (gpointer)fi->fh;
gssize res;
int fd;
XDP_FH_AUTOLOCK (fh);
if (fh->readonly)
{
fuse_reply_err (req, EACCES);
return;
}
fd = xdp_fh_get_fd_nolock (fh);
if (fd == -1)
{
fuse_reply_err (req, EIO);
return;
}
res = pwrite (fd, buf, size, off);
if (res < 0)
fuse_reply_err (req, errno);
else
fuse_reply_write (req, res);
}
static void
xdp_fuse_write_buf (fuse_req_t req,
fuse_ino_t ino,
struct fuse_bufvec *bufv,
off_t off,
struct fuse_file_info *fi)
{
XdpFh *fh = (gpointer)fi->fh;
struct fuse_bufvec dst = FUSE_BUFVEC_INIT(fuse_buf_size(bufv));
gssize res;
int fd;
XDP_FH_AUTOLOCK (fh);
if (fh->readonly)
{
fuse_reply_err (req, EACCES);
return;
}
fd = xdp_fh_get_fd_nolock (fh);
if (fd == -1)
{
fuse_reply_err (req, EIO);
return;
}
dst.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
dst.buf[0].fd = fd;
dst.buf[0].pos = off;
res = fuse_buf_copy (&dst, bufv, FUSE_BUF_SPLICE_NONBLOCK);
if (res < 0)
fuse_reply_err (req, -res);
else
fuse_reply_write (req, res);
}
static void
xdp_fuse_release (fuse_req_t req,
fuse_ino_t ino,
struct fuse_file_info *fi)
{
XdpFh *fh = (gpointer)fi->fh;
g_debug ("xdp_fuse_release %lx (fi=%p, refcount: %d)", ino, fi, fh->ref_count);
xdp_fh_unref (fh);
fuse_reply_err (req, 0);
}
static void
xdp_fuse_rename (fuse_req_t req,
fuse_ino_t parent,
const char *name,
fuse_ino_t newparent,
const char *newname)
{
XdpInodeClass parent_class = get_class (parent);
guint64 parent_class_ino = get_class_ino (parent);
g_autoptr (XdgAppDbEntry) entry = NULL;
int res;
fuse_ino_t inode;
struct stat stbuf = {0};
g_autofree char *basename = NULL;
g_autoptr(XdpTmp) tmp = NULL;
g_autoptr(XdpTmp) other_tmp = NULL;
guint32 app_id = 0;
guint32 doc_id = 0;
gboolean can_write;
g_debug ("xdp_fuse_rename %lx/%s -> %lx/%s", parent, name, newparent, newname);
res = xdp_lookup (parent, name, &inode, &stbuf, &entry, &tmp);
if (res != 0)
{
fuse_reply_err (req, res);
return;
}
if (parent_class != APP_DOC_DIR_INO_CLASS)
{
/* Only allow renames in (app) doc dirs */
fuse_reply_err (req, EACCES);
return;
}
app_id = get_app_id_from_app_doc_ino (parent_class_ino);
doc_id = get_doc_id_from_app_doc_ino (parent_class_ino);
can_write = app_can_write_doc (entry, app_id);
/* Only allow renames inside the same dir */
if (!can_write ||
parent != newparent ||
entry == NULL ||
/* Also, don't allow renaming non-tmpfiles */
tmp == NULL)
{
fuse_reply_err (req, EACCES);
return;
}
basename = xdp_entry_dup_basename (entry);
if (strcmp (newname, basename) == 0)
{
glnx_fd_close int dir_fd = -1;
g_autofree char *backing_basename = NULL;
/* Rename tmpfile to regular file */
dir_fd = xdp_entry_open_dir (entry);
if (dir_fd == -1)
{
fuse_reply_err (req, errno);
return;
}
/* Steal backing path so we don't delete it when unlinking tmp */
backing_basename = xdp_tmp_steal_backing_basename (tmp);
if (backing_basename == NULL)
{
fuse_reply_err (req, EINVAL);
return;
}
/* Stop writes to all outstanding fds to the temp file */
mark_open_tmp_file_readonly (tmp->tmp_id);
if (renameat (dir_fd, backing_basename,
dir_fd, basename) != 0)
{
fuse_reply_err (req, errno);
return;
}
AUTOLOCK(tmp_files);
xdp_tmp_unlink_nolock (tmp);
fuse_reply_err (req, 0);
/* We actually turn the old inode to a different one after the rename, so
we need to invalidate the target entry */
fuse_lowlevel_notify_inval_entry (main_ch, make_app_doc_dir_inode (app_id, doc_id),
basename, strlen (basename));
}
else
{
/* Rename tmpfile to other tmpfile name */
AUTOLOCK(tmp_files);
other_tmp = find_tmp_by_name_nolock (newparent, newname);
if (other_tmp)
xdp_tmp_unlink_nolock (other_tmp);
g_free (tmp->name);
tmp->name = g_strdup (newname);
fuse_reply_err (req, 0);
}
}
static void
xdp_fuse_setattr (fuse_req_t req,
fuse_ino_t ino,
struct stat *attr,
int to_set,
struct fuse_file_info *fi)
{
g_debug ("xdp_fuse_setattr %lx %x %p", ino, to_set, fi);
if (to_set == FUSE_SET_ATTR_SIZE && fi != NULL)
{
XdpFh *fh = (gpointer)fi->fh;
int res;
struct stat newattr = {0};
/* ftruncate */
if (!fh->can_write)
{
fuse_reply_err (req, EACCES);
return;
}
res = xdp_fh_truncate_locked (fh, attr->st_size, &newattr);
if (res < 0)
{
fuse_reply_err (req, res);
return;
}
fuse_reply_attr (req, &newattr, get_attr_cache_time (newattr.st_mode));
}
else if (to_set == FUSE_SET_ATTR_SIZE && fi == NULL)
{
int res = 0;
struct stat newattr = {0};
struct stat *newattrp = &newattr;
g_autoptr(XdpFh) fh = NULL;
/* truncate, truncate any open files (but EACCES if not open) */
fh = find_open_fh (ino);
if (fh)
{
if (!fh->can_write)
{
fuse_reply_err (req, EACCES);
return;
}
res = xdp_fh_truncate_locked (fh, attr->st_size, newattrp);
newattrp = NULL;
}
else
{
fuse_reply_err (req, EACCES);
return;
}
if (res < 0)
{
fuse_reply_err (req, -res);
return;
}
fuse_reply_attr (req, &newattr, get_attr_cache_time (newattr.st_mode));
}
else if (to_set == FUSE_SET_ATTR_MODE)
{
gboolean found = FALSE;
int res, err = -1;
struct stat newattr = {0};
XdpFh *fh;
fh = find_open_fh (ino);
if (fh)
{
int fd, errsv;
if (!fh->can_write)
{
fuse_reply_err (req, EACCES);
return;
}
XDP_FH_AUTOLOCK (fh);
fd = xdp_fh_get_fd_nolock (fh);
if (fd != -1)
{
res = fchmod (fd, get_user_perms (attr));
errsv = errno;
found = TRUE;
if (res != 0)
err = -errsv;
else
err = xdp_fh_fstat (fh, &newattr);
}
}
if (!found)
{
fuse_reply_err (req, EACCES);
return;
}
if (err < 0)
{
fuse_reply_err (req, -err);
return;
}
fuse_reply_attr (req, &newattr, get_attr_cache_time (newattr.st_mode));
}
else
fuse_reply_err (req, ENOSYS);
}
static void
xdp_fuse_fsyncdir (fuse_req_t req,
fuse_ino_t ino,
int datasync,
struct fuse_file_info *fi)
{
XdpInodeClass class = get_class (ino);
guint64 class_ino = get_class_ino (ino);
guint32 doc_id;
if (class == APP_DOC_DIR_INO_CLASS)
{
g_autoptr (XdgAppDbEntry) entry = NULL;
doc_id = get_doc_id_from_app_doc_ino (class_ino);
entry = xdp_lookup_doc (doc_id);
if (entry != NULL)
{
g_autofree char *dirname = xdp_entry_dup_dirname (entry);
int fd = open (dirname, O_DIRECTORY|O_RDONLY);
if (fd >= 0)
{
if (datasync)
fdatasync (fd);
else
fsync (fd);
close (fd);
}
}
}
fuse_reply_err (req, 0);
}
static void
xdp_fuse_fsync (fuse_req_t req,
fuse_ino_t ino,
int datasync,
struct fuse_file_info *fi)
{
XdpInodeClass class = get_class (ino);
if (class == APP_DOC_FILE_INO_CLASS ||
class == TMPFILE_INO_CLASS)
{
XdpFh *fh = (gpointer)fi->fh;
XDP_FH_AUTOLOCK (fh);
if (fh->fd >= 0)
fsync (fh->fd);
if (fh->truncated && fh->trunc_fd >= 0)
fsync (fh->trunc_fd);
}
fuse_reply_err (req, 0);
}
static void
xdp_fuse_unlink (fuse_req_t req,
fuse_ino_t parent,
const char *name)
{
XdpInodeClass parent_class = get_class (parent);
guint64 parent_class_ino = get_class_ino (parent);
g_autoptr (XdgAppDbEntry) entry = NULL;
int res;
fuse_ino_t inode;
struct stat stbuf = {0};
g_autofree char *basename = NULL;
g_autoptr (XdpTmp) tmp = NULL;
guint32 app_id = 0;
gboolean can_write;
g_debug ("xdp_fuse_unlink %lx/%s", parent, name);
res = xdp_lookup (parent, name, &inode, &stbuf, &entry, &tmp);
if (res != 0)
{
fuse_reply_err (req, res);
return;
}
if (entry == NULL)
{
fuse_reply_err (req, EACCES);
return;
}
if (parent_class != APP_DOC_DIR_INO_CLASS)
{
/* Only allow unlink in (app) doc dirs */
fuse_reply_err (req, EACCES);
return;
}
app_id = get_app_id_from_app_doc_ino (parent_class_ino);
can_write = app_can_write_doc (entry, app_id);
if (!can_write)
{
fuse_reply_err (req, EACCES);
return;
}
basename = xdp_entry_dup_basename (entry);
if (strcmp (name, basename) == 0)
{
glnx_fd_close int dir_fd = -1;
dir_fd = xdp_entry_open_dir (entry);
if (dir_fd == -1)
{
fuse_reply_err (req, errno);
return;
}
if (unlinkat (dir_fd, basename, 0) != 0)
{
fuse_reply_err (req, errno);
return;
}
fuse_reply_err (req, 0);
}
else
{
AUTOLOCK(tmp_files);
xdp_tmp_unlink_nolock (tmp);
fuse_reply_err (req, 0);
}
}
static struct fuse_lowlevel_ops xdp_fuse_oper = {
.lookup = xdp_fuse_lookup,
.getattr = xdp_fuse_getattr,
.opendir = xdp_fuse_opendir,
.readdir = xdp_fuse_readdir,
.releasedir = xdp_fuse_releasedir,
.fsyncdir = xdp_fuse_fsyncdir,
.open = xdp_fuse_open,
.create = xdp_fuse_create,
.read = xdp_fuse_read,
.write = xdp_fuse_write,
.write_buf = xdp_fuse_write_buf,
.release = xdp_fuse_release,
.rename = xdp_fuse_rename,
.setattr = xdp_fuse_setattr,
.fsync = xdp_fuse_fsync,
.unlink = xdp_fuse_unlink,
};
/* Called when a apps permissions to see a document is changed */
void
xdp_fuse_invalidate_doc_app (const char *doc_id_s,
const char *app_id_s,
XdgAppDbEntry *entry)
{
guint32 app_id = get_app_id_from_name (app_id_s);
guint32 doc_id = xdp_id_from_name (doc_id_s);
g_autofree char *basename = xdp_entry_dup_basename (entry);
g_debug ("invalidate %s/%s\n", doc_id_s, app_id_s);
/* This can happen if fuse is not initialized yet for the very
first dbus message that activated the service */
if (main_ch == NULL)
return;
fuse_lowlevel_notify_inval_inode (main_ch, make_app_doc_file_inode (app_id, doc_id), 0, 0);
fuse_lowlevel_notify_inval_entry (main_ch, make_app_doc_dir_inode (app_id, doc_id),
basename, strlen (basename));
fuse_lowlevel_notify_inval_inode (main_ch, make_app_doc_dir_inode (app_id, doc_id), 0, 0);
fuse_lowlevel_notify_inval_entry (main_ch, make_inode (APP_DIR_INO_CLASS, app_id),
doc_id_s, strlen (doc_id_s));
}
/* Called when a document id is created/removed */
void
xdp_fuse_invalidate_doc (const char *doc_id_s,
XdgAppDbEntry *entry)
{
guint32 doc_id = xdp_id_from_name (doc_id_s);
g_autofree char *basename = xdp_entry_dup_basename (entry);
g_debug ("invalidate %s\n", doc_id_s);
/* This can happen if fuse is not initialized yet for the very
first dbus message that activated the service */
if (main_ch == NULL)
return;
fuse_lowlevel_notify_inval_inode (main_ch, make_app_doc_file_inode (0, doc_id), 0, 0);
fuse_lowlevel_notify_inval_entry (main_ch, make_app_doc_dir_inode (0, doc_id),
basename, strlen (basename));
fuse_lowlevel_notify_inval_inode (main_ch, make_app_doc_dir_inode (0, doc_id), 0, 0);
fuse_lowlevel_notify_inval_entry (main_ch, FUSE_ROOT_ID, doc_id_s, strlen (doc_id_s));
}
guint32
xdp_fuse_lookup_id_for_inode (ino_t inode)
{
XdpInodeClass class = get_class (inode);
guint64 class_ino = get_class_ino (inode);
if (class != APP_DOC_FILE_INO_CLASS)
return 0;
return get_doc_id_from_app_doc_ino (class_ino);
}
const char *
xdp_fuse_get_mountpoint (void)
{
if (mount_path == NULL)
mount_path = g_build_filename (g_get_user_runtime_dir(), "doc", NULL);
return mount_path;
}
void
xdp_fuse_exit (void)
{
if (session)
fuse_session_exit (session);
if (fuse_pthread)
pthread_kill (fuse_pthread, SIGHUP);
if (fuse_thread)
g_thread_join (fuse_thread);
}
static gpointer
xdp_fuse_mainloop (gpointer data)
{
fuse_pthread = pthread_self ();
fuse_session_loop_mt (session);
fuse_session_remove_chan(main_ch);
fuse_session_destroy (session);
fuse_unmount (mount_path, main_ch);
return NULL;
}
gboolean
xdp_fuse_init (GError **error)
{
char *argv[] = { "xdp-fuse", "-osplice_write,splice_move,splice_read" };
struct fuse_args args = FUSE_ARGS_INIT(G_N_ELEMENTS(argv), argv);
struct stat st;
const char *mount_path;
app_name_to_id =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
app_id_to_name =
g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL);
mount_path = xdp_fuse_get_mountpoint ();
if (stat (mount_path, &st) == -1 && errno == ENOTCONN)
{
char *argv[] = { "fusermount", "-u", (char *)mount_path, NULL };
g_spawn_sync (NULL, argv, NULL, G_SPAWN_SEARCH_PATH,
NULL, NULL, NULL, NULL, NULL, NULL);
}
if (g_mkdir_with_parents (mount_path, 0700))
{
g_set_error (error, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_FAILED,
"Unable to create dir %s\n", mount_path);
return FALSE;
}
main_ch = fuse_mount (mount_path, &args);
if (main_ch == NULL)
{
g_set_error (error, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_FAILED, "Can't mount fuse fs");
return FALSE;
}
session = fuse_lowlevel_new (&args, &xdp_fuse_oper,
sizeof (xdp_fuse_oper), NULL);
if (session == NULL)
{
g_set_error (error, XDG_APP_PORTAL_ERROR, XDG_APP_PORTAL_ERROR_FAILED,
"Can't create fuse session");
return FALSE;
}
fuse_session_add_chan (session, main_ch);
fuse_thread = g_thread_new ("fuse mainloop", xdp_fuse_mainloop, session);
return TRUE;
}
Reference in New Issue View Git Blame Copy Permalink