18861N/A dnl ==============================================================================
18861N/A-PKG_CHECK_MODULES(LIBGNOMEVFS, glib-2.0 >= $GLIB_REQUIRED gmodule-no-export-2.0 >= $GLIB_REQUIRED gthread-2.0 >= $GLIB_REQUIRED gobject-2.0 >= $GLIB_REQUIRED gconf-2.0 >= $GCONF_REQUIRED libxml-2.0 >= $XML_REQUIRED gnome-mime-data-2.0 $dbus_requirement)
18861N/A+PKG_CHECK_MODULES(LIBGNOMEVFS, glib-2.0 >= $GLIB_REQUIRED gmodule-no-export-2.0 >= $GLIB_REQUIRED gthread-2.0 >= $GLIB_REQUIRED gobject-2.0 >= $GLIB_REQUIRED gconf-2.0 >= $GCONF_REQUIRED libxml-2.0 >= $XML_REQUIRED gnome-mime-data-2.0 dbus-glib-1 >= 0.60)
18861N/A LIBGNOMEVFS_CFLAGS="$LIBGNOMEVFS_CFLAGS $OPENSSL_CFLAGS $LIBGNUTLS_CFLAGS $HOWL_CFLAGS $AVAHI_CFLAGS"
18861N/A LIBGNOMEVFS_LIBS="$LIBGNOMEVFS_LIBS $OPENSSL_LIBS $LIBGNUTLS_LIBS $HOWL_LIBS $AVAHI_LIBS $RESOLVER_LIBS"
18861N/A AC_CHECK_FUNCS(acl_extended_file)
18861N/A- if test "$ac_cv_header_pwd_h" = "yes"; then
18861N/A- AC_CACHE_CHECK([for posix getpwuid_r],
18861N/A- struct passwd pwd, *pwptr = &pwd;
18861N/A- error = getpwuid_r (0, &pwd, buffer,
18861N/A- return (error < 0 && errno == ENOSYS)
18861N/A- [ac_cv_func_posix_getpwuid_r=yes],
18861N/A- [ac_cv_func_posix_getpwuid_r=no])])
18861N/A- dnl GLIB_ASSERT_SET(ac_cv_func_posix_getpwuid_r)
18861N/A- if test "$ac_cv_func_posix_getpwuid_r" = yes; then
18861N/A- AC_DEFINE(HAVE_POSIX_GETPWUID_R,1,
18861N/A- [Have POSIX function getpwuid_r])
18861N/A- AC_CACHE_CHECK([for nonposix getpwuid_r],
20857N/A- ac_cv_func_nonposix_getpwuid_r,
18861N/A- [ac_cv_func_nonposix_getpwuid_r=yes],
18861N/A- [ac_cv_func_nonposix_getpwuid_r=no])])
18861N/A- dnl GLIB_ASSERT_SET(ac_cv_func_nonposix_getpwuid_r)
18861N/A- if test "$ac_cv_func_nonposix_getpwuid_r" = yes; then
18861N/A- AC_DEFINE(HAVE_NONPOSIX_GETPWUID_R,1,
18861N/A- [Have non-POSIX function getpwuid_r])
18861N/A+dnl checks for password entry functions and header files
18861N/A+AC_MSG_CHECKING(for getpwnam_r with 5 parameters)
18861N/A+getpwnam_r(NULL,NULL,NULL,0,NULL);,AC_DEFINE(HAVE_GETPWNAM_R_5,1,Some systems have getpwnam_r) AC_DEFINE(HAVE_GETPWNAM_R,1,Some systems have getpwnam_r) AC_MSG_RESULT(yes); HAVE_GETPWNAM_R="yes", AC_MSG_RESULT(no))
18861N/A+if ( test -z "$HAVE_GETPWNAM_R" )
18861N/A+ AC_MSG_CHECKING(for getpwnam_r with 4 parameters)
18861N/A+getpwnam_r(NULL,NULL,NULL,0);,AC_DEFINE(HAVE_GETPWNAM_R_4,1,Some systems have getpwnam_r) AC_DEFINE(HAVE_GETPWNAM_R,1,Some systems have getpwnam_r) AC_MSG_RESULT(yes), AC_MSG_RESULT(no))
18861N/A+AC_MSG_CHECKING(for getpwuid_r with 5 parameters)
18861N/A+getpwuid_r(0,NULL,NULL,0,NULL);,AC_DEFINE(HAVE_GETPWUID_R_5,1,Some systems have getpwuid_r) AC_DEFINE(HAVE_GETPWUID_R,1,Some systems have getpwuid_r) AC_MSG_RESULT(yes); HAVE_GETPWUID_R="yes", AC_MSG_RESULT(no))
18861N/A+if ( test -z "$HAVE_GETPWUID_R" )
18861N/A+ AC_MSG_CHECKING(for getpwuid_r with 4 parameters)
18861N/A+getpwuid_r(0,NULL,NULL,0);,AC_DEFINE(HAVE_GETPWUID_R_4,1,Some systems have getpwuid_r) AC_DEFINE(HAVE_GETPWUID_R,1,Some systems have getpwuid_r) AC_MSG_RESULT(yes), AC_MSG_RESULT(no))
18861N/A+dnl checks for group entry functions and header files
+AC_MSG_CHECKING(for getgrnam_r with 5 parameters)
+AC_TRY_COMPILE([#include <
grp.h>
+getgrnam_r(NULL,NULL,NULL,0,NULL);,AC_DEFINE(HAVE_GETGRNAM_R_5,1,Some systems have getgrnam_r) AC_DEFINE(HAVE_GETGRNAM_R,1,Some systems have getgrnam_r) AC_MSG_RESULT(yes); HAVE_GETGRNAM_R="yes", AC_MSG_RESULT(no))
+if ( test -z "$HAVE_GETGRNAM_R" )
+ AC_MSG_CHECKING(for getgrnam_r with 4 parameters)
+ AC_TRY_COMPILE([#include <
grp.h>
+getgrnam_r(NULL,NULL,NULL,0);,AC_DEFINE(HAVE_GETGRNAM_R_4,1,Some systems have getgrnam_r) AC_DEFINE(HAVE_GETGRNAM_R,1,Some systems have getgrnam_r) AC_MSG_RESULT(yes), AC_MSG_RESULT(no))
+AC_MSG_CHECKING(for getgrgid_r with 5 parameters)
+AC_TRY_COMPILE([#include <
grp.h>
+getgrgid_r(0,NULL,NULL,0,NULL);,AC_DEFINE(HAVE_GETGRGID_R_5,1,Some systems have getgrgid_r) AC_DEFINE(HAVE_GETGRGID_R,1,Some systems have getgrgid_r) AC_MSG_RESULT(yes); HAVE_GETGRGID_R="yes", AC_MSG_RESULT(no))
+if ( test -z "$HAVE_GETGRGID_R" )
+ AC_MSG_CHECKING(for getgrgid_r with 4 parameters)
+ AC_TRY_COMPILE([#include <
grp.h>
+getgrgid_r(0,NULL,NULL,0);,AC_DEFINE(HAVE_GETGRGID_R_4,1,Some systems have getgrgid_r) AC_DEFINE(HAVE_GETGRGID_R,1,Some systems have getgrgid_r) AC_MSG_RESULT(yes), AC_MSG_RESULT(no))
struct _GnomeVFSACEPrivate {
+ GnomeVFSACLInherance inherance;
#define GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GNOME_VFS_TYPE_ACE, GnomeVFSACEPrivate))
- pspec = g_param_spec_boolean ("negative",
+ pspec = g_param_spec_uint ("type",
+ GNOME_VFS_ACL_TYPE_NULL,
+ GNOME_VFS_ACL_TYPE_NULL,
g_object_class_install_property (gobject_class,
- pspec = g_param_spec_boolean ("inherit",
+ pspec = g_param_spec_uint ("inherance",
+ GNOME_VFS_ACL_INHERANCE_NULL,
+ GNOME_VFS_ACL_INHERANCE_NULL,
g_object_class_install_property (gobject_class,
permset_set (&priv->perm_set, pset);
- priv->inherit = g_value_get_boolean (value);
+ priv->type = g_value_get_uint (value);
- priv->negative = g_value_get_boolean (value);
+ priv->inherance = g_value_get_uint (value);
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
- g_value_set_boolean (value, priv->inherit);
+ g_value_set_uint (value, priv->type);
- g_value_set_boolean (value, priv->negative);
+ g_value_set_uint (value, priv->inherance);
-gnome_vfs_ace_new (GnomeVFSACLKind kind,
- GnomeVFSACLPerm *perms)
+gnome_vfs_ace_new (GnomeVFSACLKind kind,
+ GnomeVFSACLPerm *perms,
+ GnomeVFSACLInherance inherance)
+ "inherance", inherance,
priv->id = g_strdup (id);
-gnome_vfs_ace_set_inherit (GnomeVFSACE *entry,
+gnome_vfs_ace_get_ace_type (GnomeVFSACE *entry)
- g_object_set (G_OBJECT(entry), "inherit", inherit, NULL);
+ return entry->priv->type;
-gnome_vfs_ace_get_inherit (GnomeVFSACE *entry)
- g_object_get (G_OBJECT(entry), "inherit", &inherit, NULL);
+gnome_vfs_ace_set_ace_type (GnomeVFSACE *entry,
+ entry->priv->type = type;
-gnome_vfs_ace_set_negative (GnomeVFSACE *entry,
+gnome_vfs_ace_get_inherance (GnomeVFSACE *entry)
- g_object_set (G_OBJECT(entry), "negative", negative, NULL);
+ return entry->priv->inherance;
-gnome_vfs_ace_get_negative (GnomeVFSACE *entry)
- g_object_get (G_OBJECT(entry), "negative", &negative, NULL);
+gnome_vfs_ace_set_inherance (GnomeVFSACE *entry,
+ GnomeVFSACLInherance inherance)
+ entry->priv->inherance = inherance;
gnome_vfs_ace_get_perms (GnomeVFSACE *entry)
return (priv_a->kind == priv_b->kind &&
g_str_equal_safe (priv_a->id, priv_b->id) &&
- priv_a->inherit == priv_b->inherit &&
- priv_a->negative == priv_b->negative);
+ priv_a->inherance == priv_b->inherance &&
+ priv_a->type == priv_b->type);
typedef guint32 GnomeVFSACLKind;
typedef guint32 GnomeVFSACLPerm;
+typedef guint32 GnomeVFSACLType;
+typedef guint32 GnomeVFSACLInherance;
+typedef guint32 GnomeVFSACLScheme;
GType gnome_vfs_ace_get_type (void) G_GNUC_CONST;
GnomeVFSACE * gnome_vfs_ace_new (GnomeVFSACLKind kind,
- GnomeVFSACLPerm *perms);
+ GnomeVFSACLPerm *perms,
+ GnomeVFSACLInherance inherance);
GnomeVFSACLKind gnome_vfs_ace_get_kind (GnomeVFSACE *entry);
void gnome_vfs_ace_set_kind (GnomeVFSACE *entry,
const char * gnome_vfs_ace_get_id (GnomeVFSACE *entry);
void gnome_vfs_ace_set_id (GnomeVFSACE *entry,
-gboolean gnome_vfs_ace_get_inherit (GnomeVFSACE *entry);
-void gnome_vfs_ace_set_inherit (GnomeVFSACE *entry,
-gboolean gnome_vfs_ace_get_negative (GnomeVFSACE *entry);
-void gnome_vfs_ace_set_negative (GnomeVFSACE *entry,
const GnomeVFSACLPerm * gnome_vfs_ace_get_perms (GnomeVFSACE *entry);
void gnome_vfs_ace_set_perms (GnomeVFSACE *entry,
+GnomeVFSACLType gnome_vfs_ace_get_ace_type (GnomeVFSACE *entry);
+void gnome_vfs_ace_set_ace_type (GnomeVFSACE *entry,
+GnomeVFSACLInherance gnome_vfs_ace_get_inherance (GnomeVFSACE *entry);
+void gnome_vfs_ace_set_inherance (GnomeVFSACE *entry,
+ GnomeVFSACLInherance inherit);
+gboolean gnome_vfs_ace_equal (GnomeVFSACE *entry_a,
+/* Permission related */
void gnome_vfs_ace_add_perm (GnomeVFSACE *entry,
void gnome_vfs_ace_del_perm (GnomeVFSACE *entry,
void gnome_vfs_ace_copy_perms (GnomeVFSACE *source,
-gboolean gnome_vfs_ace_equal (GnomeVFSACE *entry_a,
+/* Deprecated functions */
+gboolean gnome_vfs_ace_get_negative (GnomeVFSACE *entry);
+void gnome_vfs_ace_set_negative (GnomeVFSACE *entry,
struct _GnomeVFSACLPrivate {
+ GnomeVFSACLScheme scheme;
list = g_list_copy (priv->entries);
g_list_foreach (list, (GFunc) g_object_ref, NULL);
case GNOME_VFS_ACL_OTHER:
+ case GNOME_VFS_ACL_MASK:
+ case GNOME_VFS_ACL_EVERYONE:
+ case GNOME_VFS_ACL_OWNER_USER:
+ case GNOME_VFS_ACL_OWNER_GROUP:
case GNOME_VFS_ACL_EXECUTE:
+ /* NFSv4, ZFS extended permissions
+ case GNOME_VFS_ACL_LIST_DIRECTORY:
+ value = "list directory";
+ GNOME_VFS_ACL_ADD_FILE:
+ GNOME_VFS_ACL_APPEND_DATA:
+ GNOME_VFS_ACL_ADD_SUBDIRECTORY:
+ value = "add subdirectory";
+ GNOME_VFS_ACL_READ_NAMED_ATTRS:
+ value = "read named attributes";
+ GNOME_VFS_ACL_WRITE_NAMED_ATTRS:
+ value = "write named attributes";
+ GNOME_VFS_ACL_DELETE_CHILD:
+ value = "delete child";
+ GNOME_VFS_ACL_READ_ATTRIBUTES:
+ value = "read attributes";
+ GNOME_VFS_ACL_WRITE_ATTRIBUTES:
+ value = "write attributes";
+ GNOME_VFS_ACL_READ_ACL:
+ GNOME_VFS_ACL_WRITE_ACL:
+ GNOME_VFS_ACL_WRITE_OWNER:
+ GNOME_VFS_ACL_SYNCHRONIZE:
+gnome_vfs_acl_type_to_string (GnomeVFSACLType type)
+ if (type < GNOME_VFS_ACL_TYPE_SYS_LAST) {
+ case GNOME_VFS_ACL_ALLOW:
+ case GNOME_VFS_ACL_DENY:
+ case GNOME_VFS_ACL_AUDIT:
+ case GNOME_VFS_ACL_ALARM:
+gnome_vfs_acl_inherance_to_string (GnomeVFSACLInherance inheritance)
+ if (inheritance < GNOME_VFS_ACL_TYPE_SYS_LAST) {
+ case GNOME_VFS_ACL_FILE_INHERIT:
+ value = "File inherit";
+ case GNOME_VFS_ACL_DIR_INHERIT:
+ value = "Directory inherit";
+ case GNOME_VFS_ACL_INHERIT_ONLY:
+ value = "Inherit only";
+ case GNOME_VFS_ACL_NO_PROPAGATE:
+ value = "No propagate";
+gnome_vfs_acl_set_scheme (GnomeVFSACL *acl,
+ GnomeVFSACLScheme scheme)
+ acl->priv->scheme = scheme;
+gnome_vfs_acl_get_scheme (GnomeVFSACL *acl)
+ return acl->priv->scheme;
/* ************************************************************************** */
+const char * gnome_vfs_acl_inherance_to_string (GnomeVFSACLInherance inherance);
+ GNOME_VFS_ACL_INHERANCE_NULL = 0,
+ GNOME_VFS_ACL_FILE_INHERIT,
+ GNOME_VFS_ACL_DIR_INHERIT,
+ GNOME_VFS_ACL_INHERIT_ONLY,
+ GNOME_VFS_ACL_NO_PROPAGATE,
+ GNOME_VFS_ACL_INHERANCE_SYS_LAST
const char * gnome_vfs_acl_kind_to_string (GnomeVFSACLKind kind);
GNOME_VFS_ACL_KIND_NULL = 0,
+ /* NFSv4, ZFS extended kinds */
+ GNOME_VFS_ACL_EVERYONE,
+ GNOME_VFS_ACL_OWNER_USER,
+ GNOME_VFS_ACL_OWNER_GROUP,
GNOME_VFS_ACL_KIND_SYS_LAST
GNOME_VFS_ACL_PERM_NULL = 0,
+ /* Basic permissions */
+ /* NFSv4, ZFS extended permissions */
+ GNOME_VFS_ACL_LIST_DIRECTORY,
+ GNOME_VFS_ACL_ADD_FILE,
+ GNOME_VFS_ACL_APPEND_DATA,
+ GNOME_VFS_ACL_ADD_SUBDIRECTORY,
+ GNOME_VFS_ACL_READ_NAMED_ATTRS,
+ GNOME_VFS_ACL_WRITE_NAMED_ATTRS,
+ GNOME_VFS_ACL_DELETE_CHILD,
+ GNOME_VFS_ACL_READ_ATTRIBUTES,
+ GNOME_VFS_ACL_WRITE_ATTRIBUTES,
+ GNOME_VFS_ACL_READ_ACL,
+ GNOME_VFS_ACL_WRITE_ACL,
+ GNOME_VFS_ACL_WRITE_OWNER,
+ GNOME_VFS_ACL_SYNCHRONIZE,
GNOME_VFS_ACL_PERM_SYS_LAST
+const char * gnome_vfs_acl_type_to_string (GnomeVFSACLType type);
+ GNOME_VFS_ACL_TYPE_NULL = 0,
+ GNOME_VFS_ACL_TYPE_SYS_LAST
+ GNOME_VFS_ACL_SCHEME_NULL,
+ GNOME_VFS_ACL_SCHEME_CLASSIC,
+ GNOME_VFS_ACL_SCHEME_NFS4
/* ************************************************************************** */
#define GNOME_VFS_TYPE_ACL (gnome_vfs_acl_get_type ())
GList * gnome_vfs_acl_get_ace_list (GnomeVFSACL *acl);
void gnome_vfs_acl_free_ace_list (GList *ace_list);
+void gnome_vfs_acl_set_scheme (GnomeVFSACL *acl,
+ GnomeVFSACLScheme scheme);
+ gnome_vfs_acl_get_scheme (GnomeVFSACL *acl);
-#ifdef HAVE_SYS_RESOURCE_H
struct passwd *pw = NULL;
-#if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
+// #if defined (HAVE_POSIX_GETPWUID_R) || defined (HAVE_NONPOSIX_GETPWUID_R)
#endif /* _SC_GETPW_R_SIZE_MAX */
#ifdef HAVE_POSIX_GETPWUID_R
- error = getpwuid_r (uid, &pwd, buffer, bufsize, &pw);
+ error = getpwuid_r (uid, &pwd, buffer, bufsize, &pw);
error = error < 0 ? errno : error;
#else /* HAVE_NONPOSIX_GETPWUID_R */
/* HPUX 11 falls into the HAVE_POSIX_GETPWUID_R case */
error = getpwuid_r (uid, &pwd, buffer, bufsize);
pw = error == 0 ? &pwd : NULL;
- pw = getpwuid_r (uid, &pwd, buffer, bufsize);
+ pw = getpwuid_r (uid, &pwd, buffer, bufsize, &pw);
#endif /* HAVE_NONPOSIX_GETPWUID_R */
if (error == 0 || error == ENOENT) {
-#endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
+// #endif /* HAVE_POSIX_GETPWUID_R || HAVE_NONPOSIX_GETPWUID_R */
if (uid_string == NULL) {
uid_string = g_strdup_printf ("%d", uid);
permset_to_perms (e_ps, pset);
- ace = gnome_vfs_ace_new (kind, id, pset);
+ ace = gnome_vfs_ace_new (kind, id, pset, GNOME_VFS_ACL_ALLOW);
-#define SOLARIS_N_TAGS 3
+//#define SOLARIS_N_TAGS 3
+#define SOLARIS_N_TAGS GNOME_VFS_ACL_PERM_SYS_LAST
fixup_acl (GnomeVFSACL *acl, GSList *acls)
GnomeVFSACE *ace = GNOME_VFS_ACE(i->data);
- if (!gnome_vfs_ace_get_inherit(ace))
+// if (!gnome_vfs_ace_get_inherit(ace))
+ if (gnome_vfs_ace_get_inherance(ace) == GNOME_VFS_ACL_INHERANCE_NULL)
GNOME_VFS_ACL_EXECUTE, 0};
- ace = gnome_vfs_ace_new (GNOME_VFS_ACL_USER, NULL, perms);
- gnome_vfs_ace_set_inherit (ace, TRUE);
+ ace = gnome_vfs_ace_new (GNOME_VFS_ACL_USER, NULL, perms, GNOME_VFS_ACL_ALLOW, GNOME_VFS_ACL_FILE_INHERIT);
+// gnome_vfs_ace_set_inherit (ace, TRUE);
gnome_vfs_acl_set (acl, ace);
g_slist_append(acls, ace);
GnomeVFSACLPerm perms[] = {0};
- ace = gnome_vfs_ace_new (GNOME_VFS_ACL_GROUP, NULL, perms);
- gnome_vfs_ace_set_inherit (ace, TRUE);
+ ace = gnome_vfs_ace_new (GNOME_VFS_ACL_GROUP, NULL, perms, GNOME_VFS_ACL_ALLOW, GNOME_VFS_ACL_FILE_INHERIT);
+// gnome_vfs_ace_set_inherit (ace, TRUE);
gnome_vfs_acl_set (acl, ace);
GnomeVFSACLPerm perms[] = {0};
- ace = gnome_vfs_ace_new (GNOME_VFS_ACL_OTHER, NULL, perms);
- gnome_vfs_ace_set_inherit (ace, TRUE);
+ ace = gnome_vfs_ace_new (GNOME_VFS_ACL_OTHER, NULL, perms, GNOME_VFS_ACL_ALLOW, GNOME_VFS_ACL_FILE_INHERIT);
+// gnome_vfs_ace_set_inherit (ace, TRUE);
gnome_vfs_acl_set (acl, ace);
GNOME_VFS_ACL_EXECUTE, 0};
- ace = gnome_vfs_ace_new (GNOME_VFS_ACL_MASK, NULL, perms);
- gnome_vfs_ace_set_inherit (ace, TRUE);
+ ace = gnome_vfs_ace_new (GNOME_VFS_ACL_MASK, NULL, perms, GNOME_VFS_ACL_ALLOW, GNOME_VFS_ACL_FILE_INHERIT);
+// gnome_vfs_ace_set_inherit (ace, TRUE);
gnome_vfs_acl_set (acl, ace);
+nfs4_access_mask_to_perms (int access_mask, GnomeVFSACLPerm *tags)
+ memset (tags, 0, sizeof (GnomeVFSACLPerm) * (SOLARIS_N_TAGS + 1));
+ if (access_mask & ACE_READ_DATA)
+ tags[i++] = GNOME_VFS_ACL_READ;
+ if (access_mask & ACE_WRITE_DATA)
+ tags[i++] = GNOME_VFS_ACL_WRITE;
+ if (access_mask & ACE_EXECUTE)
+ tags[i++] = GNOME_VFS_ACL_EXECUTE;
+ if (access_mask & ACE_LIST_DIRECTORY)
+ tags[i++] = GNOME_VFS_ACL_LIST_DIRECTORY;
+ if (access_mask & ACE_ADD_FILE)
+ tags[i++] = GNOME_VFS_ACL_ADD_FILE;
+ if (access_mask & ACE_APPEND_DATA)
+ tags[i++] = GNOME_VFS_ACL_APPEND_DATA;
+ if (access_mask & ACE_ADD_SUBDIRECTORY)
+ tags[i++] = GNOME_VFS_ACL_ADD_SUBDIRECTORY;
+ if (access_mask & ACE_READ_NAMED_ATTRS)
+ tags[i++] = GNOME_VFS_ACL_READ_NAMED_ATTRS;
+ if (access_mask & ACE_WRITE_NAMED_ATTRS)
+ tags[i++] = GNOME_VFS_ACL_WRITE_NAMED_ATTRS;
+ if (access_mask & ACE_DELETE_CHILD)
+ tags[i++] = GNOME_VFS_ACL_DELETE_CHILD;
+ if (access_mask & ACE_READ_ATTRIBUTES)
+ tags[i++] = GNOME_VFS_ACL_READ_ATTRIBUTES;
+ if (access_mask & ACE_WRITE_ATTRIBUTES)
+ tags[i++] = GNOME_VFS_ACL_WRITE_ATTRIBUTES;
+ if (access_mask & ACE_DELETE)
+ tags[i++] = GNOME_VFS_ACL_DELETE;
+ if (access_mask & ACE_READ_ACL)
+ tags[i++] = GNOME_VFS_ACL_READ_ACL;
+ if (access_mask & ACE_WRITE_ACL)
+ tags[i++] = GNOME_VFS_ACL_WRITE_ACL;
+ if (access_mask & ACE_WRITE_OWNER)
+ tags[i++] = GNOME_VFS_ACL_WRITE_OWNER;
+ if (access_mask & ACE_SYNCHRONIZE)
+ tags[i++] = GNOME_VFS_ACL_SYNCHRONIZE;
solaris_acl_read (GnomeVFSACL *acl,
for (tp = aclp, i=0; i < aclcnt; tp++, i++) {
- GnomeVFSACLPerm pset[SOLARIS_N_TAGS+1];
+ GnomeVFSACLInherance inherance;
+ GnomeVFSACLPerm pset[SOLARIS_N_TAGS+1];
kind = GNOME_VFS_ACL_KIND_NULL;
g_warning ("Unhandled Solaris ACE: %d\n", tp->a_type);
- permset_to_perms (tp->a_perm, pset);
- ace = gnome_vfs_ace_new (kind, id, pset);
+// if (tp->a_type & ACL_DEFAULT)
+// gnome_vfs_ace_set_inherit (ace, TRUE);
+ inherance = (tp->a_type & ACL_DEFAULT) ? GNOME_VFS_ACL_FILE_INHERIT : GNOME_VFS_ACL_INHERANCE_NULL;
- if (tp->a_type & ACL_DEFAULT)
- gnome_vfs_ace_set_inherit (ace, TRUE);
+ permset_to_perms (tp->a_perm, pset);
+ ace = gnome_vfs_ace_new (kind, id, pset, GNOME_VFS_ACL_ALLOW, inherance);
gnome_vfs_acl_set (acl, ace);
+solaris_acl_nfs4_read (GnomeVFSACL *acl,
+ for (tp = aclp, i=0; i < aclcnt; tp++, i++) {
+ GnomeVFSACLInherance inherance;
+ GnomeVFSACLPerm pset[SOLARIS_N_TAGS+1];
+ type = GNOME_VFS_ACL_TYPE_NULL;
+ kind = GNOME_VFS_ACL_KIND_NULL;
+ inherance = GNOME_VFS_ACL_INHERANCE_NULL;
+ owner_type = tp->a_flags & ACE_TYPE_FLAGS;
+ /* Type: allow, deny, ..
+ case ACE_ACCESS_ALLOWED_ACE_TYPE:
+ type = GNOME_VFS_ACL_ALLOW;
+ case ACE_ACCESS_DENIED_ACE_TYPE:
+ type = GNOME_VFS_ACL_DENY;
+ type = GNOME_VFS_ACL_TYPE_NULL;
+ /* Kind: user, group, everyone, ..
+ if (owner_type == ACE_OWNER) {
+ kind = GNOME_VFS_ACL_OWNER_USER;
+ } else if (owner_type == (ACE_GROUP|ACE_IDENTIFIER_GROUP)) {
+ kind = GNOME_VFS_ACL_OWNER_GROUP;
+ } else if (owner_type == ACE_GROUP) {
+ id = gid_to_string (tp->a_who);
+ kind = GNOME_VFS_ACL_GROUP;
+ } else if (owner_type == ACE_EVERYONE) {
+ kind = GNOME_VFS_ACL_EVERYONE;
+ id = uid_to_string (tp->a_who);
+ kind = GNOME_VFS_ACL_USER;
+ if (tp->a_flags & ACE_FILE_INHERIT_ACE) {
+ inherance = GNOME_VFS_ACL_FILE_INHERIT;
+ } else if (tp->a_flags & ACE_DIRECTORY_INHERIT_ACE) {
+ inherance = GNOME_VFS_ACL_DIR_INHERIT;
+ } else if (tp->a_flags & ACE_NO_PROPAGATE_INHERIT_ACE) {
+ inherance = GNOME_VFS_ACL_NO_PROPAGATE;
+ } else if (tp->a_flags & ACE_INHERIT_ONLY_ACE) {
+ inherance = GNOME_VFS_ACL_INHERIT_ONLY;
+ nfs4_access_mask_to_perms (tp->a_access_mask, pset);
+ ace = gnome_vfs_ace_new (kind, id, pset, type, inherance);
+ gnome_vfs_acl_set (acl, ace);
translate_ace_into_aclent (GnomeVFSACE *ace, aclent_t *aclp)
id_str = gnome_vfs_ace_get_id (ace);
kind = gnome_vfs_ace_get_kind (ace);
- is_default = gnome_vfs_ace_get_inherit (ace);
+ is_default = (gnome_vfs_ace_get_inherance(ace) != GNOME_VFS_ACL_INHERANCE_NULL);
-GnomeVFSResult file_get_acl (const char *path,
- GnomeVFSFileInfo *info,
- GnomeVFSContext *context)
+file_get_acl_classic (const char *path,
+ GnomeVFSFileInfo *info,
+ GnomeVFSContext *context)
- if (info->acl != NULL) {
- gnome_vfs_acl_clear (info->acl);
- info->acl = gnome_vfs_acl_new ();
aclcnt = acl (path, GETACLCNT, 0, NULL);
return aclerrno_to_vfserror (errno);
info->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_ACL;
+file_get_acl_nfs4 (const char *path,
+ GnomeVFSFileInfo *info,
+ GnomeVFSContext *context)
+ aclcnt = acl (path, ACE_GETACLCNT, 0, NULL);
+ return aclerrno_to_vfserror (errno);
+ if (aclcnt < MIN_ACL_ENTRIES) {
+ return GNOME_VFS_ERROR_INTERNAL;
+ aclp = (ace_t *)malloc(sizeof (ace_t) * aclcnt);
+ return GNOME_VFS_ERROR_NO_MEMORY;
+ re = acl (path, ACE_GETACL, aclcnt, aclp);
+ return aclerrno_to_vfserror (errno);
+ re = solaris_acl_nfs4_read (info->acl, aclp, aclcnt, FALSE);
+ return GNOME_VFS_ERROR_INTERNAL;
+ info->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_ACL;
+GnomeVFSResult file_get_acl (const char *path,
+ GnomeVFSFileInfo *info,
+ GnomeVFSContext *context)
+ if (info->acl != NULL) {
+ gnome_vfs_acl_clear (info->acl);
+ info->acl = gnome_vfs_acl_new ();
+ acl_type = pathconf (path, _PC_ACL_ENABLED);
+ /* Call the sub-handler
+ if (acl_type == _ACL_ACLENT_ENABLED) {
+ gnome_vfs_acl_set_scheme (info->acl, GNOME_VFS_ACL_SCHEME_CLASSIC);
+ return file_get_acl_classic (path, info, statbuf, context);
+ else if (acl_type == _ACL_ACE_ENABLED) {
+ gnome_vfs_acl_set_scheme (info->acl, GNOME_VFS_ACL_SCHEME_NFS4);
+ return file_get_acl_nfs4 (path, info, statbuf, context);
+ return GNOME_VFS_ERROR_GENERIC;
#elif defined(HAVE_POSIX_ACL)
-file_set_acl (const char *path,
- const GnomeVFSFileInfo *info,
- GnomeVFSContext *context)
+file_set_acl_classic (const char *path,
+ const GnomeVFSFileInfo *info,
+ GnomeVFSContext *context)
- return GNOME_VFS_ERROR_BAD_PARAMETERS;
acls = gnome_vfs_acl_get_ace_list (info->acl);
if (acls == NULL) return GNOME_VFS_OK;
+ gnome_vfs_acl_free_ace_list (acls);
#elif defined(HAVE_POSIX_ACL)
+translate_ace_into_nfs4_ace (GnomeVFSACE *ace,
+ GnomeVFSACLInherance inherance;
+ g_assert (GNOME_VFS_IS_ACE(ace));
+ id = gnome_vfs_ace_get_id (ace);
+ kind = gnome_vfs_ace_get_kind (ace);
+ type = gnome_vfs_ace_get_ace_type (ace);
+ inherance = gnome_vfs_ace_get_inherance (ace);
+ system_ace->a_who = -1;
+ num = string_to_uid(id);
+ system_ace->a_who = num;
+ if (type == GNOME_VFS_ACL_DENY)
+ system_ace->a_type = ACE_ACCESS_DENIED_ACE_TYPE;
+ system_ace->a_type = ACE_ACCESS_ALLOWED_ACE_TYPE;
+ case GNOME_VFS_ACL_USER:
+ system_ace->a_flags = 0;
+ case GNOME_VFS_ACL_GROUP:
+ system_ace->a_flags |= ACE_IDENTIFIER_GROUP;
+ case GNOME_VFS_ACL_OWNER_USER:
+ system_ace->a_flags |= ACE_OWNER;
+ case GNOME_VFS_ACL_OWNER_GROUP:
+ system_ace->a_flags |= (ACE_GROUP | ACE_IDENTIFIER_GROUP);
+ case GNOME_VFS_ACL_EVERYONE:
+ system_ace->a_flags |= ACE_EVERYONE;
+#define set_perm(gnome,system) \
+ if (gnome_vfs_ace_check_perm (ace, gnome)) \
+ system_ace->a_access_mask |= system; \
+ system_ace->a_access_mask &= ~system; \
+ set_perm (GNOME_VFS_ACL_READ, ACE_READ_DATA);
+ set_perm (GNOME_VFS_ACL_WRITE, ACE_WRITE_DATA);
+ set_perm (GNOME_VFS_ACL_EXECUTE, ACE_EXECUTE);
+ set_perm (GNOME_VFS_ACL_LIST_DIRECTORY, ACE_LIST_DIRECTORY);
+ set_perm (GNOME_VFS_ACL_ADD_FILE, ACE_ADD_FILE);
+ set_perm (GNOME_VFS_ACL_APPEND_DATA, ACE_APPEND_DATA);
+ set_perm (GNOME_VFS_ACL_ADD_SUBDIRECTORY, ACE_ADD_SUBDIRECTORY);
+ set_perm (GNOME_VFS_ACL_READ_NAMED_ATTRS, ACE_READ_NAMED_ATTRS);
+ set_perm (GNOME_VFS_ACL_WRITE_NAMED_ATTRS, ACE_WRITE_NAMED_ATTRS);
+ set_perm (GNOME_VFS_ACL_DELETE_CHILD, ACE_DELETE_CHILD);
+ set_perm (GNOME_VFS_ACL_READ_ATTRIBUTES, ACE_READ_ATTRIBUTES);
+ set_perm (GNOME_VFS_ACL_WRITE_ATTRIBUTES, ACE_WRITE_ATTRIBUTES);
+ set_perm (GNOME_VFS_ACL_DELETE, ACE_DELETE);
+ set_perm (GNOME_VFS_ACL_READ_ACL, ACE_READ_ACL);
+ set_perm (GNOME_VFS_ACL_WRITE_ACL, ACE_WRITE_ACL);
+ set_perm (GNOME_VFS_ACL_WRITE_OWNER, ACE_WRITE_OWNER);
+ set_perm (GNOME_VFS_ACL_SYNCHRONIZE, ACE_SYNCHRONIZE);
+ case GNOME_VFS_ACL_FILE_INHERIT:
+ system_ace->a_flags &= ACE_FILE_INHERIT_ACE;
+ case GNOME_VFS_ACL_DIR_INHERIT:
+ system_ace->a_flags &= ACE_DIRECTORY_INHERIT_ACE;
+ case GNOME_VFS_ACL_NO_PROPAGATE:
+ system_ace->a_flags &= ACE_NO_PROPAGATE_INHERIT_ACE;
+ case GNOME_VFS_ACL_INHERIT_ONLY:
+ system_ace->a_flags &= ACE_INHERIT_ONLY_ACE;
+file_set_acl_nfs4 (const char *path,
+ const GnomeVFSFileInfo *info,
+ GnomeVFSContext *context)
+ acls = gnome_vfs_acl_get_ace_list (info->acl);
+ if (acls == NULL) return GNOME_VFS_OK;
+ len = g_list_length (acls);
+ if (len <= 0) return GNOME_VFS_OK;
+ acls = g_list_reverse (acls);
+ new_aclp = (ace_t *) malloc (len * sizeof(ace_t));
+ if (new_aclp == NULL) return GNOME_VFS_ERROR_NO_MEMORY;
+ memset (new_aclp, 0, len * sizeof(ace_t));
+ /* Convert GNOME-VFS aces to system ace_t's
+ for (entry=acls; entry != NULL; entry = entry->next) {
+ GnomeVFSACE *ace = GNOME_VFS_ACE(entry->data);
+ re = translate_ace_into_nfs4_ace (ace, taclp);
+ if (re != GNOME_VFS_OK) continue;
+ /* Commit it to the file system
+ re = acl (path, ACE_SETACL, aclp_i, (ace_t *)new_aclp);
+ return aclerrno_to_vfserror(err);
+ gnome_vfs_acl_free_ace_list (acls);
+file_set_acl (const char *path,
+ const GnomeVFSFileInfo *info,
+ GnomeVFSContext *context)
+ GnomeVFSACLScheme scheme;
+ return GNOME_VFS_ERROR_BAD_PARAMETERS;
+ scheme = gnome_vfs_acl_get_scheme(info->acl);
+ if (scheme == GNOME_VFS_ACL_SCHEME_CLASSIC)
+ return file_set_acl_classic (path, info, context);
+ return file_set_acl_nfs4 (path, info, context);
+G_LOCK_DEFINE (getpwnam_lock);
+secure_getpwnam (const char *name, struct passwd *pwbuf, char *buf, size_t buflen)
+ size_t pw_name_len = 0;
+ size_t pw_passwd_len = 0;
+ size_t pw_gecos_len = 0;
+ size_t pw_shell_len = 0;
+ if (tmp->pw_name) pw_name_len = strlen(tmp->pw_name);
+ if (tmp->pw_passwd) pw_passwd_len = strlen(tmp->pw_passwd);
+ if (tmp->pw_gecos) pw_gecos_len = strlen(tmp->pw_gecos);
+ if (tmp->pw_dir) pw_dir_len = strlen(tmp->pw_dir);
+ if (tmp->pw_shell) pw_shell_len = strlen(tmp->pw_shell);
+ if ((pw_name_len + pw_passwd_len +
+ pw_gecos_len + pw_dir_len + pw_shell_len) > buflen)
+ memset (buf, 0, buflen);
+ memcpy (ptr, tmp->pw_name, pw_name_len);
+ ptr += pw_name_len + 1;
+ memcpy (ptr, tmp->pw_passwd, pw_passwd_len);
+ pwbuf->pw_passwd = ptr;
+ ptr += pw_passwd_len + 1;
+ memcpy (ptr, tmp->pw_gecos, pw_gecos_len);
+ ptr += pw_gecos_len + 1;
+ memcpy (ptr, tmp->pw_dir, pw_dir_len);
+ memcpy (ptr, tmp->pw_shell, pw_shell_len);
+ ptr += pw_shell_len + 1;
+ G_UNLOCK(getpwnam_lock);
+ return getpwnam_r (name, pwbuf, buf, buflen, &tmp);
+ return getpwnam_r (name, pwbuf, buf, buflen);
+G_LOCK_DEFINE (getgrnam_lock);
+secure_getgrnam (const char *name, struct group *grbuf, char *buf, size_t buflen)
+ size_t gr_name_len = 0;
+ size_t gr_passwd_len = 0;
+ if (tmp->gr_name) gr_name_len = strlen(tmp->gr_name);
+ if (tmp->gr_passwd) gr_passwd_len = strlen(tmp->gr_passwd);
+ if ((gr_name_len + gr_passwd_len) > buflen)
+ memset (buf, 0, buflen);
+ grbuf->gr_gid = tmp->gr_gid;
+ memcpy (ptr, tmp->gr_name, gr_name_len);
+ ptr += gr_name_len + 1;
+ memcpy (ptr, tmp->gr_passwd, gr_passwd_len);
+ grbuf->gr_passwd = ptr;
+ ptr += gr_passwd_len + 1;
+ // TODO: Duplicate char **tmp->gr_mem
+ G_UNLOCK(getgrnam_lock);
+ return getgrnam_r (name, grbuf, buf, buflen, &tmp);
+ return getgrnam_r (name, grbuf, buf, buflen);
+get_access_info_acl (GnomeVFSFileInfo *file_info,
+ const gchar *full_name)
+ acls = gnome_vfs_acl_get_ace_list (file_info->acl);
+ for (iter = acls; iter; iter = iter->next) {
+ gid_t sup_groups[NGROUPS_MAX];
+ id = gnome_vfs_ace_get_id (ace);
+ if (id == NULL) continue;
+ re = secure_getpwnam (id, &pwd, buf, 1024);
+ group = secure_getgrnam (id, &grp, buf, 1024);
+ /* Suplementary groups */
+ sup_groups_num = getgroups(NGROUPS_MAX, sup_groups);
+ if ((file_info->uid == uid) ||
+ (file_info->gid == gid))
+ if (gnome_vfs_ace_check_perm (ace,GNOME_VFS_ACL_READ))
+ file_info->permissions |= GNOME_VFS_PERM_ACCESS_READABLE;
+ if (gnome_vfs_ace_check_perm (ace,GNOME_VFS_ACL_WRITE))
+ file_info->permissions |= GNOME_VFS_PERM_ACCESS_WRITABLE;
+ if (gnome_vfs_ace_check_perm (ace,GNOME_VFS_ACL_EXECUTE))
+ file_info->permissions |= GNOME_VFS_PERM_ACCESS_EXECUTABLE;
+ for (i = 0; i < sup_groups_num; i++) {
+ if (gid == sup_groups[i]) {
+ if (gnome_vfs_ace_check_perm (ace,GNOME_VFS_ACL_READ))
+ file_info->permissions |= GNOME_VFS_PERM_ACCESS_READABLE;
+ if (gnome_vfs_ace_check_perm (ace,GNOME_VFS_ACL_WRITE))
+ file_info->permissions |= GNOME_VFS_PERM_ACCESS_WRITABLE;
+ if (gnome_vfs_ace_check_perm (ace,GNOME_VFS_ACL_EXECUTE))
+ file_info->permissions |= GNOME_VFS_PERM_ACCESS_EXECUTABLE;
+ gnome_vfs_acl_free_ace_list (acls);
const GnomeVFSFileInfo *info,
GnomeVFSContext *context);
+void get_access_info_acl (GnomeVFSFileInfo *info,
+GnomeVFSACLScheme get_acl_scheme (GnomeVFSFileInfo *info);
+ get_access_info_acl (file_info, full_name);
file_info->valid_fields |= GNOME_VFS_FILE_INFO_FIELDS_ACCESS;
g_print ("Testing ACE Object\n");
- a = gnome_vfs_ace_new (GNOME_VFS_ACL_USER, "a", pset_a);
- b = gnome_vfs_ace_new (GNOME_VFS_ACL_USER, "a", NULL);
+ a = gnome_vfs_ace_new (GNOME_VFS_ACL_USER, "a", pset_a, GNOME_VFS_ACL_TYPE_NULL, GNOME_VFS_ACL_SCHEME_CLASSIC);
+ b = gnome_vfs_ace_new (GNOME_VFS_ACL_USER, "a", NULL, GNOME_VFS_ACL_TYPE_NULL, GNOME_VFS_ACL_SCHEME_CLASSIC);