1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2024 Paulo Alcantara <pc@manguebit.com> 4 */ 5 6 #include <linux/fs.h> 7 #include <linux/stat.h> 8 #include <linux/slab.h> 9 #include "cifsglob.h" 10 #include "smb2proto.h" 11 #include "cifsproto.h" 12 #include "cifs_unicode.h" 13 #include "cifs_debug.h" 14 #include "fs_context.h" 15 #include "reparse.h" 16 17 static int mknod_nfs(unsigned int xid, struct inode *inode, 18 struct dentry *dentry, struct cifs_tcon *tcon, 19 const char *full_path, umode_t mode, dev_t dev, 20 const char *symname); 21 22 static int mknod_wsl(unsigned int xid, struct inode *inode, 23 struct dentry *dentry, struct cifs_tcon *tcon, 24 const char *full_path, umode_t mode, dev_t dev, 25 const char *symname); 26 27 static int create_native_symlink(const unsigned int xid, struct inode *inode, 28 struct dentry *dentry, struct cifs_tcon *tcon, 29 const char *full_path, const char *symname); 30 31 static int detect_directory_symlink_target(struct cifs_sb_info *cifs_sb, 32 const unsigned int xid, 33 const char *full_path, 34 const char *symname, 35 bool *directory); 36 37 int smb2_create_reparse_symlink(const unsigned int xid, struct inode *inode, 38 struct dentry *dentry, struct cifs_tcon *tcon, 39 const char *full_path, const char *symname) 40 { 41 switch (get_cifs_symlink_type(CIFS_SB(inode->i_sb))) { 42 case CIFS_SYMLINK_TYPE_NATIVE: 43 return create_native_symlink(xid, inode, dentry, tcon, full_path, symname); 44 case CIFS_SYMLINK_TYPE_NFS: 45 return mknod_nfs(xid, inode, dentry, tcon, full_path, S_IFLNK, 0, symname); 46 case CIFS_SYMLINK_TYPE_WSL: 47 return mknod_wsl(xid, inode, dentry, tcon, full_path, S_IFLNK, 0, symname); 48 default: 49 return -EOPNOTSUPP; 50 } 51 } 52 53 static int create_native_symlink(const unsigned int xid, struct inode *inode, 54 struct dentry *dentry, struct cifs_tcon *tcon, 55 const char *full_path, const char *symname) 56 { 57 struct reparse_symlink_data_buffer *buf = NULL; 58 struct cifs_open_info_data data = {}; 59 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 60 struct inode *new; 61 struct kvec iov; 62 __le16 *path = NULL; 63 bool directory; 64 char *symlink_target = NULL; 65 char *sym = NULL; 66 char sep = CIFS_DIR_SEP(cifs_sb); 67 u16 len, plen, poff, slen; 68 int rc = 0; 69 70 if (strlen(symname) > REPARSE_SYM_PATH_MAX) 71 return -ENAMETOOLONG; 72 73 symlink_target = kstrdup(symname, GFP_KERNEL); 74 if (!symlink_target) { 75 rc = -ENOMEM; 76 goto out; 77 } 78 79 data = (struct cifs_open_info_data) { 80 .reparse_point = true, 81 .reparse = { .tag = IO_REPARSE_TAG_SYMLINK, }, 82 .symlink_target = symlink_target, 83 }; 84 85 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) && symname[0] == '/') { 86 /* 87 * This is a request to create an absolute symlink on the server 88 * which does not support POSIX paths, and expects symlink in 89 * NT-style path. So convert absolute Linux symlink target path 90 * to the absolute NT-style path. Root of the NT-style path for 91 * symlinks is specified in "symlinkroot" mount option. This will 92 * ensure compatibility of this symlink stored in absolute form 93 * on the SMB server. 94 */ 95 if (!strstarts(symname, cifs_sb->ctx->symlinkroot)) { 96 /* 97 * If the absolute Linux symlink target path is not 98 * inside "symlinkroot" location then there is no way 99 * to convert such Linux symlink to NT-style path. 100 */ 101 cifs_dbg(VFS, 102 "absolute symlink '%s' cannot be converted to NT format " 103 "because it is outside of symlinkroot='%s'\n", 104 symname, cifs_sb->ctx->symlinkroot); 105 rc = -EINVAL; 106 goto out; 107 } 108 len = strlen(cifs_sb->ctx->symlinkroot); 109 if (cifs_sb->ctx->symlinkroot[len-1] != '/') 110 len++; 111 if (symname[len] >= 'a' && symname[len] <= 'z' && 112 (symname[len+1] == '/' || symname[len+1] == '\0')) { 113 /* 114 * Symlink points to Linux target /symlinkroot/x/path/... 115 * where 'x' is the lowercase local Windows drive. 116 * NT-style path for 'x' has common form \??\X:\path\... 117 * with uppercase local Windows drive. 118 */ 119 int common_path_len = strlen(symname+len+1)+1; 120 sym = kzalloc(6+common_path_len, GFP_KERNEL); 121 if (!sym) { 122 rc = -ENOMEM; 123 goto out; 124 } 125 memcpy(sym, "\\??\\", 4); 126 sym[4] = symname[len] - ('a'-'A'); 127 sym[5] = ':'; 128 memcpy(sym+6, symname+len+1, common_path_len); 129 } else { 130 /* Unhandled absolute symlink. Report an error. */ 131 cifs_dbg( 132 VFS, 133 "absolute symlink '%s' cannot be converted to NT format " 134 "because it points to unknown target\n", 135 symname); 136 rc = -EINVAL; 137 goto out; 138 } 139 } else { 140 /* 141 * This is request to either create an absolute symlink on 142 * server which expects POSIX paths or it is an request to 143 * create a relative symlink from the current directory. 144 * These paths have same format as relative SMB symlinks, 145 * so no conversion is needed. So just take symname as-is. 146 */ 147 sym = kstrdup(symname, GFP_KERNEL); 148 if (!sym) { 149 rc = -ENOMEM; 150 goto out; 151 } 152 } 153 154 if (sep == '\\') 155 convert_delimiter(sym, sep); 156 157 /* 158 * For absolute NT symlinks it is required to pass also leading 159 * backslash and to not mangle NT object prefix "\\??\\" and not to 160 * mangle colon in drive letter. But cifs_convert_path_to_utf16() 161 * removes leading backslash and replaces '?' and ':'. So temporary 162 * mask these characters in NT object prefix by '_' and then change 163 * them back. 164 */ 165 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) && symname[0] == '/') 166 sym[0] = sym[1] = sym[2] = sym[5] = '_'; 167 168 path = cifs_convert_path_to_utf16(sym, cifs_sb); 169 if (!path) { 170 rc = -ENOMEM; 171 goto out; 172 } 173 174 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) && symname[0] == '/') { 175 sym[0] = '\\'; 176 sym[1] = sym[2] = '?'; 177 sym[5] = ':'; 178 path[0] = cpu_to_le16('\\'); 179 path[1] = path[2] = cpu_to_le16('?'); 180 path[5] = cpu_to_le16(':'); 181 } 182 183 /* 184 * SMB distinguish between symlink to directory and symlink to file. 185 * They cannot be exchanged (symlink of file type which points to 186 * directory cannot be resolved and vice-versa). Try to detect if 187 * the symlink target could be a directory or not. When detection 188 * fails then treat symlink as a file (non-directory) symlink. 189 */ 190 directory = false; 191 rc = detect_directory_symlink_target(cifs_sb, xid, full_path, symname, &directory); 192 if (rc < 0) 193 goto out; 194 195 slen = 2 * UniStrnlen((wchar_t *)path, REPARSE_SYM_PATH_MAX); 196 poff = 0; 197 plen = slen; 198 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) && symname[0] == '/') { 199 /* 200 * For absolute NT symlinks skip leading "\\??\\" in PrintName as 201 * PrintName is user visible location in DOS/Win32 format (not in NT format). 202 */ 203 poff = 4; 204 plen -= 2 * poff; 205 } 206 len = sizeof(*buf) + plen + slen; 207 buf = kzalloc(len, GFP_KERNEL); 208 if (!buf) { 209 rc = -ENOMEM; 210 goto out; 211 } 212 213 buf->ReparseTag = cpu_to_le32(IO_REPARSE_TAG_SYMLINK); 214 buf->ReparseDataLength = cpu_to_le16(len - sizeof(struct reparse_data_buffer)); 215 216 buf->SubstituteNameOffset = cpu_to_le16(plen); 217 buf->SubstituteNameLength = cpu_to_le16(slen); 218 memcpy(&buf->PathBuffer[plen], path, slen); 219 220 buf->PrintNameOffset = 0; 221 buf->PrintNameLength = cpu_to_le16(plen); 222 memcpy(buf->PathBuffer, path+poff, plen); 223 224 buf->Flags = cpu_to_le32(*symname != '/' ? SYMLINK_FLAG_RELATIVE : 0); 225 226 iov.iov_base = buf; 227 iov.iov_len = len; 228 new = smb2_get_reparse_inode(&data, inode->i_sb, xid, 229 tcon, full_path, directory, 230 &iov, NULL); 231 if (!IS_ERR(new)) 232 d_instantiate(dentry, new); 233 else 234 rc = PTR_ERR(new); 235 out: 236 kfree(sym); 237 kfree(path); 238 cifs_free_open_info(&data); 239 kfree(buf); 240 return rc; 241 } 242 243 static int detect_directory_symlink_target(struct cifs_sb_info *cifs_sb, 244 const unsigned int xid, 245 const char *full_path, 246 const char *symname, 247 bool *directory) 248 { 249 char sep = CIFS_DIR_SEP(cifs_sb); 250 struct cifs_open_parms oparms; 251 struct tcon_link *tlink; 252 struct cifs_tcon *tcon; 253 const char *basename; 254 struct cifs_fid fid; 255 char *resolved_path; 256 int full_path_len; 257 int basename_len; 258 int symname_len; 259 char *path_sep; 260 __u32 oplock; 261 int open_rc; 262 263 /* 264 * First do some simple check. If the original Linux symlink target ends 265 * with slash, or last path component is dot or dot-dot then it is for 266 * sure symlink to the directory. 267 */ 268 basename = kbasename(symname); 269 basename_len = strlen(basename); 270 if (basename_len == 0 || /* symname ends with slash */ 271 (basename_len == 1 && basename[0] == '.') || /* last component is "." */ 272 (basename_len == 2 && basename[0] == '.' && basename[1] == '.')) { /* or ".." */ 273 *directory = true; 274 return 0; 275 } 276 277 /* 278 * For absolute symlinks it is not possible to determinate 279 * if it should point to directory or file. 280 */ 281 if (symname[0] == '/') { 282 cifs_dbg(FYI, 283 "%s: cannot determinate if the symlink target path '%s' " 284 "is directory or not, creating '%s' as file symlink\n", 285 __func__, symname, full_path); 286 return 0; 287 } 288 289 /* 290 * If it was not detected as directory yet and the symlink is relative 291 * then try to resolve the path on the SMB server, check if the path 292 * exists and determinate if it is a directory or not. 293 */ 294 295 full_path_len = strlen(full_path); 296 symname_len = strlen(symname); 297 298 tlink = cifs_sb_tlink(cifs_sb); 299 if (IS_ERR(tlink)) 300 return PTR_ERR(tlink); 301 302 resolved_path = kzalloc(full_path_len + symname_len + 1, GFP_KERNEL); 303 if (!resolved_path) { 304 cifs_put_tlink(tlink); 305 return -ENOMEM; 306 } 307 308 /* 309 * Compose the resolved SMB symlink path from the SMB full path 310 * and Linux target symlink path. 311 */ 312 memcpy(resolved_path, full_path, full_path_len+1); 313 path_sep = strrchr(resolved_path, sep); 314 if (path_sep) 315 path_sep++; 316 else 317 path_sep = resolved_path; 318 memcpy(path_sep, symname, symname_len+1); 319 if (sep == '\\') 320 convert_delimiter(path_sep, sep); 321 322 tcon = tlink_tcon(tlink); 323 oparms = CIFS_OPARMS(cifs_sb, tcon, resolved_path, 324 FILE_READ_ATTRIBUTES, FILE_OPEN, 0, ACL_NO_MODE); 325 oparms.fid = &fid; 326 327 /* Try to open as a directory (NOT_FILE) */ 328 oplock = 0; 329 oparms.create_options = cifs_create_options(cifs_sb, 330 CREATE_NOT_FILE | OPEN_REPARSE_POINT); 331 open_rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL); 332 if (open_rc == 0) { 333 /* Successful open means that the target path is definitely a directory. */ 334 *directory = true; 335 tcon->ses->server->ops->close(xid, tcon, &fid); 336 } else if (open_rc == -ENOTDIR) { 337 /* -ENOTDIR means that the target path is definitely a file. */ 338 *directory = false; 339 } else if (open_rc == -ENOENT) { 340 /* -ENOENT means that the target path does not exist. */ 341 cifs_dbg(FYI, 342 "%s: symlink target path '%s' does not exist, " 343 "creating '%s' as file symlink\n", 344 __func__, symname, full_path); 345 } else { 346 /* Try to open as a file (NOT_DIR) */ 347 oplock = 0; 348 oparms.create_options = cifs_create_options(cifs_sb, 349 CREATE_NOT_DIR | OPEN_REPARSE_POINT); 350 open_rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL); 351 if (open_rc == 0) { 352 /* Successful open means that the target path is definitely a file. */ 353 *directory = false; 354 tcon->ses->server->ops->close(xid, tcon, &fid); 355 } else if (open_rc == -EISDIR) { 356 /* -EISDIR means that the target path is definitely a directory. */ 357 *directory = true; 358 } else { 359 /* 360 * This code branch is called when we do not have a permission to 361 * open the resolved_path or some other client/process denied 362 * opening the resolved_path. 363 * 364 * TODO: Try to use ops->query_dir_first on the parent directory 365 * of resolved_path, search for basename of resolved_path and 366 * check if the ATTR_DIRECTORY is set in fi.Attributes. In some 367 * case this could work also when opening of the path is denied. 368 */ 369 cifs_dbg(FYI, 370 "%s: cannot determinate if the symlink target path '%s' " 371 "is directory or not, creating '%s' as file symlink\n", 372 __func__, symname, full_path); 373 } 374 } 375 376 kfree(resolved_path); 377 cifs_put_tlink(tlink); 378 return 0; 379 } 380 381 static int create_native_socket(const unsigned int xid, struct inode *inode, 382 struct dentry *dentry, struct cifs_tcon *tcon, 383 const char *full_path) 384 { 385 struct reparse_data_buffer buf = { 386 .ReparseTag = cpu_to_le32(IO_REPARSE_TAG_AF_UNIX), 387 .ReparseDataLength = cpu_to_le16(0), 388 }; 389 struct cifs_open_info_data data = { 390 .reparse_point = true, 391 .reparse = { .tag = IO_REPARSE_TAG_AF_UNIX, .buf = &buf, }, 392 }; 393 struct kvec iov = { 394 .iov_base = &buf, 395 .iov_len = sizeof(buf), 396 }; 397 struct inode *new; 398 int rc = 0; 399 400 new = smb2_get_reparse_inode(&data, inode->i_sb, xid, 401 tcon, full_path, false, &iov, NULL); 402 if (!IS_ERR(new)) 403 d_instantiate(dentry, new); 404 else 405 rc = PTR_ERR(new); 406 cifs_free_open_info(&data); 407 return rc; 408 } 409 410 static int nfs_set_reparse_buf(struct reparse_nfs_data_buffer *buf, 411 mode_t mode, dev_t dev, 412 __le16 *symname_utf16, 413 int symname_utf16_len, 414 struct kvec *iov) 415 { 416 u64 type; 417 u16 len, dlen; 418 419 len = sizeof(*buf); 420 421 switch ((type = reparse_mode_nfs_type(mode))) { 422 case NFS_SPECFILE_BLK: 423 case NFS_SPECFILE_CHR: 424 dlen = 2 * sizeof(__le32); 425 ((__le32 *)buf->DataBuffer)[0] = cpu_to_le32(MAJOR(dev)); 426 ((__le32 *)buf->DataBuffer)[1] = cpu_to_le32(MINOR(dev)); 427 break; 428 case NFS_SPECFILE_LNK: 429 dlen = symname_utf16_len; 430 memcpy(buf->DataBuffer, symname_utf16, symname_utf16_len); 431 break; 432 case NFS_SPECFILE_FIFO: 433 case NFS_SPECFILE_SOCK: 434 dlen = 0; 435 break; 436 default: 437 return -EOPNOTSUPP; 438 } 439 440 buf->ReparseTag = cpu_to_le32(IO_REPARSE_TAG_NFS); 441 buf->Reserved = 0; 442 buf->InodeType = cpu_to_le64(type); 443 buf->ReparseDataLength = cpu_to_le16(len + dlen - 444 sizeof(struct reparse_data_buffer)); 445 iov->iov_base = buf; 446 iov->iov_len = len + dlen; 447 return 0; 448 } 449 450 static int mknod_nfs(unsigned int xid, struct inode *inode, 451 struct dentry *dentry, struct cifs_tcon *tcon, 452 const char *full_path, umode_t mode, dev_t dev, 453 const char *symname) 454 { 455 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 456 struct cifs_open_info_data data; 457 struct reparse_nfs_data_buffer *p = NULL; 458 __le16 *symname_utf16 = NULL; 459 int symname_utf16_len = 0; 460 struct inode *new; 461 struct kvec iov; 462 __u8 buf[sizeof(*p) + sizeof(__le64)]; 463 int rc; 464 465 if (S_ISLNK(mode)) { 466 symname_utf16 = cifs_strndup_to_utf16(symname, strlen(symname), 467 &symname_utf16_len, 468 cifs_sb->local_nls, 469 NO_MAP_UNI_RSVD); 470 if (!symname_utf16) { 471 rc = -ENOMEM; 472 goto out; 473 } 474 symname_utf16_len -= 2; /* symlink is without trailing wide-nul */ 475 p = kzalloc(sizeof(*p) + symname_utf16_len, GFP_KERNEL); 476 if (!p) { 477 rc = -ENOMEM; 478 goto out; 479 } 480 } else { 481 p = (struct reparse_nfs_data_buffer *)buf; 482 } 483 rc = nfs_set_reparse_buf(p, mode, dev, symname_utf16, symname_utf16_len, &iov); 484 if (rc) 485 goto out; 486 487 data = (struct cifs_open_info_data) { 488 .reparse_point = true, 489 .reparse = { .tag = IO_REPARSE_TAG_NFS, .buf = (struct reparse_data_buffer *)p, }, 490 .symlink_target = kstrdup(symname, GFP_KERNEL), 491 }; 492 493 new = smb2_get_reparse_inode(&data, inode->i_sb, xid, 494 tcon, full_path, false, &iov, NULL); 495 if (!IS_ERR(new)) 496 d_instantiate(dentry, new); 497 else 498 rc = PTR_ERR(new); 499 cifs_free_open_info(&data); 500 out: 501 if (S_ISLNK(mode)) { 502 kfree(symname_utf16); 503 kfree(p); 504 } 505 return rc; 506 } 507 508 static int wsl_set_reparse_buf(struct reparse_data_buffer **buf, 509 mode_t mode, const char *symname, 510 struct cifs_sb_info *cifs_sb, 511 struct kvec *iov) 512 { 513 struct reparse_wsl_symlink_data_buffer *symlink_buf; 514 __le16 *symname_utf16; 515 int symname_utf16_len; 516 int symname_utf8_maxlen; 517 int symname_utf8_len; 518 size_t buf_len; 519 u32 tag; 520 521 switch ((tag = reparse_mode_wsl_tag(mode))) { 522 case IO_REPARSE_TAG_LX_BLK: 523 case IO_REPARSE_TAG_LX_CHR: 524 case IO_REPARSE_TAG_LX_FIFO: 525 case IO_REPARSE_TAG_AF_UNIX: 526 buf_len = sizeof(struct reparse_data_buffer); 527 *buf = kzalloc(buf_len, GFP_KERNEL); 528 if (!*buf) 529 return -ENOMEM; 530 break; 531 case IO_REPARSE_TAG_LX_SYMLINK: 532 symname_utf16 = cifs_strndup_to_utf16(symname, strlen(symname), 533 &symname_utf16_len, 534 cifs_sb->local_nls, 535 NO_MAP_UNI_RSVD); 536 if (!symname_utf16) 537 return -ENOMEM; 538 symname_utf8_maxlen = symname_utf16_len/2*3; 539 symlink_buf = kzalloc(sizeof(struct reparse_wsl_symlink_data_buffer) + 540 symname_utf8_maxlen, GFP_KERNEL); 541 if (!symlink_buf) { 542 kfree(symname_utf16); 543 return -ENOMEM; 544 } 545 /* Version field must be set to 2 (MS-FSCC 2.1.2.7) */ 546 symlink_buf->Version = cpu_to_le32(2); 547 /* Target for Version 2 is in UTF-8 but without trailing null-term byte */ 548 symname_utf8_len = utf16s_to_utf8s((wchar_t *)symname_utf16, symname_utf16_len/2, 549 UTF16_LITTLE_ENDIAN, 550 symlink_buf->Target, 551 symname_utf8_maxlen); 552 *buf = (struct reparse_data_buffer *)symlink_buf; 553 buf_len = sizeof(struct reparse_wsl_symlink_data_buffer) + symname_utf8_len; 554 kfree(symname_utf16); 555 break; 556 default: 557 return -EOPNOTSUPP; 558 } 559 560 (*buf)->ReparseTag = cpu_to_le32(tag); 561 (*buf)->Reserved = 0; 562 (*buf)->ReparseDataLength = cpu_to_le16(buf_len - sizeof(struct reparse_data_buffer)); 563 iov->iov_base = *buf; 564 iov->iov_len = buf_len; 565 return 0; 566 } 567 568 static struct smb2_create_ea_ctx *ea_create_context(u32 dlen, size_t *cc_len) 569 { 570 struct smb2_create_ea_ctx *cc; 571 572 *cc_len = round_up(sizeof(*cc) + dlen, 8); 573 cc = kzalloc(*cc_len, GFP_KERNEL); 574 if (!cc) 575 return ERR_PTR(-ENOMEM); 576 577 cc->ctx.NameOffset = cpu_to_le16(offsetof(struct smb2_create_ea_ctx, 578 name)); 579 cc->ctx.NameLength = cpu_to_le16(4); 580 memcpy(cc->name, SMB2_CREATE_EA_BUFFER, strlen(SMB2_CREATE_EA_BUFFER)); 581 cc->ctx.DataOffset = cpu_to_le16(offsetof(struct smb2_create_ea_ctx, ea)); 582 cc->ctx.DataLength = cpu_to_le32(dlen); 583 return cc; 584 } 585 586 struct wsl_xattr { 587 const char *name; 588 __le64 value; 589 u16 size; 590 u32 next; 591 }; 592 593 static int wsl_set_xattrs(struct inode *inode, umode_t _mode, 594 dev_t _dev, struct kvec *iov) 595 { 596 struct smb2_file_full_ea_info *ea; 597 struct smb2_create_ea_ctx *cc; 598 struct smb3_fs_context *ctx = CIFS_SB(inode->i_sb)->ctx; 599 __le64 uid = cpu_to_le64(from_kuid(current_user_ns(), ctx->linux_uid)); 600 __le64 gid = cpu_to_le64(from_kgid(current_user_ns(), ctx->linux_gid)); 601 __le64 dev = cpu_to_le64(((u64)MINOR(_dev) << 32) | MAJOR(_dev)); 602 __le64 mode = cpu_to_le64(_mode); 603 struct wsl_xattr xattrs[] = { 604 { .name = SMB2_WSL_XATTR_UID, .value = uid, .size = SMB2_WSL_XATTR_UID_SIZE, }, 605 { .name = SMB2_WSL_XATTR_GID, .value = gid, .size = SMB2_WSL_XATTR_GID_SIZE, }, 606 { .name = SMB2_WSL_XATTR_MODE, .value = mode, .size = SMB2_WSL_XATTR_MODE_SIZE, }, 607 { .name = SMB2_WSL_XATTR_DEV, .value = dev, .size = SMB2_WSL_XATTR_DEV_SIZE, }, 608 }; 609 size_t cc_len; 610 u32 dlen = 0, next = 0; 611 int i, num_xattrs; 612 u8 name_size = SMB2_WSL_XATTR_NAME_LEN + 1; 613 614 memset(iov, 0, sizeof(*iov)); 615 616 /* Exclude $LXDEV xattr for non-device files */ 617 if (!S_ISBLK(_mode) && !S_ISCHR(_mode)) 618 num_xattrs = ARRAY_SIZE(xattrs) - 1; 619 else 620 num_xattrs = ARRAY_SIZE(xattrs); 621 622 for (i = 0; i < num_xattrs; i++) { 623 xattrs[i].next = ALIGN(sizeof(*ea) + name_size + 624 xattrs[i].size, 4); 625 dlen += xattrs[i].next; 626 } 627 628 cc = ea_create_context(dlen, &cc_len); 629 if (IS_ERR(cc)) 630 return PTR_ERR(cc); 631 632 ea = &cc->ea; 633 for (i = 0; i < num_xattrs; i++) { 634 ea = (void *)((u8 *)ea + next); 635 next = xattrs[i].next; 636 ea->next_entry_offset = cpu_to_le32(next); 637 638 ea->ea_name_length = name_size - 1; 639 ea->ea_value_length = cpu_to_le16(xattrs[i].size); 640 memcpy(ea->ea_data, xattrs[i].name, name_size); 641 memcpy(&ea->ea_data[name_size], 642 &xattrs[i].value, xattrs[i].size); 643 } 644 ea->next_entry_offset = 0; 645 646 iov->iov_base = cc; 647 iov->iov_len = cc_len; 648 return 0; 649 } 650 651 static int mknod_wsl(unsigned int xid, struct inode *inode, 652 struct dentry *dentry, struct cifs_tcon *tcon, 653 const char *full_path, umode_t mode, dev_t dev, 654 const char *symname) 655 { 656 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 657 struct cifs_open_info_data data; 658 struct reparse_data_buffer *buf; 659 struct smb2_create_ea_ctx *cc; 660 struct inode *new; 661 unsigned int len; 662 struct kvec reparse_iov, xattr_iov; 663 int rc; 664 665 rc = wsl_set_reparse_buf(&buf, mode, symname, cifs_sb, &reparse_iov); 666 if (rc) 667 return rc; 668 669 rc = wsl_set_xattrs(inode, mode, dev, &xattr_iov); 670 if (rc) { 671 kfree(buf); 672 return rc; 673 } 674 675 data = (struct cifs_open_info_data) { 676 .reparse_point = true, 677 .reparse = { .tag = le32_to_cpu(buf->ReparseTag), .buf = buf, }, 678 .symlink_target = kstrdup(symname, GFP_KERNEL), 679 }; 680 681 cc = xattr_iov.iov_base; 682 len = le32_to_cpu(cc->ctx.DataLength); 683 memcpy(data.wsl.eas, &cc->ea, len); 684 data.wsl.eas_len = len; 685 686 new = smb2_get_reparse_inode(&data, inode->i_sb, 687 xid, tcon, full_path, false, 688 &reparse_iov, &xattr_iov); 689 if (!IS_ERR(new)) 690 d_instantiate(dentry, new); 691 else 692 rc = PTR_ERR(new); 693 cifs_free_open_info(&data); 694 kfree(xattr_iov.iov_base); 695 kfree(buf); 696 return rc; 697 } 698 699 int smb2_mknod_reparse(unsigned int xid, struct inode *inode, 700 struct dentry *dentry, struct cifs_tcon *tcon, 701 const char *full_path, umode_t mode, dev_t dev) 702 { 703 struct smb3_fs_context *ctx = CIFS_SB(inode->i_sb)->ctx; 704 705 if (S_ISSOCK(mode) && !ctx->nonativesocket && ctx->reparse_type != CIFS_REPARSE_TYPE_NONE) 706 return create_native_socket(xid, inode, dentry, tcon, full_path); 707 708 switch (ctx->reparse_type) { 709 case CIFS_REPARSE_TYPE_NFS: 710 return mknod_nfs(xid, inode, dentry, tcon, full_path, mode, dev, NULL); 711 case CIFS_REPARSE_TYPE_WSL: 712 return mknod_wsl(xid, inode, dentry, tcon, full_path, mode, dev, NULL); 713 default: 714 return -EOPNOTSUPP; 715 } 716 } 717 718 /* See MS-FSCC 2.1.2.6 for the 'NFS' style reparse tags */ 719 static int parse_reparse_nfs(struct reparse_nfs_data_buffer *buf, 720 struct cifs_sb_info *cifs_sb, 721 struct cifs_open_info_data *data) 722 { 723 unsigned int len; 724 u64 type; 725 726 len = le16_to_cpu(buf->ReparseDataLength); 727 if (len < sizeof(buf->InodeType)) { 728 cifs_dbg(VFS, "srv returned malformed nfs buffer\n"); 729 return -EIO; 730 } 731 732 len -= sizeof(buf->InodeType); 733 734 switch ((type = le64_to_cpu(buf->InodeType))) { 735 case NFS_SPECFILE_LNK: 736 if (len == 0 || (len % 2)) { 737 cifs_dbg(VFS, "srv returned malformed nfs symlink buffer\n"); 738 return -EIO; 739 } 740 /* 741 * Check that buffer does not contain UTF-16 null codepoint 742 * because Linux cannot process symlink with null byte. 743 */ 744 if (UniStrnlen((wchar_t *)buf->DataBuffer, len/2) != len/2) { 745 cifs_dbg(VFS, "srv returned null byte in nfs symlink target location\n"); 746 return -EIO; 747 } 748 data->symlink_target = cifs_strndup_from_utf16(buf->DataBuffer, 749 len, true, 750 cifs_sb->local_nls); 751 if (!data->symlink_target) 752 return -ENOMEM; 753 cifs_dbg(FYI, "%s: target path: %s\n", 754 __func__, data->symlink_target); 755 break; 756 case NFS_SPECFILE_CHR: 757 case NFS_SPECFILE_BLK: 758 /* DataBuffer for block and char devices contains two 32-bit numbers */ 759 if (len != 8) { 760 cifs_dbg(VFS, "srv returned malformed nfs buffer for type: 0x%llx\n", type); 761 return -EIO; 762 } 763 break; 764 case NFS_SPECFILE_FIFO: 765 case NFS_SPECFILE_SOCK: 766 /* DataBuffer for fifos and sockets is empty */ 767 if (len != 0) { 768 cifs_dbg(VFS, "srv returned malformed nfs buffer for type: 0x%llx\n", type); 769 return -EIO; 770 } 771 break; 772 default: 773 cifs_dbg(VFS, "%s: unhandled inode type: 0x%llx\n", 774 __func__, type); 775 return -EOPNOTSUPP; 776 } 777 return 0; 778 } 779 780 int smb2_parse_native_symlink(char **target, const char *buf, unsigned int len, 781 bool relative, 782 const char *full_path, 783 struct cifs_sb_info *cifs_sb) 784 { 785 char sep = CIFS_DIR_SEP(cifs_sb); 786 char *linux_target = NULL; 787 char *smb_target = NULL; 788 int symlinkroot_len; 789 int abs_path_len; 790 char *abs_path; 791 int levels; 792 int rc; 793 int i; 794 795 /* Check that length it valid */ 796 if (!len || (len % 2)) { 797 cifs_dbg(VFS, "srv returned malformed symlink buffer\n"); 798 rc = -EIO; 799 goto out; 800 } 801 802 /* 803 * Check that buffer does not contain UTF-16 null codepoint 804 * because Linux cannot process symlink with null byte. 805 */ 806 if (UniStrnlen((wchar_t *)buf, len/2) != len/2) { 807 cifs_dbg(VFS, "srv returned null byte in native symlink target location\n"); 808 rc = -EIO; 809 goto out; 810 } 811 812 smb_target = cifs_strndup_from_utf16(buf, len, true, cifs_sb->local_nls); 813 if (!smb_target) { 814 rc = -ENOMEM; 815 goto out; 816 } 817 818 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) && !relative) { 819 /* 820 * This is an absolute symlink from the server which does not 821 * support POSIX paths, so the symlink is in NT-style path. 822 * So convert it to absolute Linux symlink target path. Root of 823 * the NT-style path for symlinks is specified in "symlinkroot" 824 * mount option. 825 * 826 * Root of the DOS and Win32 paths is at NT path \??\ 827 * It means that DOS/Win32 path C:\folder\file.txt is 828 * NT path \??\C:\folder\file.txt 829 * 830 * NT systems have some well-known object symlinks in their NT 831 * hierarchy, which is needed to take into account when resolving 832 * other symlinks. Most commonly used symlink paths are: 833 * \?? -> \GLOBAL?? 834 * \DosDevices -> \?? 835 * \GLOBAL??\GLOBALROOT -> \ 836 * \GLOBAL??\Global -> \GLOBAL?? 837 * \GLOBAL??\NUL -> \Device\Null 838 * \GLOBAL??\UNC -> \Device\Mup 839 * \GLOBAL??\PhysicalDrive0 -> \Device\Harddisk0\DR0 (for each harddisk) 840 * \GLOBAL??\A: -> \Device\Floppy0 (if A: is the first floppy) 841 * \GLOBAL??\C: -> \Device\HarddiskVolume1 (if C: is the first harddisk) 842 * \GLOBAL??\D: -> \Device\CdRom0 (if D: is first cdrom) 843 * \SystemRoot -> \Device\Harddisk0\Partition1\WINDOWS (or where is NT system installed) 844 * \Volume{...} -> \Device\HarddiskVolume1 (where ... is system generated guid) 845 * 846 * In most common cases, absolute NT symlinks points to path on 847 * DOS/Win32 drive letter, system-specific Volume or on UNC share. 848 * Here are few examples of commonly used absolute NT symlinks 849 * created by mklink.exe tool: 850 * \??\C:\folder\file.txt 851 * \??\\C:\folder\file.txt 852 * \??\UNC\server\share\file.txt 853 * \??\\UNC\server\share\file.txt 854 * \??\Volume{b75e2c83-0000-0000-0000-602f00000000}\folder\file.txt 855 * 856 * It means that the most common path prefix \??\ is also NT path 857 * symlink (to \GLOBAL??). It is less common that second path 858 * separator is double backslash, but it is valid. 859 * 860 * Volume guid is randomly generated by the target system and so 861 * only the target system knows the mapping between guid and the 862 * hardisk number. Over SMB it is not possible to resolve this 863 * mapping, therefore symlinks pointing to target location of 864 * volume guids are totally unusable over SMB. 865 * 866 * For now parse only symlink paths available for DOS and Win32. 867 * Those are paths with \??\ prefix or paths which points to \??\ 868 * via other NT symlink (\DosDevices\, \GLOBAL??\, ...). 869 */ 870 abs_path = smb_target; 871 globalroot: 872 if (strstarts(abs_path, "\\??\\")) 873 abs_path += sizeof("\\??\\")-1; 874 else if (strstarts(abs_path, "\\DosDevices\\")) 875 abs_path += sizeof("\\DosDevices\\")-1; 876 else if (strstarts(abs_path, "\\GLOBAL??\\")) 877 abs_path += sizeof("\\GLOBAL??\\")-1; 878 else { 879 /* Unhandled absolute symlink, points outside of DOS/Win32 */ 880 cifs_dbg(VFS, 881 "absolute symlink '%s' cannot be converted from NT format " 882 "because points to unknown target\n", 883 smb_target); 884 rc = -EIO; 885 goto out; 886 } 887 888 /* Sometimes path separator after \?? is double backslash */ 889 if (abs_path[0] == '\\') 890 abs_path++; 891 892 while (strstarts(abs_path, "Global\\")) 893 abs_path += sizeof("Global\\")-1; 894 895 if (strstarts(abs_path, "GLOBALROOT\\")) { 896 /* Label globalroot requires path with leading '\\', so do not trim '\\' */ 897 abs_path += sizeof("GLOBALROOT")-1; 898 goto globalroot; 899 } 900 901 /* For now parse only paths to drive letters */ 902 if (((abs_path[0] >= 'A' && abs_path[0] <= 'Z') || 903 (abs_path[0] >= 'a' && abs_path[0] <= 'z')) && 904 abs_path[1] == ':' && 905 (abs_path[2] == '\\' || abs_path[2] == '\0')) { 906 /* Convert drive letter to lowercase and drop colon */ 907 char drive_letter = abs_path[0]; 908 if (drive_letter >= 'A' && drive_letter <= 'Z') 909 drive_letter += 'a'-'A'; 910 abs_path++; 911 abs_path[0] = drive_letter; 912 } else { 913 /* Unhandled absolute symlink. Report an error. */ 914 cifs_dbg(VFS, 915 "absolute symlink '%s' cannot be converted from NT format " 916 "because points to unknown target\n", 917 smb_target); 918 rc = -EIO; 919 goto out; 920 } 921 922 abs_path_len = strlen(abs_path)+1; 923 symlinkroot_len = strlen(cifs_sb->ctx->symlinkroot); 924 if (cifs_sb->ctx->symlinkroot[symlinkroot_len-1] == '/') 925 symlinkroot_len--; 926 linux_target = kmalloc(symlinkroot_len + 1 + abs_path_len, GFP_KERNEL); 927 if (!linux_target) { 928 rc = -ENOMEM; 929 goto out; 930 } 931 memcpy(linux_target, cifs_sb->ctx->symlinkroot, symlinkroot_len); 932 linux_target[symlinkroot_len] = '/'; 933 memcpy(linux_target + symlinkroot_len + 1, abs_path, abs_path_len); 934 } else if (smb_target[0] == sep && relative) { 935 /* 936 * This is a relative SMB symlink from the top of the share, 937 * which is the top level directory of the Linux mount point. 938 * Linux does not support such relative symlinks, so convert 939 * it to the relative symlink from the current directory. 940 * full_path is the SMB path to the symlink (from which is 941 * extracted current directory) and smb_target is the SMB path 942 * where symlink points, therefore full_path must always be on 943 * the SMB share. 944 */ 945 int smb_target_len = strlen(smb_target)+1; 946 levels = 0; 947 for (i = 1; full_path[i]; i++) { /* i=1 to skip leading sep */ 948 if (full_path[i] == sep) 949 levels++; 950 } 951 linux_target = kmalloc(levels*3 + smb_target_len, GFP_KERNEL); 952 if (!linux_target) { 953 rc = -ENOMEM; 954 goto out; 955 } 956 for (i = 0; i < levels; i++) { 957 linux_target[i*3 + 0] = '.'; 958 linux_target[i*3 + 1] = '.'; 959 linux_target[i*3 + 2] = sep; 960 } 961 memcpy(linux_target + levels*3, smb_target+1, smb_target_len); /* +1 to skip leading sep */ 962 } else { 963 /* 964 * This is either an absolute symlink in POSIX-style format 965 * or relative SMB symlink from the current directory. 966 * These paths have same format as Linux symlinks, so no 967 * conversion is needed. 968 */ 969 linux_target = smb_target; 970 smb_target = NULL; 971 } 972 973 if (sep == '\\') 974 convert_delimiter(linux_target, '/'); 975 976 rc = 0; 977 *target = linux_target; 978 979 cifs_dbg(FYI, "%s: symlink target: %s\n", __func__, *target); 980 981 out: 982 if (rc != 0) 983 kfree(linux_target); 984 kfree(smb_target); 985 return rc; 986 } 987 988 static int parse_reparse_native_symlink(struct reparse_symlink_data_buffer *sym, 989 u32 plen, 990 struct cifs_sb_info *cifs_sb, 991 const char *full_path, 992 struct cifs_open_info_data *data) 993 { 994 unsigned int len; 995 unsigned int offs; 996 997 /* We handle Symbolic Link reparse tag here. See: MS-FSCC 2.1.2.4 */ 998 999 offs = le16_to_cpu(sym->SubstituteNameOffset); 1000 len = le16_to_cpu(sym->SubstituteNameLength); 1001 if (offs + 20 > plen || offs + len + 20 > plen) { 1002 cifs_dbg(VFS, "srv returned malformed symlink buffer\n"); 1003 return -EIO; 1004 } 1005 1006 return smb2_parse_native_symlink(&data->symlink_target, 1007 sym->PathBuffer + offs, 1008 len, 1009 le32_to_cpu(sym->Flags) & SYMLINK_FLAG_RELATIVE, 1010 full_path, 1011 cifs_sb); 1012 } 1013 1014 static int parse_reparse_wsl_symlink(struct reparse_wsl_symlink_data_buffer *buf, 1015 struct cifs_sb_info *cifs_sb, 1016 struct cifs_open_info_data *data) 1017 { 1018 int len = le16_to_cpu(buf->ReparseDataLength); 1019 int data_offset = offsetof(typeof(*buf), Target) - offsetof(typeof(*buf), Version); 1020 int symname_utf8_len; 1021 __le16 *symname_utf16; 1022 int symname_utf16_len; 1023 1024 if (len <= data_offset) { 1025 cifs_dbg(VFS, "srv returned malformed wsl symlink buffer\n"); 1026 return -EIO; 1027 } 1028 1029 /* MS-FSCC 2.1.2.7 defines layout of the Target field only for Version 2. */ 1030 if (le32_to_cpu(buf->Version) != 2) { 1031 cifs_dbg(VFS, "srv returned unsupported wsl symlink version %u\n", le32_to_cpu(buf->Version)); 1032 return -EIO; 1033 } 1034 1035 /* Target for Version 2 is in UTF-8 but without trailing null-term byte */ 1036 symname_utf8_len = len - data_offset; 1037 /* 1038 * Check that buffer does not contain null byte 1039 * because Linux cannot process symlink with null byte. 1040 */ 1041 if (strnlen(buf->Target, symname_utf8_len) != symname_utf8_len) { 1042 cifs_dbg(VFS, "srv returned null byte in wsl symlink target location\n"); 1043 return -EIO; 1044 } 1045 symname_utf16 = kzalloc(symname_utf8_len * 2, GFP_KERNEL); 1046 if (!symname_utf16) 1047 return -ENOMEM; 1048 symname_utf16_len = utf8s_to_utf16s(buf->Target, symname_utf8_len, 1049 UTF16_LITTLE_ENDIAN, 1050 (wchar_t *) symname_utf16, symname_utf8_len * 2); 1051 if (symname_utf16_len < 0) { 1052 kfree(symname_utf16); 1053 return symname_utf16_len; 1054 } 1055 symname_utf16_len *= 2; /* utf8s_to_utf16s() returns number of u16 items, not byte length */ 1056 1057 data->symlink_target = cifs_strndup_from_utf16((u8 *)symname_utf16, 1058 symname_utf16_len, true, 1059 cifs_sb->local_nls); 1060 kfree(symname_utf16); 1061 if (!data->symlink_target) 1062 return -ENOMEM; 1063 1064 return 0; 1065 } 1066 1067 int parse_reparse_point(struct reparse_data_buffer *buf, 1068 u32 plen, struct cifs_sb_info *cifs_sb, 1069 const char *full_path, 1070 struct cifs_open_info_data *data) 1071 { 1072 data->reparse.buf = buf; 1073 1074 /* See MS-FSCC 2.1.2 */ 1075 switch (le32_to_cpu(buf->ReparseTag)) { 1076 case IO_REPARSE_TAG_NFS: 1077 return parse_reparse_nfs((struct reparse_nfs_data_buffer *)buf, 1078 cifs_sb, data); 1079 case IO_REPARSE_TAG_SYMLINK: 1080 return parse_reparse_native_symlink( 1081 (struct reparse_symlink_data_buffer *)buf, 1082 plen, cifs_sb, full_path, data); 1083 case IO_REPARSE_TAG_LX_SYMLINK: 1084 return parse_reparse_wsl_symlink( 1085 (struct reparse_wsl_symlink_data_buffer *)buf, 1086 cifs_sb, data); 1087 case IO_REPARSE_TAG_AF_UNIX: 1088 case IO_REPARSE_TAG_LX_FIFO: 1089 case IO_REPARSE_TAG_LX_CHR: 1090 case IO_REPARSE_TAG_LX_BLK: 1091 if (le16_to_cpu(buf->ReparseDataLength) != 0) { 1092 cifs_dbg(VFS, "srv returned malformed buffer for reparse point: 0x%08x\n", 1093 le32_to_cpu(buf->ReparseTag)); 1094 return -EIO; 1095 } 1096 return 0; 1097 default: 1098 return -EOPNOTSUPP; 1099 } 1100 } 1101 1102 struct reparse_data_buffer *smb2_get_reparse_point_buffer(const struct kvec *rsp_iov, 1103 u32 *plen) 1104 { 1105 struct smb2_ioctl_rsp *io = rsp_iov->iov_base; 1106 *plen = le32_to_cpu(io->OutputCount); 1107 return (struct reparse_data_buffer *)((u8 *)io + 1108 le32_to_cpu(io->OutputOffset)); 1109 } 1110 1111 static bool wsl_to_fattr(struct cifs_open_info_data *data, 1112 struct cifs_sb_info *cifs_sb, 1113 u32 tag, struct cifs_fattr *fattr) 1114 { 1115 struct smb2_file_full_ea_info *ea; 1116 bool have_xattr_dev = false; 1117 u32 next = 0; 1118 1119 switch (tag) { 1120 case IO_REPARSE_TAG_LX_SYMLINK: 1121 fattr->cf_mode |= S_IFLNK; 1122 break; 1123 case IO_REPARSE_TAG_LX_FIFO: 1124 fattr->cf_mode |= S_IFIFO; 1125 break; 1126 case IO_REPARSE_TAG_AF_UNIX: 1127 fattr->cf_mode |= S_IFSOCK; 1128 break; 1129 case IO_REPARSE_TAG_LX_CHR: 1130 fattr->cf_mode |= S_IFCHR; 1131 break; 1132 case IO_REPARSE_TAG_LX_BLK: 1133 fattr->cf_mode |= S_IFBLK; 1134 break; 1135 } 1136 1137 if (!data->wsl.eas_len) 1138 goto out; 1139 1140 ea = (struct smb2_file_full_ea_info *)data->wsl.eas; 1141 do { 1142 const char *name; 1143 void *v; 1144 u8 nlen; 1145 1146 ea = (void *)((u8 *)ea + next); 1147 next = le32_to_cpu(ea->next_entry_offset); 1148 if (!le16_to_cpu(ea->ea_value_length)) 1149 continue; 1150 1151 name = ea->ea_data; 1152 nlen = ea->ea_name_length; 1153 v = (void *)((u8 *)ea->ea_data + ea->ea_name_length + 1); 1154 1155 if (!strncmp(name, SMB2_WSL_XATTR_UID, nlen)) 1156 fattr->cf_uid = wsl_make_kuid(cifs_sb, v); 1157 else if (!strncmp(name, SMB2_WSL_XATTR_GID, nlen)) 1158 fattr->cf_gid = wsl_make_kgid(cifs_sb, v); 1159 else if (!strncmp(name, SMB2_WSL_XATTR_MODE, nlen)) { 1160 /* File type in reparse point tag and in xattr mode must match. */ 1161 if (S_DT(fattr->cf_mode) != S_DT(le32_to_cpu(*(__le32 *)v))) 1162 return false; 1163 fattr->cf_mode = (umode_t)le32_to_cpu(*(__le32 *)v); 1164 } else if (!strncmp(name, SMB2_WSL_XATTR_DEV, nlen)) { 1165 fattr->cf_rdev = reparse_mkdev(v); 1166 have_xattr_dev = true; 1167 } 1168 } while (next); 1169 out: 1170 1171 /* Major and minor numbers for char and block devices are mandatory. */ 1172 if (!have_xattr_dev && (tag == IO_REPARSE_TAG_LX_CHR || tag == IO_REPARSE_TAG_LX_BLK)) 1173 return false; 1174 1175 fattr->cf_dtype = S_DT(fattr->cf_mode); 1176 return true; 1177 } 1178 1179 static bool posix_reparse_to_fattr(struct cifs_sb_info *cifs_sb, 1180 struct cifs_fattr *fattr, 1181 struct cifs_open_info_data *data) 1182 { 1183 struct reparse_nfs_data_buffer *buf = (struct reparse_nfs_data_buffer *)data->reparse.buf; 1184 1185 if (buf == NULL) 1186 return true; 1187 1188 if (le16_to_cpu(buf->ReparseDataLength) < sizeof(buf->InodeType)) { 1189 WARN_ON_ONCE(1); 1190 return false; 1191 } 1192 1193 switch (le64_to_cpu(buf->InodeType)) { 1194 case NFS_SPECFILE_CHR: 1195 if (le16_to_cpu(buf->ReparseDataLength) != sizeof(buf->InodeType) + 8) { 1196 WARN_ON_ONCE(1); 1197 return false; 1198 } 1199 fattr->cf_mode |= S_IFCHR; 1200 fattr->cf_rdev = reparse_mkdev(buf->DataBuffer); 1201 break; 1202 case NFS_SPECFILE_BLK: 1203 if (le16_to_cpu(buf->ReparseDataLength) != sizeof(buf->InodeType) + 8) { 1204 WARN_ON_ONCE(1); 1205 return false; 1206 } 1207 fattr->cf_mode |= S_IFBLK; 1208 fattr->cf_rdev = reparse_mkdev(buf->DataBuffer); 1209 break; 1210 case NFS_SPECFILE_FIFO: 1211 fattr->cf_mode |= S_IFIFO; 1212 break; 1213 case NFS_SPECFILE_SOCK: 1214 fattr->cf_mode |= S_IFSOCK; 1215 break; 1216 case NFS_SPECFILE_LNK: 1217 fattr->cf_mode |= S_IFLNK; 1218 break; 1219 default: 1220 WARN_ON_ONCE(1); 1221 return false; 1222 } 1223 return true; 1224 } 1225 1226 bool cifs_reparse_point_to_fattr(struct cifs_sb_info *cifs_sb, 1227 struct cifs_fattr *fattr, 1228 struct cifs_open_info_data *data) 1229 { 1230 u32 tag = data->reparse.tag; 1231 bool ok; 1232 1233 switch (tag) { 1234 case IO_REPARSE_TAG_LX_SYMLINK: 1235 case IO_REPARSE_TAG_LX_FIFO: 1236 case IO_REPARSE_TAG_AF_UNIX: 1237 case IO_REPARSE_TAG_LX_CHR: 1238 case IO_REPARSE_TAG_LX_BLK: 1239 ok = wsl_to_fattr(data, cifs_sb, tag, fattr); 1240 if (!ok) 1241 return false; 1242 break; 1243 case IO_REPARSE_TAG_NFS: 1244 ok = posix_reparse_to_fattr(cifs_sb, fattr, data); 1245 if (!ok) 1246 return false; 1247 break; 1248 case 0: /* SMB1 symlink */ 1249 case IO_REPARSE_TAG_SYMLINK: 1250 fattr->cf_mode |= S_IFLNK; 1251 break; 1252 default: 1253 if (!(fattr->cf_cifsattrs & ATTR_DIRECTORY)) 1254 return false; 1255 if (!IS_REPARSE_TAG_NAME_SURROGATE(tag) && 1256 tag != IO_REPARSE_TAG_INTERNAL) 1257 return false; 1258 /* See cifs_create_junction_fattr() */ 1259 fattr->cf_mode = S_IFDIR | 0711; 1260 break; 1261 } 1262 1263 fattr->cf_dtype = S_DT(fattr->cf_mode); 1264 return true; 1265 } 1266