fs/xfs/linux-2.6/xfs_xattr.c

   1 /*
   2  * Copyright (C) 2008 Christoph Hellwig.
   3  * Portions Copyright (C) 2000-2008 Silicon Graphics, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include "xfs.h"
  20 #include "xfs_da_btree.h"
  21 #include "xfs_bmap_btree.h"
  22 #include "xfs_inode.h"
  23 #include "xfs_attr.h"
  24 #include "xfs_attr_leaf.h"
  25 #include "xfs_acl.h"
  26 #include "xfs_vnodeops.h"
  27
  28 #include <linux/posix_acl_xattr.h>
  29 #include <linux/xattr.h>
  30
  31
  32 /*
  33  * Get system extended attributes which at the moment only
  34  * includes Posix ACLs.
  35  */
  36 static int
  37 xfs_xattr_system_get(struct inode *inode, const char *name,
  38                 void *buffer, size_t size)
  39 {
  40         int acl;
  41
  42         acl = xfs_decode_acl(name);
  43         if (acl < 0)
  44                 return acl;
  45
  46         return xfs_acl_vget(inode, buffer, size, acl);
  47 }
  48
  49 static int
  50 xfs_xattr_system_set(struct inode *inode, const char *name,
  51                 const void *value, size_t size, int flags)
  52 {
  53         int acl;
  54
  55         acl = xfs_decode_acl(name);
  56         if (acl < 0)
  57                 return acl;
  58         if (flags & XATTR_CREATE)
  59                 return -EINVAL;
  60
  61         if (!value)
  62                 return xfs_acl_vremove(inode, acl);
  63
  64         return xfs_acl_vset(inode, (void *)value, size, acl);
  65 }
  66
  67 static struct xattr_handler xfs_xattr_system_handler = {
  68         .prefix = XATTR_SYSTEM_PREFIX,
  69         .get    = xfs_xattr_system_get,
  70         .set    = xfs_xattr_system_set,
  71 };
  72
  73
  74 /*
  75  * Real xattr handling.  The only difference between the namespaces is
  76  * a flag passed to the low-level attr code.
  77  */
  78
  79 static int
  80 __xfs_xattr_get(struct inode *inode, const char *name,
  81                 void *value, size_t size, int xflags)
  82 {
  83         struct xfs_inode *ip = XFS_I(inode);
  84         int error, asize = size;
  85
  86         if (strcmp(name, "") == 0)
  87                 return -EINVAL;
  88
  89         /* Convert Linux syscall to XFS internal ATTR flags */
  90         if (!size) {
  91                 xflags |= ATTR_KERNOVAL;
  92                 value = NULL;
  93         }
  94
  95         error = -xfs_attr_get(ip, name, value, &asize, xflags);
  96         if (error)
  97                 return error;
  98         return asize;
  99 }
 100
 101 static int
 102 __xfs_xattr_set(struct inode *inode, const char *name, const void *value,
 103                 size_t size, int flags, int xflags)
 104 {
 105         struct xfs_inode *ip = XFS_I(inode);
 106
 107         if (strcmp(name, "") == 0)
 108                 return -EINVAL;
 109
 110         /* Convert Linux syscall to XFS internal ATTR flags */
 111         if (flags & XATTR_CREATE)
 112                 xflags |= ATTR_CREATE;
 113         if (flags & XATTR_REPLACE)
 114                 xflags |= ATTR_REPLACE;
 115
 116         if (!value)
 117                 return -xfs_attr_remove(ip, name, xflags);
 118         return -xfs_attr_set(ip, name, (void *)value, size, xflags);
 119 }
 120
 121 static int
 122 xfs_xattr_user_get(struct inode *inode, const char *name,
 123                 void *value, size_t size)
 124 {
 125         return __xfs_xattr_get(inode, name, value, size, 0);
 126 }
 127
 128 static int
 129 xfs_xattr_user_set(struct inode *inode, const char *name,
 130                 const void *value, size_t size, int flags)
 131 {
 132         return __xfs_xattr_set(inode, name, value, size, flags, 0);
 133 }
 134
 135 static struct xattr_handler xfs_xattr_user_handler = {
 136         .prefix = XATTR_USER_PREFIX,
 137         .get    = xfs_xattr_user_get,
 138         .set    = xfs_xattr_user_set,
 139 };
 140
 141
 142 static int
 143 xfs_xattr_trusted_get(struct inode *inode, const char *name,
 144                 void *value, size_t size)
 145 {
 146         return __xfs_xattr_get(inode, name, value, size, ATTR_ROOT);
 147 }
 148
 149 static int
 150 xfs_xattr_trusted_set(struct inode *inode, const char *name,
 151                 const void *value, size_t size, int flags)
 152 {
 153         return __xfs_xattr_set(inode, name, value, size, flags, ATTR_ROOT);
 154 }
 155
 156 static struct xattr_handler xfs_xattr_trusted_handler = {
 157         .prefix = XATTR_TRUSTED_PREFIX,
 158         .get    = xfs_xattr_trusted_get,
 159         .set    = xfs_xattr_trusted_set,
 160 };
 161
 162
 163 static int
 164 xfs_xattr_secure_get(struct inode *inode, const char *name,
 165                 void *value, size_t size)
 166 {
 167         return __xfs_xattr_get(inode, name, value, size, ATTR_SECURE);
 168 }
 169
 170 static int
 171 xfs_xattr_secure_set(struct inode *inode, const char *name,
 172                 const void *value, size_t size, int flags)
 173 {
 174         return __xfs_xattr_set(inode, name, value, size, flags, ATTR_SECURE);
 175 }
 176
 177 static struct xattr_handler xfs_xattr_security_handler = {
 178         .prefix = XATTR_SECURITY_PREFIX,
 179         .get    = xfs_xattr_secure_get,
 180         .set    = xfs_xattr_secure_set,
 181 };
 182
 183
 184 struct xattr_handler *xfs_xattr_handlers[] = {
 185         &xfs_xattr_user_handler,
 186         &xfs_xattr_trusted_handler,
 187         &xfs_xattr_security_handler,
 188         &xfs_xattr_system_handler,
 189         NULL
 190 };
 191
 192 static unsigned int xfs_xattr_prefix_len(int flags)
 193 {
 194         if (flags & XFS_ATTR_SECURE)
 195                 return sizeof("security");
 196         else if (flags & XFS_ATTR_ROOT)
 197                 return sizeof("trusted");
 198         else
 199                 return sizeof("user");
 200 }
 201
 202 static const char *xfs_xattr_prefix(int flags)
 203 {
 204         if (flags & XFS_ATTR_SECURE)
 205                 return xfs_xattr_security_handler.prefix;
 206         else if (flags & XFS_ATTR_ROOT)
 207                 return xfs_xattr_trusted_handler.prefix;
 208         else
 209                 return xfs_xattr_user_handler.prefix;
 210 }
 211
 212 static int
 213 xfs_xattr_put_listent(struct xfs_attr_list_context *context, int flags,
 214                 char *name, int namelen, int valuelen, char *value)
 215 {
 216         unsigned int prefix_len = xfs_xattr_prefix_len(flags);
 217         char *offset;
 218         int arraytop;
 219
 220         ASSERT(context->count >= 0);
 221
 222         /*
 223          * Only show root namespace entries if we are actually allowed to
 224          * see them.
 225          */
 226         if ((flags & XFS_ATTR_ROOT) && !capable(CAP_SYS_ADMIN))
 227                 return 0;
 228
 229         arraytop = context->count + prefix_len + namelen + 1;
 230         if (arraytop > context->firstu) {
 231                 context->count = -1;    /* insufficient space */
 232                 return 1;
 233         }
 234         offset = (char *)context->alist + context->count;
 235         strncpy(offset, xfs_xattr_prefix(flags), prefix_len);
 236         offset += prefix_len;
 237         strncpy(offset, name, namelen);                 /* real name */
 238         offset += namelen;
 239         *offset = '\0';
 240         context->count += prefix_len + namelen + 1;
 241         return 0;
 242 }
 243
 244 static int
 245 xfs_xattr_put_listent_sizes(struct xfs_attr_list_context *context, int flags,
 246                 char *name, int namelen, int valuelen, char *value)
 247 {
 248         context->count += xfs_xattr_prefix_len(flags) + namelen + 1;
 249         return 0;
 250 }
 251
 252 static int
 253 list_one_attr(const char *name, const size_t len, void *data,
 254                 size_t size, ssize_t *result)
 255 {
 256         char *p = data + *result;
 257
 258         *result += len;
 259         if (!size)
 260                 return 0;
 261         if (*result > size)
 262                 return -ERANGE;
 263
 264         strcpy(p, name);
 265         return 0;
 266 }
 267
 268 ssize_t
 269 xfs_vn_listxattr(struct dentry *dentry, char *data, size_t size)
 270 {
 271         struct xfs_attr_list_context context;
 272         struct attrlist_cursor_kern cursor = { 0 };
 273         struct inode            *inode = dentry->d_inode;
 274         int                     error;
 275
 276         /*
 277          * First read the regular on-disk attributes.
 278          */
 279         memset(&context, 0, sizeof(context));
 280         context.dp = XFS_I(inode);
 281         context.cursor = &cursor;
 282         context.resynch = 1;
 283         context.alist = data;
 284         context.bufsize = size;
 285         context.firstu = context.bufsize;
 286
 287         if (size)
 288                 context.put_listent = xfs_xattr_put_listent;
 289         else
 290                 context.put_listent = xfs_xattr_put_listent_sizes;
 291
 292         xfs_attr_list_int(&context);
 293         if (context.count < 0)
 294                 return -ERANGE;
 295
 296         /*
 297          * Then add the two synthetic ACL attributes.
 298          */
 299         if (xfs_acl_vhasacl_access(inode)) {
 300                 error = list_one_attr(POSIX_ACL_XATTR_ACCESS,
 301                                 strlen(POSIX_ACL_XATTR_ACCESS) + 1,
 302                                 data, size, &context.count);
 303                 if (error)
 304                         return error;
 305         }
 306
 307         if (xfs_acl_vhasacl_default(inode)) {
 308                 error = list_one_attr(POSIX_ACL_XATTR_DEFAULT,
 309                                 strlen(POSIX_ACL_XATTR_DEFAULT) + 1,
 310                                 data, size, &context.count);
 311                 if (error)
 312                         return error;
 313         }
 314
 315         return context.count;
 316 }