reparse.c

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