1 // SPDX-License-Identifier: LGPL-2.1 2 /* 3 * 4 * Copyright (c) International Business Machines Corp., 2003, 2007 5 * Author(s): Steve French (sfrench@us.ibm.com) 6 * 7 */ 8 9 #include <linux/fs.h> 10 #include <linux/posix_acl_xattr.h> 11 #include <linux/slab.h> 12 #include <linux/xattr.h> 13 #include "cifsfs.h" 14 #include "cifspdu.h" 15 #include "cifsglob.h" 16 #include "cifsproto.h" 17 #include "cifs_debug.h" 18 #include "cifs_fs_sb.h" 19 #include "cifs_unicode.h" 20 #include "cifs_ioctl.h" 21 22 #define MAX_EA_VALUE_SIZE CIFSMaxBufSize 23 #define CIFS_XATTR_CIFS_ACL "system.cifs_acl" /* DACL only */ 24 #define CIFS_XATTR_CIFS_NTSD "system.cifs_ntsd" /* owner plus DACL */ 25 #define CIFS_XATTR_CIFS_NTSD_FULL "system.cifs_ntsd_full" /* owner/DACL/SACL */ 26 #define CIFS_XATTR_ATTRIB "cifs.dosattrib" /* full name: user.cifs.dosattrib */ 27 #define CIFS_XATTR_CREATETIME "cifs.creationtime" /* user.cifs.creationtime */ 28 /* 29 * Although these three are just aliases for the above, need to move away from 30 * confusing users and using the 20+ year old term 'cifs' when it is no longer 31 * secure, replaced by SMB2 (then even more highly secure SMB3) many years ago 32 */ 33 #define SMB3_XATTR_CIFS_ACL "system.smb3_acl" /* DACL only */ 34 #define SMB3_XATTR_CIFS_NTSD "system.smb3_ntsd" /* owner plus DACL */ 35 #define SMB3_XATTR_CIFS_NTSD_FULL "system.smb3_ntsd_full" /* owner/DACL/SACL */ 36 #define SMB3_XATTR_ATTRIB "smb3.dosattrib" /* full name: user.smb3.dosattrib */ 37 #define SMB3_XATTR_CREATETIME "smb3.creationtime" /* user.smb3.creationtime */ 38 /* BB need to add server (Samba e.g) support for security and trusted prefix */ 39 40 enum { XATTR_USER, XATTR_CIFS_ACL, XATTR_ACL_ACCESS, XATTR_ACL_DEFAULT, 41 XATTR_CIFS_NTSD, XATTR_CIFS_NTSD_FULL }; 42 43 static int cifs_attrib_set(unsigned int xid, struct cifs_tcon *pTcon, 44 struct inode *inode, const char *full_path, 45 const void *value, size_t size) 46 { 47 ssize_t rc = -EOPNOTSUPP; 48 __u32 *pattrib = (__u32 *)value; 49 __u32 attrib; 50 FILE_BASIC_INFO info_buf; 51 52 if ((value == NULL) || (size != sizeof(__u32))) 53 return -ERANGE; 54 55 memset(&info_buf, 0, sizeof(info_buf)); 56 attrib = *pattrib; 57 info_buf.Attributes = cpu_to_le32(attrib); 58 if (pTcon->ses->server->ops->set_file_info) 59 rc = pTcon->ses->server->ops->set_file_info(inode, full_path, 60 &info_buf, xid); 61 if (rc == 0) 62 CIFS_I(inode)->cifsAttrs = attrib; 63 64 return rc; 65 } 66 67 static int cifs_creation_time_set(unsigned int xid, struct cifs_tcon *pTcon, 68 struct inode *inode, const char *full_path, 69 const void *value, size_t size) 70 { 71 ssize_t rc = -EOPNOTSUPP; 72 __u64 *pcreation_time = (__u64 *)value; 73 __u64 creation_time; 74 FILE_BASIC_INFO info_buf; 75 76 if ((value == NULL) || (size != sizeof(__u64))) 77 return -ERANGE; 78 79 memset(&info_buf, 0, sizeof(info_buf)); 80 creation_time = *pcreation_time; 81 info_buf.CreationTime = cpu_to_le64(creation_time); 82 if (pTcon->ses->server->ops->set_file_info) 83 rc = pTcon->ses->server->ops->set_file_info(inode, full_path, 84 &info_buf, xid); 85 if (rc == 0) 86 CIFS_I(inode)->createtime = creation_time; 87 88 return rc; 89 } 90 91 static int cifs_xattr_set(const struct xattr_handler *handler, 92 struct mnt_idmap *idmap, 93 struct dentry *dentry, struct inode *inode, 94 const char *name, const void *value, 95 size_t size, int flags) 96 { 97 int rc = -EOPNOTSUPP; 98 unsigned int xid; 99 struct super_block *sb = dentry->d_sb; 100 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 101 struct tcon_link *tlink; 102 struct cifs_tcon *pTcon; 103 const char *full_path; 104 void *page; 105 106 tlink = cifs_sb_tlink(cifs_sb); 107 if (IS_ERR(tlink)) 108 return PTR_ERR(tlink); 109 pTcon = tlink_tcon(tlink); 110 111 xid = get_xid(); 112 page = alloc_dentry_path(); 113 114 full_path = build_path_from_dentry(dentry, page); 115 if (IS_ERR(full_path)) { 116 rc = PTR_ERR(full_path); 117 goto out; 118 } 119 /* return dos attributes as pseudo xattr */ 120 /* return alt name if available as pseudo attr */ 121 122 /* if proc/fs/cifs/streamstoxattr is set then 123 search server for EAs or streams to 124 returns as xattrs */ 125 if (size > MAX_EA_VALUE_SIZE) { 126 cifs_dbg(FYI, "size of EA value too large\n"); 127 rc = -EOPNOTSUPP; 128 goto out; 129 } 130 131 switch (handler->flags) { 132 case XATTR_USER: 133 cifs_dbg(FYI, "%s:setting user xattr %s\n", __func__, name); 134 if ((strcmp(name, CIFS_XATTR_ATTRIB) == 0) || 135 (strcmp(name, SMB3_XATTR_ATTRIB) == 0)) { 136 rc = cifs_attrib_set(xid, pTcon, inode, full_path, 137 value, size); 138 if (rc == 0) /* force revalidate of the inode */ 139 CIFS_I(inode)->time = 0; 140 break; 141 } else if ((strcmp(name, CIFS_XATTR_CREATETIME) == 0) || 142 (strcmp(name, SMB3_XATTR_CREATETIME) == 0)) { 143 rc = cifs_creation_time_set(xid, pTcon, inode, 144 full_path, value, size); 145 if (rc == 0) /* force revalidate of the inode */ 146 CIFS_I(inode)->time = 0; 147 break; 148 } 149 150 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) 151 goto out; 152 153 if (pTcon->ses->server->ops->set_EA) 154 rc = pTcon->ses->server->ops->set_EA(xid, pTcon, 155 full_path, name, value, (__u16)size, 156 cifs_sb->local_nls, cifs_sb); 157 break; 158 159 case XATTR_CIFS_ACL: 160 case XATTR_CIFS_NTSD: 161 case XATTR_CIFS_NTSD_FULL: { 162 struct cifs_ntsd *pacl; 163 164 if (!value) 165 goto out; 166 pacl = kmalloc(size, GFP_KERNEL); 167 if (!pacl) { 168 rc = -ENOMEM; 169 } else { 170 memcpy(pacl, value, size); 171 if (pTcon->ses->server->ops->set_acl) { 172 int aclflags = 0; 173 rc = 0; 174 175 switch (handler->flags) { 176 case XATTR_CIFS_NTSD_FULL: 177 aclflags = (CIFS_ACL_OWNER | 178 CIFS_ACL_GROUP | 179 CIFS_ACL_DACL | 180 CIFS_ACL_SACL); 181 break; 182 case XATTR_CIFS_NTSD: 183 aclflags = (CIFS_ACL_OWNER | 184 CIFS_ACL_GROUP | 185 CIFS_ACL_DACL); 186 break; 187 case XATTR_CIFS_ACL: 188 default: 189 aclflags = CIFS_ACL_DACL; 190 } 191 192 rc = pTcon->ses->server->ops->set_acl(pacl, 193 size, inode, full_path, aclflags); 194 } else { 195 rc = -EOPNOTSUPP; 196 } 197 if (rc == 0) /* force revalidate of the inode */ 198 CIFS_I(inode)->time = 0; 199 kfree(pacl); 200 } 201 break; 202 } 203 } 204 205 out: 206 free_dentry_path(page); 207 free_xid(xid); 208 cifs_put_tlink(tlink); 209 return rc; 210 } 211 212 static int cifs_attrib_get(struct dentry *dentry, 213 struct inode *inode, void *value, 214 size_t size) 215 { 216 ssize_t rc; 217 __u32 *pattribute; 218 219 rc = cifs_revalidate_dentry_attr(dentry); 220 221 if (rc) 222 return rc; 223 224 if ((value == NULL) || (size == 0)) 225 return sizeof(__u32); 226 else if (size < sizeof(__u32)) 227 return -ERANGE; 228 229 /* return dos attributes as pseudo xattr */ 230 pattribute = (__u32 *)value; 231 *pattribute = CIFS_I(inode)->cifsAttrs; 232 233 return sizeof(__u32); 234 } 235 236 static int cifs_creation_time_get(struct dentry *dentry, struct inode *inode, 237 void *value, size_t size) 238 { 239 ssize_t rc; 240 __u64 *pcreatetime; 241 242 rc = cifs_revalidate_dentry_attr(dentry); 243 if (rc) 244 return rc; 245 246 if ((value == NULL) || (size == 0)) 247 return sizeof(__u64); 248 else if (size < sizeof(__u64)) 249 return -ERANGE; 250 251 /* return dos attributes as pseudo xattr */ 252 pcreatetime = (__u64 *)value; 253 *pcreatetime = CIFS_I(inode)->createtime; 254 return sizeof(__u64); 255 } 256 257 258 static int cifs_xattr_get(const struct xattr_handler *handler, 259 struct dentry *dentry, struct inode *inode, 260 const char *name, void *value, size_t size) 261 { 262 ssize_t rc = -EOPNOTSUPP; 263 unsigned int xid; 264 struct super_block *sb = dentry->d_sb; 265 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 266 struct tcon_link *tlink; 267 struct cifs_tcon *pTcon; 268 const char *full_path; 269 void *page; 270 271 tlink = cifs_sb_tlink(cifs_sb); 272 if (IS_ERR(tlink)) 273 return PTR_ERR(tlink); 274 pTcon = tlink_tcon(tlink); 275 276 xid = get_xid(); 277 page = alloc_dentry_path(); 278 279 full_path = build_path_from_dentry(dentry, page); 280 if (IS_ERR(full_path)) { 281 rc = PTR_ERR(full_path); 282 goto out; 283 } 284 285 /* return alt name if available as pseudo attr */ 286 switch (handler->flags) { 287 case XATTR_USER: 288 cifs_dbg(FYI, "%s:querying user xattr %s\n", __func__, name); 289 if ((strcmp(name, CIFS_XATTR_ATTRIB) == 0) || 290 (strcmp(name, SMB3_XATTR_ATTRIB) == 0)) { 291 rc = cifs_attrib_get(dentry, inode, value, size); 292 break; 293 } else if ((strcmp(name, CIFS_XATTR_CREATETIME) == 0) || 294 (strcmp(name, SMB3_XATTR_CREATETIME) == 0)) { 295 rc = cifs_creation_time_get(dentry, inode, value, size); 296 break; 297 } 298 299 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) 300 goto out; 301 302 if (pTcon->ses->server->ops->query_all_EAs) 303 rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, 304 full_path, name, value, size, cifs_sb); 305 break; 306 307 case XATTR_CIFS_ACL: 308 case XATTR_CIFS_NTSD: 309 case XATTR_CIFS_NTSD_FULL: { 310 /* 311 * fetch owner, DACL, and SACL if asked for full descriptor, 312 * fetch owner and DACL otherwise 313 */ 314 u32 acllen, extra_info; 315 struct cifs_ntsd *pacl; 316 317 if (pTcon->ses->server->ops->get_acl == NULL) 318 goto out; /* rc already EOPNOTSUPP */ 319 320 if (handler->flags == XATTR_CIFS_NTSD_FULL) { 321 extra_info = SACL_SECINFO; 322 } else { 323 extra_info = 0; 324 } 325 pacl = pTcon->ses->server->ops->get_acl(cifs_sb, 326 inode, full_path, &acllen, extra_info); 327 if (IS_ERR(pacl)) { 328 rc = PTR_ERR(pacl); 329 cifs_dbg(VFS, "%s: error %zd getting sec desc\n", 330 __func__, rc); 331 } else { 332 if (value) { 333 if (acllen > size) 334 acllen = -ERANGE; 335 else 336 memcpy(value, pacl, acllen); 337 } 338 rc = acllen; 339 kfree(pacl); 340 } 341 break; 342 } 343 } 344 345 /* We could add an additional check for streams ie 346 if proc/fs/cifs/streamstoxattr is set then 347 search server for EAs or streams to 348 returns as xattrs */ 349 350 if (rc == -EINVAL) 351 rc = -EOPNOTSUPP; 352 353 out: 354 free_dentry_path(page); 355 free_xid(xid); 356 cifs_put_tlink(tlink); 357 return rc; 358 } 359 360 ssize_t cifs_listxattr(struct dentry *direntry, char *data, size_t buf_size) 361 { 362 ssize_t rc = -EOPNOTSUPP; 363 unsigned int xid; 364 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb); 365 struct tcon_link *tlink; 366 struct cifs_tcon *pTcon; 367 const char *full_path; 368 void *page; 369 370 if (unlikely(cifs_forced_shutdown(cifs_sb))) 371 return -EIO; 372 373 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR) 374 return -EOPNOTSUPP; 375 376 tlink = cifs_sb_tlink(cifs_sb); 377 if (IS_ERR(tlink)) 378 return PTR_ERR(tlink); 379 pTcon = tlink_tcon(tlink); 380 381 xid = get_xid(); 382 page = alloc_dentry_path(); 383 384 full_path = build_path_from_dentry(direntry, page); 385 if (IS_ERR(full_path)) { 386 rc = PTR_ERR(full_path); 387 goto list_ea_exit; 388 } 389 /* return dos attributes as pseudo xattr */ 390 /* return alt name if available as pseudo attr */ 391 392 /* if proc/fs/cifs/streamstoxattr is set then 393 search server for EAs or streams to 394 returns as xattrs */ 395 396 if (pTcon->ses->server->ops->query_all_EAs) 397 rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, 398 full_path, NULL, data, buf_size, cifs_sb); 399 list_ea_exit: 400 free_dentry_path(page); 401 free_xid(xid); 402 cifs_put_tlink(tlink); 403 return rc; 404 } 405 406 static const struct xattr_handler cifs_user_xattr_handler = { 407 .prefix = XATTR_USER_PREFIX, 408 .flags = XATTR_USER, 409 .get = cifs_xattr_get, 410 .set = cifs_xattr_set, 411 }; 412 413 /* os2.* attributes are treated like user.* attributes */ 414 static const struct xattr_handler cifs_os2_xattr_handler = { 415 .prefix = XATTR_OS2_PREFIX, 416 .flags = XATTR_USER, 417 .get = cifs_xattr_get, 418 .set = cifs_xattr_set, 419 }; 420 421 static const struct xattr_handler cifs_cifs_acl_xattr_handler = { 422 .name = CIFS_XATTR_CIFS_ACL, 423 .flags = XATTR_CIFS_ACL, 424 .get = cifs_xattr_get, 425 .set = cifs_xattr_set, 426 }; 427 428 /* 429 * Although this is just an alias for the above, need to move away from 430 * confusing users and using the 20 year old term 'cifs' when it is no 431 * longer secure and was replaced by SMB2/SMB3 a long time ago, and 432 * SMB3 and later are highly secure. 433 */ 434 static const struct xattr_handler smb3_acl_xattr_handler = { 435 .name = SMB3_XATTR_CIFS_ACL, 436 .flags = XATTR_CIFS_ACL, 437 .get = cifs_xattr_get, 438 .set = cifs_xattr_set, 439 }; 440 441 static const struct xattr_handler cifs_cifs_ntsd_xattr_handler = { 442 .name = CIFS_XATTR_CIFS_NTSD, 443 .flags = XATTR_CIFS_NTSD, 444 .get = cifs_xattr_get, 445 .set = cifs_xattr_set, 446 }; 447 448 /* 449 * Although this is just an alias for the above, need to move away from 450 * confusing users and using the 20 year old term 'cifs' when it is no 451 * longer secure and was replaced by SMB2/SMB3 a long time ago, and 452 * SMB3 and later are highly secure. 453 */ 454 static const struct xattr_handler smb3_ntsd_xattr_handler = { 455 .name = SMB3_XATTR_CIFS_NTSD, 456 .flags = XATTR_CIFS_NTSD, 457 .get = cifs_xattr_get, 458 .set = cifs_xattr_set, 459 }; 460 461 static const struct xattr_handler cifs_cifs_ntsd_full_xattr_handler = { 462 .name = CIFS_XATTR_CIFS_NTSD_FULL, 463 .flags = XATTR_CIFS_NTSD_FULL, 464 .get = cifs_xattr_get, 465 .set = cifs_xattr_set, 466 }; 467 468 /* 469 * Although this is just an alias for the above, need to move away from 470 * confusing users and using the 20 year old term 'cifs' when it is no 471 * longer secure and was replaced by SMB2/SMB3 a long time ago, and 472 * SMB3 and later are highly secure. 473 */ 474 static const struct xattr_handler smb3_ntsd_full_xattr_handler = { 475 .name = SMB3_XATTR_CIFS_NTSD_FULL, 476 .flags = XATTR_CIFS_NTSD_FULL, 477 .get = cifs_xattr_get, 478 .set = cifs_xattr_set, 479 }; 480 481 const struct xattr_handler *cifs_xattr_handlers[] = { 482 &cifs_user_xattr_handler, 483 &cifs_os2_xattr_handler, 484 &cifs_cifs_acl_xattr_handler, 485 &smb3_acl_xattr_handler, /* alias for above since avoiding "cifs" */ 486 &cifs_cifs_ntsd_xattr_handler, 487 &smb3_ntsd_xattr_handler, /* alias for above since avoiding "cifs" */ 488 &cifs_cifs_ntsd_full_xattr_handler, 489 &smb3_ntsd_full_xattr_handler, /* alias for above since avoiding "cifs" */ 490 NULL 491 }; 492