1 /* 2 * Squashfs - a compressed read only filesystem for Linux 3 * 4 * Copyright (c) 2010 5 * Phillip Lougher <phillip@lougher.demon.co.uk> 6 * 7 * This program is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU General Public License 9 * as published by the Free Software Foundation; either version 2, 10 * or (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, write to the Free Software 19 * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. 20 * 21 * xattr_id.c 22 */ 23 24 #include <linux/init.h> 25 #include <linux/module.h> 26 #include <linux/string.h> 27 #include <linux/fs.h> 28 #include <linux/vfs.h> 29 #include <linux/xattr.h> 30 #include <linux/slab.h> 31 32 #include "squashfs_fs.h" 33 #include "squashfs_fs_sb.h" 34 #include "squashfs_fs_i.h" 35 #include "squashfs.h" 36 37 static const struct xattr_handler *squashfs_xattr_handler(int); 38 39 ssize_t squashfs_listxattr(struct dentry *d, char *buffer, 40 size_t buffer_size) 41 { 42 struct inode *inode = d->d_inode; 43 struct super_block *sb = inode->i_sb; 44 struct squashfs_sb_info *msblk = sb->s_fs_info; 45 u64 start = SQUASHFS_XATTR_BLK(squashfs_i(inode)->xattr) 46 + msblk->xattr_table; 47 int offset = SQUASHFS_XATTR_OFFSET(squashfs_i(inode)->xattr); 48 int count = squashfs_i(inode)->xattr_count; 49 size_t rest = buffer_size; 50 int err; 51 52 /* check that the file system has xattrs */ 53 if (msblk->xattr_id_table == NULL) 54 return -EOPNOTSUPP; 55 56 /* loop reading each xattr name */ 57 while (count--) { 58 struct squashfs_xattr_entry entry; 59 struct squashfs_xattr_val val; 60 const struct xattr_handler *handler; 61 int name_size, prefix_size = 0; 62 63 err = squashfs_read_metadata(sb, &entry, &start, &offset, 64 sizeof(entry)); 65 if (err < 0) 66 goto failed; 67 68 name_size = le16_to_cpu(entry.size); 69 handler = squashfs_xattr_handler(le16_to_cpu(entry.type)); 70 if (handler) 71 prefix_size = handler->list(d, buffer, rest, NULL, 72 name_size, handler->flags); 73 if (prefix_size) { 74 if (buffer) { 75 if (prefix_size + name_size + 1 > rest) { 76 err = -ERANGE; 77 goto failed; 78 } 79 buffer += prefix_size; 80 } 81 err = squashfs_read_metadata(sb, buffer, &start, 82 &offset, name_size); 83 if (err < 0) 84 goto failed; 85 if (buffer) { 86 buffer[name_size] = '\0'; 87 buffer += name_size + 1; 88 } 89 rest -= prefix_size + name_size + 1; 90 } else { 91 /* no handler or insuffficient privileges, so skip */ 92 err = squashfs_read_metadata(sb, NULL, &start, 93 &offset, name_size); 94 if (err < 0) 95 goto failed; 96 } 97 98 99 /* skip remaining xattr entry */ 100 err = squashfs_read_metadata(sb, &val, &start, &offset, 101 sizeof(val)); 102 if (err < 0) 103 goto failed; 104 105 err = squashfs_read_metadata(sb, NULL, &start, &offset, 106 le32_to_cpu(val.vsize)); 107 if (err < 0) 108 goto failed; 109 } 110 err = buffer_size - rest; 111 112 failed: 113 return err; 114 } 115 116 117 static int squashfs_xattr_get(struct inode *inode, int name_index, 118 const char *name, void *buffer, size_t buffer_size) 119 { 120 struct super_block *sb = inode->i_sb; 121 struct squashfs_sb_info *msblk = sb->s_fs_info; 122 u64 start = SQUASHFS_XATTR_BLK(squashfs_i(inode)->xattr) 123 + msblk->xattr_table; 124 int offset = SQUASHFS_XATTR_OFFSET(squashfs_i(inode)->xattr); 125 int count = squashfs_i(inode)->xattr_count; 126 int name_len = strlen(name); 127 int err, vsize; 128 char *target = kmalloc(name_len, GFP_KERNEL); 129 130 if (target == NULL) 131 return -ENOMEM; 132 133 /* loop reading each xattr name */ 134 for (; count; count--) { 135 struct squashfs_xattr_entry entry; 136 struct squashfs_xattr_val val; 137 int type, prefix, name_size; 138 139 err = squashfs_read_metadata(sb, &entry, &start, &offset, 140 sizeof(entry)); 141 if (err < 0) 142 goto failed; 143 144 name_size = le16_to_cpu(entry.size); 145 type = le16_to_cpu(entry.type); 146 prefix = type & SQUASHFS_XATTR_PREFIX_MASK; 147 148 if (prefix == name_index && name_size == name_len) 149 err = squashfs_read_metadata(sb, target, &start, 150 &offset, name_size); 151 else 152 err = squashfs_read_metadata(sb, NULL, &start, 153 &offset, name_size); 154 if (err < 0) 155 goto failed; 156 157 if (prefix == name_index && name_size == name_len && 158 strncmp(target, name, name_size) == 0) { 159 /* found xattr */ 160 if (type & SQUASHFS_XATTR_VALUE_OOL) { 161 __le64 xattr; 162 /* val is a reference to the real location */ 163 err = squashfs_read_metadata(sb, &val, &start, 164 &offset, sizeof(val)); 165 if (err < 0) 166 goto failed; 167 err = squashfs_read_metadata(sb, &xattr, &start, 168 &offset, sizeof(xattr)); 169 if (err < 0) 170 goto failed; 171 xattr = le64_to_cpu(xattr); 172 start = SQUASHFS_XATTR_BLK(xattr) + 173 msblk->xattr_table; 174 offset = SQUASHFS_XATTR_OFFSET(xattr); 175 } 176 /* read xattr value */ 177 err = squashfs_read_metadata(sb, &val, &start, &offset, 178 sizeof(val)); 179 if (err < 0) 180 goto failed; 181 182 vsize = le32_to_cpu(val.vsize); 183 if (buffer) { 184 if (vsize > buffer_size) { 185 err = -ERANGE; 186 goto failed; 187 } 188 err = squashfs_read_metadata(sb, buffer, &start, 189 &offset, vsize); 190 if (err < 0) 191 goto failed; 192 } 193 break; 194 } 195 196 /* no match, skip remaining xattr entry */ 197 err = squashfs_read_metadata(sb, &val, &start, &offset, 198 sizeof(val)); 199 if (err < 0) 200 goto failed; 201 err = squashfs_read_metadata(sb, NULL, &start, &offset, 202 le32_to_cpu(val.vsize)); 203 if (err < 0) 204 goto failed; 205 } 206 err = count ? vsize : -ENODATA; 207 208 failed: 209 kfree(target); 210 return err; 211 } 212 213 214 /* 215 * User namespace support 216 */ 217 static size_t squashfs_user_list(struct dentry *d, char *list, size_t list_size, 218 const char *name, size_t name_len, int type) 219 { 220 if (list && XATTR_USER_PREFIX_LEN <= list_size) 221 memcpy(list, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN); 222 return XATTR_USER_PREFIX_LEN; 223 } 224 225 static int squashfs_user_get(struct dentry *d, const char *name, void *buffer, 226 size_t size, int type) 227 { 228 if (name[0] == '\0') 229 return -EINVAL; 230 231 return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_USER, name, 232 buffer, size); 233 } 234 235 static const struct xattr_handler squashfs_xattr_user_handler = { 236 .prefix = XATTR_USER_PREFIX, 237 .list = squashfs_user_list, 238 .get = squashfs_user_get 239 }; 240 241 /* 242 * Trusted namespace support 243 */ 244 static size_t squashfs_trusted_list(struct dentry *d, char *list, 245 size_t list_size, const char *name, size_t name_len, int type) 246 { 247 if (!capable(CAP_SYS_ADMIN)) 248 return 0; 249 250 if (list && XATTR_TRUSTED_PREFIX_LEN <= list_size) 251 memcpy(list, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN); 252 return XATTR_TRUSTED_PREFIX_LEN; 253 } 254 255 static int squashfs_trusted_get(struct dentry *d, const char *name, 256 void *buffer, size_t size, int type) 257 { 258 if (name[0] == '\0') 259 return -EINVAL; 260 261 return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_TRUSTED, name, 262 buffer, size); 263 } 264 265 static const struct xattr_handler squashfs_xattr_trusted_handler = { 266 .prefix = XATTR_TRUSTED_PREFIX, 267 .list = squashfs_trusted_list, 268 .get = squashfs_trusted_get 269 }; 270 271 /* 272 * Security namespace support 273 */ 274 static size_t squashfs_security_list(struct dentry *d, char *list, 275 size_t list_size, const char *name, size_t name_len, int type) 276 { 277 if (list && XATTR_SECURITY_PREFIX_LEN <= list_size) 278 memcpy(list, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN); 279 return XATTR_SECURITY_PREFIX_LEN; 280 } 281 282 static int squashfs_security_get(struct dentry *d, const char *name, 283 void *buffer, size_t size, int type) 284 { 285 if (name[0] == '\0') 286 return -EINVAL; 287 288 return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_SECURITY, name, 289 buffer, size); 290 } 291 292 static const struct xattr_handler squashfs_xattr_security_handler = { 293 .prefix = XATTR_SECURITY_PREFIX, 294 .list = squashfs_security_list, 295 .get = squashfs_security_get 296 }; 297 298 static const struct xattr_handler *squashfs_xattr_handler(int type) 299 { 300 if (type & ~(SQUASHFS_XATTR_PREFIX_MASK | SQUASHFS_XATTR_VALUE_OOL)) 301 /* ignore unrecognised type */ 302 return NULL; 303 304 switch (type & SQUASHFS_XATTR_PREFIX_MASK) { 305 case SQUASHFS_XATTR_USER: 306 return &squashfs_xattr_user_handler; 307 case SQUASHFS_XATTR_TRUSTED: 308 return &squashfs_xattr_trusted_handler; 309 case SQUASHFS_XATTR_SECURITY: 310 return &squashfs_xattr_security_handler; 311 default: 312 /* ignore unrecognised type */ 313 return NULL; 314 } 315 } 316 317 const struct xattr_handler *squashfs_xattr_handlers[] = { 318 &squashfs_xattr_user_handler, 319 &squashfs_xattr_trusted_handler, 320 &squashfs_xattr_security_handler, 321 NULL 322 }; 323 324