fs/xattr_acl.c

   1 /*
   2  * linux/fs/xattr_acl.c
   3  *
   4  * Almost all from linux/fs/ext2/acl.c:
   5  * Copyright (C) 2001 by Andreas Gruenbacher, <a.gruenbacher@computer.org>
   6  */
   7
   8 #include <linux/export.h>
   9 #include <linux/fs.h>
  10 #include <linux/posix_acl_xattr.h>
  11 #include <linux/gfp.h>
  12 #include <linux/user_namespace.h>
  13
  14 /*
  15  * Fix up the uids and gids in posix acl extended attributes in place.
  16  */
  17 static void posix_acl_fix_xattr_userns(
  18         struct user_namespace *to, struct user_namespace *from,
  19         void *value, size_t size)
  20 {
  21         posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;
  22         posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
  23         int count;
  24         kuid_t uid;
  25         kgid_t gid;
  26
  27         if (!value)
  28                 return;
  29         if (size < sizeof(posix_acl_xattr_header))
  30                 return;
  31         if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
  32                 return;
  33
  34         count = posix_acl_xattr_count(size);
  35         if (count < 0)
  36                 return;
  37         if (count == 0)
  38                 return;
  39
  40         for (end = entry + count; entry != end; entry++) {
  41                 switch(le16_to_cpu(entry->e_tag)) {
  42                 case ACL_USER:
  43                         uid = make_kuid(from, le32_to_cpu(entry->e_id));
  44                         entry->e_id = cpu_to_le32(from_kuid(to, uid));
  45                         break;
  46                 case ACL_GROUP:
  47                         gid = make_kgid(from, le32_to_cpu(entry->e_id));
  48                         entry->e_id = cpu_to_le32(from_kgid(to, gid));
  49                         break;
  50                 default:
  51                         break;
  52                 }
  53         }
  54 }
  55
  56 void posix_acl_fix_xattr_from_user(void *value, size_t size)
  57 {
  58         struct user_namespace *user_ns = current_user_ns();
  59         if (user_ns == &init_user_ns)
  60                 return;
  61         posix_acl_fix_xattr_userns(&init_user_ns, user_ns, value, size);
  62 }
  63
  64 void posix_acl_fix_xattr_to_user(void *value, size_t size)
  65 {
  66         struct user_namespace *user_ns = current_user_ns();
  67         if (user_ns == &init_user_ns)
  68                 return;
  69         posix_acl_fix_xattr_userns(user_ns, &init_user_ns, value, size);
  70 }
  71
  72 /*
  73  * Convert from extended attribute to in-memory representation.
  74  */
  75 struct posix_acl *
  76 posix_acl_from_xattr(struct user_namespace *user_ns,
  77                      const void *value, size_t size)
  78 {
  79         posix_acl_xattr_header *header = (posix_acl_xattr_header *)value;
  80         posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
  81         int count;
  82         struct posix_acl *acl;
  83         struct posix_acl_entry *acl_e;
  84
  85         if (!value)
  86                 return NULL;
  87         if (size < sizeof(posix_acl_xattr_header))
  88                  return ERR_PTR(-EINVAL);
  89         if (header->a_version != cpu_to_le32(POSIX_ACL_XATTR_VERSION))
  90                 return ERR_PTR(-EOPNOTSUPP);
  91
  92         count = posix_acl_xattr_count(size);
  93         if (count < 0)
  94                 return ERR_PTR(-EINVAL);
  95         if (count == 0)
  96                 return NULL;
  97
  98         acl = posix_acl_alloc(count, GFP_NOFS);
  99         if (!acl)
 100                 return ERR_PTR(-ENOMEM);
 101         acl_e = acl->a_entries;
 102
 103         for (end = entry + count; entry != end; acl_e++, entry++) {
 104                 acl_e->e_tag  = le16_to_cpu(entry->e_tag);
 105                 acl_e->e_perm = le16_to_cpu(entry->e_perm);
 106
 107                 switch(acl_e->e_tag) {
 108                         case ACL_USER_OBJ:
 109                         case ACL_GROUP_OBJ:
 110                         case ACL_MASK:
 111                         case ACL_OTHER:
 112                                 break;
 113
 114                         case ACL_USER:
 115                                 acl_e->e_uid =
 116                                         make_kuid(user_ns,
 117                                                   le32_to_cpu(entry->e_id));
 118                                 if (!uid_valid(acl_e->e_uid))
 119                                         goto fail;
 120                                 break;
 121                         case ACL_GROUP:
 122                                 acl_e->e_gid =
 123                                         make_kgid(user_ns,
 124                                                   le32_to_cpu(entry->e_id));
 125                                 if (!gid_valid(acl_e->e_gid))
 126                                         goto fail;
 127                                 break;
 128
 129                         default:
 130                                 goto fail;
 131                 }
 132         }
 133         return acl;
 134
 135 fail:
 136         posix_acl_release(acl);
 137         return ERR_PTR(-EINVAL);
 138 }
 139 EXPORT_SYMBOL (posix_acl_from_xattr);
 140
 141 /*
 142  * Convert from in-memory to extended attribute representation.
 143  */
 144 int
 145 posix_acl_to_xattr(struct user_namespace *user_ns, const struct posix_acl *acl,
 146                    void *buffer, size_t size)
 147 {
 148         posix_acl_xattr_header *ext_acl = (posix_acl_xattr_header *)buffer;
 149         posix_acl_xattr_entry *ext_entry = ext_acl->a_entries;
 150         int real_size, n;
 151
 152         real_size = posix_acl_xattr_size(acl->a_count);
 153         if (!buffer)
 154                 return real_size;
 155         if (real_size > size)
 156                 return -ERANGE;
 157
 158         ext_acl->a_version = cpu_to_le32(POSIX_ACL_XATTR_VERSION);
 159
 160         for (n=0; n < acl->a_count; n++, ext_entry++) {
 161                 const struct posix_acl_entry *acl_e = &acl->a_entries[n];
 162                 ext_entry->e_tag  = cpu_to_le16(acl_e->e_tag);
 163                 ext_entry->e_perm = cpu_to_le16(acl_e->e_perm);
 164                 switch(acl_e->e_tag) {
 165                 case ACL_USER:
 166                         ext_entry->e_id =
 167                                 cpu_to_le32(from_kuid(user_ns, acl_e->e_uid));
 168                         break;
 169                 case ACL_GROUP:
 170                         ext_entry->e_id =
 171                                 cpu_to_le32(from_kgid(user_ns, acl_e->e_gid));
 172                         break;
 173                 default:
 174                         ext_entry->e_id = cpu_to_le32(ACL_UNDEFINED_ID);
 175                         break;
 176                 }
 177         }
 178         return real_size;
 179 }
 180 EXPORT_SYMBOL (posix_acl_to_xattr);