fs/ntfs/reparse.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Processing of reparse points
 *
 * Part of this file is based on code from the NTFS-3G.
 *
 * Copyright (c) 2008-2021 Jean-Pierre Andre
 * Copyright (c) 2025 LG Electronics Co., Ltd.
 */

#include "ntfs.h"
#include "layout.h"
#include "attrib.h"
#include "inode.h"
#include "dir.h"
#include "volume.h"
#include "mft.h"
#include "index.h"
#include "lcnalloc.h"
#include "reparse.h"

struct wsl_link_reparse_data {
	__le32	type;
	char	link[];
};

static bool reparse_name_is_valid(size_t size, size_t name_off, u16 len)
{
	if ((name_off | len) & 1)
		return false;

	return name_off + len <= size;
}

/*
 * Windows-native reparse payloads store pathnames as UTF-16 strings with '\\'
 * separators. Convert the on-disk UTF-16 target into the mount's NLS and
 * normalize path separators.
 */
static int ntfs_reparse_target_to_nls(struct ntfs_volume *vol,
				      const __le16 *uname, u16 ulen,
				      char **target)
{
	int err, i;

	*target = NULL;
	ulen >>= 1;
	if (!ulen)
		return -EINVAL;

	if (!uname[ulen - 1])
		ulen--;

	err = ntfs_ucstonls(vol, uname, ulen, (unsigned char **)target, 0);
	if (err < 0) {
		ntfs_attr_name_free((unsigned char **)target);
		return err;
	}

	for (i = 0; i < err; i++) {
		if ((*target)[i] == '\\')
			(*target)[i] = '/';
	}

	return 0;
}

/* Index entry in $Extend/$Reparse */
struct reparse_index {
	struct index_entry_header header;
	struct reparse_index_key key;
	__le32 filling;
};

__le16 reparse_index_name[] = {cpu_to_le16('$'), cpu_to_le16('R'), 0};


/*
 * Check if the reparse point attribute buffer is valid.
 * Returns true if valid, false otherwise.
 */
static bool valid_reparse_buffer(struct ntfs_inode *ni,
				 const struct reparse_point *reparse_attr,
				 size_t size,
				 size_t payload_min_len)
{
	size_t expected;

	if (!ni || !reparse_attr)
		return false;

	/* Minimum size must cover reparse_point header */
	if (size < sizeof(struct reparse_point))
		return false;

	/* The payload must contain the fixed fields for the current tag. */
	if (payload_min_len &&
	    le16_to_cpu(reparse_attr->reparse_data_length) < payload_min_len)
		return false;

	/* Reserved zero tag is invalid */
	if (reparse_attr->reparse_tag == IO_REPARSE_TAG_RESERVED_ZERO)
		return false;

	/* Calculate expected total size */
	expected = sizeof(struct reparse_point) +
		le16_to_cpu(reparse_attr->reparse_data_length);

	/* Add GUID size for non-Microsoft tags */
	if (!(reparse_attr->reparse_tag & IO_REPARSE_TAG_IS_MICROSOFT))
		expected += sizeof(struct guid);

	/* Buffer must exactly match the expected size */
	return expected == size;
}

/*
 * Do some sanity checks on reparse data
 *
 * Microsoft reparse points have an 8-byte header whereas
 * non-Microsoft reparse points have a 24-byte header.  In each case,
 * 'reparse_data_length' must equal the number of non-header bytes.
 *
 * If the reparse data looks like a junction point or symbolic
 * link, more checks can be done.
 */
static bool valid_reparse_data(struct ntfs_inode *ni,
		const struct reparse_point *reparse_attr, size_t size)
{
	if (size < sizeof(*reparse_attr))
		return false;

	switch (reparse_attr->reparse_tag) {
	case IO_REPARSE_TAG_MOUNT_POINT:
	{
		struct mount_point_reparse_data *data;
		size_t data_offs;

		if (!valid_reparse_buffer(ni, reparse_attr, size, sizeof(*data)))
			return false;

		data = (struct mount_point_reparse_data *)reparse_attr->reparse_data;
		data_offs = offsetof(struct reparse_point, reparse_data) +
			offsetof(struct mount_point_reparse_data, path_buffer);

		if (!reparse_name_is_valid(size,
					   data_offs +
					   le16_to_cpu(data->substitute_name_offset),
					   le16_to_cpu(data->substitute_name_length)) ||
		    !reparse_name_is_valid(size,
					   data_offs +
					   le16_to_cpu(data->print_name_offset),
					   le16_to_cpu(data->print_name_length)))
			return false;
		break;
	}
	case IO_REPARSE_TAG_SYMLINK:
	{
		struct symlink_reparse_data *data;
		size_t data_offs;

		if (!valid_reparse_buffer(ni, reparse_attr, size,
					  sizeof(*data)))
			return false;

		data = (struct symlink_reparse_data *)reparse_attr->reparse_data;
		data_offs = offsetof(struct reparse_point, reparse_data) +
			offsetof(struct symlink_reparse_data, path_buffer);

		if (!reparse_name_is_valid(size,
					   data_offs +
					   le16_to_cpu(data->substitute_name_offset),
					   le16_to_cpu(data->substitute_name_length)) ||
		    !reparse_name_is_valid(size,
					   data_offs +
					   le16_to_cpu(data->print_name_offset),
					   le16_to_cpu(data->print_name_length)))
			return false;
		break;
	}
	case IO_REPARSE_TAG_LX_SYMLINK:
	{
		struct wsl_link_reparse_data *data;

		if (!valid_reparse_buffer(ni, reparse_attr, size,
					  sizeof(*data)))
			return false;

		data = (struct wsl_link_reparse_data *)reparse_attr->reparse_data;

		if (le16_to_cpu(reparse_attr->reparse_data_length) <= sizeof(data->type) ||
		    data->type != cpu_to_le32(2))
			return false;
		break;
	}
	case IO_REPARSE_TAG_AF_UNIX:
	case IO_REPARSE_TAG_LX_FIFO:
	case IO_REPARSE_TAG_LX_CHR:
	case IO_REPARSE_TAG_LX_BLK:
		if (!valid_reparse_buffer(ni, reparse_attr, size, 0))
			return false;
		if (le16_to_cpu(reparse_attr->reparse_data_length) ||
		    !(ni->flags & FILE_ATTRIBUTE_RECALL_ON_OPEN))
			return false;
		break;
	default:
		if (!valid_reparse_buffer(ni, reparse_attr, size, 0))
			return false;
		break;
	}

	return true;
}

static unsigned int ntfs_reparse_tag_mode(__le32 reparse_tag)
{
	unsigned int mode = 0;

	switch (reparse_tag) {
	case IO_REPARSE_TAG_MOUNT_POINT:
	case IO_REPARSE_TAG_SYMLINK:
	case IO_REPARSE_TAG_LX_SYMLINK:
		mode = S_IFLNK;
		break;
	case IO_REPARSE_TAG_AF_UNIX:
		mode = S_IFSOCK;
		break;
	case IO_REPARSE_TAG_LX_FIFO:
		mode = S_IFIFO;
		break;
	case IO_REPARSE_TAG_LX_CHR:
		mode = S_IFCHR;
		break;
	case IO_REPARSE_TAG_LX_BLK:
		mode = S_IFBLK;
	}

	return mode;
}

/*
 * Get the target for symbolic link
 */
unsigned int ntfs_make_symlink(struct ntfs_inode *ni)
{
	s64 attr_size = 0;
	int err;
	unsigned int lth;
	struct reparse_point *reparse_attr;
	unsigned int mode = 0;

	kvfree(ni->target);
	ni->target = NULL;
	ni->reparse_tag = 0;
	ni->reparse_flags = 0;

	reparse_attr = ntfs_attr_readall(ni, AT_REPARSE_POINT, NULL, 0,
					 &attr_size);
	if (reparse_attr &&
	    valid_reparse_data(ni, reparse_attr, attr_size)) {
		err = -EINVAL;

		switch (reparse_attr->reparse_tag) {
		case IO_REPARSE_TAG_MOUNT_POINT:
		{
			struct mount_point_reparse_data *data =
				(struct mount_point_reparse_data *)reparse_attr->reparse_data;
			const __le16 *name = (const __le16 *)((u8 *)data->path_buffer +
					      le16_to_cpu(data->substitute_name_offset));

			err = ntfs_reparse_target_to_nls(ni->vol,
							 name,
							 le16_to_cpu(data->substitute_name_length),
							 &ni->target);
			break;
		}
		case IO_REPARSE_TAG_SYMLINK:
		{
			struct symlink_reparse_data *data =
				(struct symlink_reparse_data *)reparse_attr->reparse_data;
			const __le16 *name = (const __le16 *)((u8 *)data->path_buffer +
							le16_to_cpu(data->substitute_name_offset));

			err = ntfs_reparse_target_to_nls(ni->vol,
							 name,
							 le16_to_cpu(data->substitute_name_length),
							 &ni->target);
			if (!err)
				ni->reparse_flags = data->flags;
			break;
		}
		case IO_REPARSE_TAG_LX_SYMLINK:
		{
			struct wsl_link_reparse_data *wsl_link_data =
				(struct wsl_link_reparse_data *)reparse_attr->reparse_data;

			if (wsl_link_data->type == cpu_to_le32(2)) {
				lth = le16_to_cpu(reparse_attr->reparse_data_length) -
					  sizeof(wsl_link_data->type);
				ni->target = kvzalloc(lth + 1, GFP_NOFS);
				if (ni->target) {
					memcpy(ni->target, wsl_link_data->link, lth);
					ni->target[lth] = 0;
					err = 0;
				}
			}
			break;
		}
		default:
			err = 0;
		}

		if (!err) {
			mode = ntfs_reparse_tag_mode(reparse_attr->reparse_tag);
			ni->reparse_tag = reparse_attr->reparse_tag;
		}
	} else
		ni->flags &= ~FILE_ATTR_REPARSE_POINT;

	if (reparse_attr)
		kvfree(reparse_attr);

	return mode;
}

unsigned int ntfs_reparse_tag_dt_types(struct ntfs_volume *vol, unsigned long mref)
{
	s64 attr_size = 0;
	struct reparse_point *reparse_attr;
	unsigned int dt_type = DT_UNKNOWN;
	struct inode *vi;

	vi = ntfs_iget(vol->sb, mref);
	if (IS_ERR(vi))
		return PTR_ERR(vi);

	reparse_attr = (struct reparse_point *)ntfs_attr_readall(NTFS_I(vi),
			AT_REPARSE_POINT, NULL, 0, &attr_size);

	if (reparse_attr && attr_size >= sizeof(*reparse_attr)) {
		switch (reparse_attr->reparse_tag) {
		case IO_REPARSE_TAG_MOUNT_POINT:
		case IO_REPARSE_TAG_SYMLINK:
		case IO_REPARSE_TAG_LX_SYMLINK:
			dt_type = DT_LNK;
			break;
		case IO_REPARSE_TAG_AF_UNIX:
			dt_type = DT_SOCK;
			break;
		case IO_REPARSE_TAG_LX_FIFO:
			dt_type = DT_FIFO;
			break;
		case IO_REPARSE_TAG_LX_CHR:
			dt_type = DT_CHR;
			break;
		case IO_REPARSE_TAG_LX_BLK:
			dt_type = DT_BLK;
		}
	}

	if (reparse_attr)
		kvfree(reparse_attr);

	iput(vi);
	return dt_type;
}

static bool ntfs_is_drive_letter(const char *target)
{
	return ((target[0] >= 'A' && target[0] <= 'Z') ||
		(target[0] >= 'a' && target[0] <= 'z')) &&
		target[1] == ':';
}

/*
 * ntfs_translate_symlink_path
 *
 * @dentry: dentry of the symlink/junction being resolved
 * @target: NUL-terminated NLS target string with '\\' already normalized to '/'
 * @translated: out parameter, set to a newly kmalloc'd relative path on success
 *
 * Windows junctions (IO_REPARSE_TAG_MOUNT_POINT) and non-relative symlinks
 * (IO_REPARSE_TAG_SYMLINK without SYMLINK_FLAG_RELATIVE) store substitute
 * names such as "/??/C:/foo", "//?/C:/foo", "/foo", or "C:/foo". Linux
 * cannot continue pathname lookup from those syntaxes, so rewrite them as a
 * path relative to the symlink's containing directory on this NTFS volume,
 * anchored at the volume root via "../".
 *
 * Note: bind-mounted subtrees of the volume may resolve to unexpected
 * locations because the computed "../" depth is relative to the NTFS volume
 * root, not the bind-mounted subtree root.
 *
 * Return: 0 on success with *translated set to a newly allocated string the
 * caller must kfree(); negative errno on failure.
 */
int ntfs_translate_symlink_path(struct dentry *dentry, const char *target,
				char **translated)
{
	char *buf, *link_path, *out, *p;
	const char *path, *tail;
	unsigned int up_levels = 0;
	size_t tail_len, out_len;
	int err;

	if (!dentry || !target || !translated)
		return -EINVAL;

	path = target;
	/* reject UNC path. */
	if (path[0] == '/' && path[1] == '/' &&
	    !(path[2] == '?' && path[3] == '/'))
		return -EOPNOTSUPP;

	/* target starts with "/??/" or "//?/"? */
	if ((path[0] == '/' && path[1] == '?' && path[2] == '?' && path[3] == '/') ||
	    (path[0] == '/' && path[1] == '/' && path[2] == '?' && path[3] == '/'))
		path += 4;

	/* target must start with a drive character or '/'. */
	if (ntfs_is_drive_letter(path)) {
		if (path[2] && path[2] != '/')
			return -EOPNOTSUPP;
		tail = path + 2;
		if (*tail == '/')
			tail++;
	} else if (*path == '/') {
		tail = path + 1;
	} else {
		return -EOPNOTSUPP;
	}

	tail_len = strlen(tail);

	buf = kmalloc(PATH_MAX, GFP_NOFS);
	if (!buf)
		return -ENOMEM;

	link_path = dentry_path_raw(dentry, buf, PATH_MAX);
	if (IS_ERR(link_path)) {
		err = PTR_ERR(link_path);
		goto out;
	}

	/* count '/' after the leading slash. */
	for (p = link_path + 1; *p; p++)
		if (*p == '/')
			up_levels++;

	/* build "./" + ("../" * up_levels) + tail. */
	out_len = 2 + up_levels * 3 + tail_len;
	if (out_len >= PATH_MAX) {
		err = -ENAMETOOLONG;
		goto out;
	}

	out = kmalloc(out_len + 1, GFP_NOFS);
	if (!out) {
		err = -ENOMEM;
		goto out;
	}

	memcpy(out, "./", 2);
	p = out + 2;
	while (up_levels--) {
		memcpy(p, "../", 3);
		p += 3;
	}
	memcpy(p, tail, tail_len + 1);

	*translated = out;
	err = 0;
out:
	kfree(buf);
	return err;
}

/*
 * Set the index for new reparse data
 */
static int set_reparse_index(struct ntfs_inode *ni, struct ntfs_index_context *xr,
		__le32 reparse_tag)
{
	struct reparse_index indx;
	u64 file_id_cpu;
	__le64 file_id;

	file_id_cpu = MK_MREF(ni->mft_no, ni->seq_no);
	file_id = cpu_to_le64(file_id_cpu);
	indx.header.data.vi.data_offset =
		cpu_to_le16(sizeof(struct index_entry_header) + sizeof(struct reparse_index_key));
	indx.header.data.vi.data_length = 0;
	indx.header.data.vi.reservedV = 0;
	indx.header.length = cpu_to_le16(sizeof(struct reparse_index));
	indx.header.key_length = cpu_to_le16(sizeof(struct reparse_index_key));
	indx.header.flags = 0;
	indx.header.reserved = 0;
	indx.key.reparse_tag = reparse_tag;
	/* danger on processors which require proper alignment! */
	memcpy(&indx.key.file_id, &file_id, 8);
	indx.filling = 0;
	ntfs_index_ctx_reinit(xr);

	return ntfs_ie_add(xr, (struct index_entry *)&indx);
}

/*
 * Remove a reparse data index entry if attribute present
 */
static int remove_reparse_index(struct inode *rp, struct ntfs_index_context *xr,
				__le32 *preparse_tag)
{
	struct reparse_index_key key;
	u64 file_id_cpu;
	__le64 file_id;
	s64 size;
	struct ntfs_inode *ni = NTFS_I(rp);
	int err = 0, ret = ni->data_size;

	if (ni->data_size == 0)
		return 0;

	/* read the existing reparse_tag */
	size = ntfs_inode_attr_pread(rp, 0, 4, (char *)preparse_tag);
	if (size != 4)
		return -ENODATA;

	file_id_cpu = MK_MREF(ni->mft_no, ni->seq_no);
	file_id = cpu_to_le64(file_id_cpu);
	key.reparse_tag = *preparse_tag;
	/* danger on processors which require proper alignment! */
	memcpy(&key.file_id, &file_id, 8);
	if (!ntfs_index_lookup(&key, sizeof(struct reparse_index_key), xr)) {
		err = ntfs_index_rm(xr);
		if (err)
			ret = err;
	}
	return ret;
}

/*
 * Open the $Extend/$Reparse file and its index
 */
static struct ntfs_index_context *open_reparse_index(struct ntfs_volume *vol)
{
	struct ntfs_index_context *xr = NULL;
	u64 mref;
	__le16 *uname;
	struct ntfs_name *name = NULL;
	int uname_len;
	struct inode *vi, *dir_vi;

	/* do not use path_name_to inode - could reopen root */
	dir_vi = ntfs_iget(vol->sb, FILE_Extend);
	if (IS_ERR(dir_vi))
		return NULL;

	uname_len = ntfs_nlstoucs(vol, "$Reparse", 8, &uname,
				  NTFS_MAX_NAME_LEN);
	if (uname_len < 0) {
		iput(dir_vi);
		return NULL;
	}

	mutex_lock_nested(&NTFS_I(dir_vi)->mrec_lock, NTFS_EXTEND_MUTEX_PARENT);
	mref = ntfs_lookup_inode_by_name(NTFS_I(dir_vi), uname, uname_len,
					 &name);
	mutex_unlock(&NTFS_I(dir_vi)->mrec_lock);
	kfree(name);
	kmem_cache_free(ntfs_name_cache, uname);
	if (IS_ERR_MREF(mref))
		goto put_dir_vi;

	vi = ntfs_iget(vol->sb, MREF(mref));
	if (IS_ERR(vi))
		goto put_dir_vi;

	xr = ntfs_index_ctx_get(NTFS_I(vi), reparse_index_name, 2);
	if (!xr)
		iput(vi);
put_dir_vi:
	iput(dir_vi);
	return xr;
}


/*
 * Update the reparse data and index
 *
 * The reparse data attribute should have been created, and
 * an existing index is expected if there is an existing value.
 *
 */
static int update_reparse_data(struct ntfs_inode *ni, struct ntfs_index_context *xr,
		char *value, size_t size)
{
	struct inode *rp_inode;
	int err = 0;
	s64 written;
	int oldsize;
	__le32 reparse_tag;
	struct ntfs_inode *rp_ni;

	rp_inode = ntfs_attr_iget(VFS_I(ni), AT_REPARSE_POINT, AT_UNNAMED, 0);
	if (IS_ERR(rp_inode))
		return -EINVAL;
	rp_ni = NTFS_I(rp_inode);

	/* remove the existing reparse data */
	oldsize = remove_reparse_index(rp_inode, xr, &reparse_tag);
	if (oldsize < 0) {
		err = oldsize;
		goto put_rp_inode;
	}

	/* overwrite value if any */
	written = ntfs_inode_attr_pwrite(rp_inode, 0, size, value, false);
	if (written != size) {
		ntfs_error(ni->vol->sb, "Failed to update reparse data\n");
		err = -EIO;
		goto put_rp_inode;
	}

	if (set_reparse_index(ni, xr, ((const struct reparse_point *)value)->reparse_tag) &&
	    oldsize > 0) {
		/*
		 * If cannot index, try to remove the reparse
		 * data and log the error. There will be an
		 * inconsistency if removal fails.
		 */
		ntfs_attr_rm(rp_ni);
		ntfs_error(ni->vol->sb,
			   "Failed to index reparse data. Possible corruption.\n");
	}

	mark_mft_record_dirty(ni);
put_rp_inode:
	iput(rp_inode);

	return err;
}

/*
 * Delete a reparse index entry
 */
int ntfs_delete_reparse_index(struct ntfs_inode *ni)
{
	struct inode *vi;
	struct ntfs_index_context *xr;
	struct ntfs_inode *xrni;
	__le32 reparse_tag;
	int err = 0;

	if (!(ni->flags & FILE_ATTR_REPARSE_POINT))
		return 0;

	vi = ntfs_attr_iget(VFS_I(ni), AT_REPARSE_POINT, AT_UNNAMED, 0);
	if (IS_ERR(vi))
		return PTR_ERR(vi);

	/*
	 * read the existing reparse data (the tag is enough)
	 * and un-index it
	 */
	xr = open_reparse_index(ni->vol);
	if (xr) {
		xrni = xr->idx_ni;
		mutex_lock_nested(&xrni->mrec_lock, NTFS_EXTEND_MUTEX_PARENT);
		err = remove_reparse_index(vi, xr, &reparse_tag);
		if (err < 0) {
			ntfs_index_ctx_put(xr);
			mutex_unlock(&xrni->mrec_lock);
			iput(VFS_I(xrni));
			goto out;
		}
		mark_mft_record_dirty(xrni);
		ntfs_index_ctx_put(xr);
		mutex_unlock(&xrni->mrec_lock);
		iput(VFS_I(xrni));
	}

	ni->flags &= ~FILE_ATTR_REPARSE_POINT;
	NInoSetFileNameDirty(ni);
	mark_mft_record_dirty(ni);

out:
	iput(vi);
	return err;
}

/*
 * Set the reparse data from an extended attribute
 */
static int ntfs_set_ntfs_reparse_data(struct ntfs_inode *ni, char *value, size_t size)
{
	int err = 0;
	struct ntfs_inode *xrni;
	struct ntfs_index_context *xr;

	if (!ni)
		return -EINVAL;

	/*
	 * reparse data compatibily with EA is not checked
	 * any more, it is required by Windows 10, but may
	 * lead to problems with earlier versions.
	 */
	if (valid_reparse_data(ni, (const struct reparse_point *)value, size) == false)
		return -EINVAL;

	xr = open_reparse_index(ni->vol);
	if (!xr)
		return -EINVAL;
	xrni = xr->idx_ni;

	if (!ntfs_attr_exist(ni, AT_REPARSE_POINT, AT_UNNAMED, 0)) {
		struct reparse_point rp = {0, };

		/*
		 * no reparse data attribute : add one,
		 * apparently, this does not feed the new value in
		 * Note : NTFS version must be >= 3
		 */
		if (ni->vol->major_ver < 3) {
			err = -EOPNOTSUPP;
			ntfs_index_ctx_put(xr);
			goto out;
		}

		err = ntfs_attr_add(ni, AT_REPARSE_POINT, AT_UNNAMED, 0, (u8 *)&rp, sizeof(rp));
		if (err) {
			ntfs_index_ctx_put(xr);
			goto out;
		}
		ni->flags |= FILE_ATTR_REPARSE_POINT;
		NInoSetFileNameDirty(ni);
		mark_mft_record_dirty(ni);
	}

	/* update value and index */
	mutex_lock_nested(&xrni->mrec_lock, NTFS_EXTEND_MUTEX_PARENT);
	err = update_reparse_data(ni, xr, value, size);
	if (err) {
		ni->flags &= ~FILE_ATTR_REPARSE_POINT;
		NInoSetFileNameDirty(ni);
		mark_mft_record_dirty(ni);
	}
	ntfs_index_ctx_put(xr);
	mutex_unlock(&xrni->mrec_lock);

out:
	if (!err)
		mark_mft_record_dirty(xrni);
	iput(VFS_I(xrni));

	return err;
}

/*
 * Set reparse data for a WSL type symlink
 */
int ntfs_reparse_set_wsl_symlink(struct ntfs_inode *ni,
				 const char *target, int target_len)
{
	int err = 0;
	int reparse_len;
	struct reparse_point *reparse;
	struct wsl_link_reparse_data *data;

	reparse_len = sizeof(struct reparse_point) + sizeof(data->type) +
		target_len;
	reparse = kvzalloc(reparse_len, GFP_NOFS);
	if (!reparse)
		return -ENOMEM;

	ni->target = kstrdup(target, GFP_NOFS);
	if (!ni->target) {
		kvfree(reparse);
		return -ENOMEM;
	}

	data = (struct wsl_link_reparse_data *)reparse->reparse_data;
	reparse->reparse_tag = IO_REPARSE_TAG_LX_SYMLINK;
	reparse->reparse_data_length =
		cpu_to_le16(sizeof(data->type) + target_len);
	reparse->reserved = 0;
	data->type = cpu_to_le32(2);
	memcpy(data->link, target, target_len);
	err = ntfs_set_ntfs_reparse_data(ni,
					 (char *)reparse, reparse_len);
	kvfree(reparse);
	if (err) {
		kfree(ni->target);
		ni->target = NULL;
	} else {
		ni->reparse_tag = IO_REPARSE_TAG_LX_SYMLINK;
		ni->reparse_flags = 0;
	}
	return err;
}

int ntfs_reparse_set_native_symlink(struct ntfs_inode *ni,
				    const char *target, int target_len)
{
	int err = 0;
	bool is_absolute, prt_sub_shared = true;
	char *sub_name = NULL;
	char *prt_name = NULL;
	__le16 *sub_name_utf16 = NULL;
	__le16 *prt_name_utf16 = NULL;
	int sub_len, prt_len;
	int total_data_len, total_reparse_len;
	struct reparse_point *reparse = NULL;
	struct symlink_reparse_data *data;
	int i;

	/* Determine if target is absolute (starts with drive letter like C:/ or C:\) */
	is_absolute = target_len > 2 &&
		ntfs_is_drive_letter(target) &&
		(target[2] == '/' || target[2] == '\\');


	/* Normalize and prepare NLS paths */
	prt_name = kstrdup(target, GFP_NOFS);
	if (!prt_name)
		return -ENOMEM;

	/* Replace '/' with '\' */
	for (i = 0; i < target_len; i++) {
		if (prt_name[i] == '/')
			prt_name[i] = '\\';
	}

	if (is_absolute) {
		/* Prepend '\??\' to Substitutename */
		sub_name = kmalloc(target_len + 5, GFP_NOFS);
		if (!sub_name) {
			err = -ENOMEM;
			goto out;
		}
		snprintf(sub_name, target_len + 5, "\\??\\%s", prt_name);
		prt_sub_shared = false;
	} else {
		/* For relative symlinks (including absolute paths without drive letters),
		 * SubstituteName and PrintName are identical.
		 */
		sub_name = prt_name;
	}

	/* Convert NLS paths to UTF-16 */
	sub_len = ntfs_nlstoucs(ni->vol, sub_name, strlen(sub_name),
				&sub_name_utf16, PATH_MAX);
	if (sub_len < 0) {
		err = sub_len;
		goto out;
	}

	prt_len = ntfs_nlstoucs(ni->vol, prt_name, strlen(prt_name),
				&prt_name_utf16, PATH_MAX);
	if (prt_len < 0) {
		err = prt_len;
		goto out;
	}

	/* Check for buffer size limits */
	total_data_len = sizeof(struct symlink_reparse_data) +
		(sub_len + prt_len) * sizeof(__le16);
	if (total_data_len > 16384) { /* 16KB max reparse tag size */
		err = -EFBIG;
		goto out;
	}

	total_reparse_len = sizeof(struct reparse_point) + total_data_len;
	reparse = kvzalloc(total_reparse_len, GFP_NOFS);
	if (!reparse) {
		err = -ENOMEM;
		goto out;
	}

	/* Pack fields in reparse buffer */
	reparse->reparse_tag = IO_REPARSE_TAG_SYMLINK;
	reparse->reparse_data_length = cpu_to_le16(total_data_len);
	reparse->reserved = 0;

	data = (struct symlink_reparse_data *)reparse->reparse_data;
	data->substitute_name_offset = 0;
	data->substitute_name_length = cpu_to_le16(sub_len * sizeof(__le16));
	data->print_name_offset = data->substitute_name_length;
	data->print_name_length = cpu_to_le16(prt_len * sizeof(__le16));
	data->flags = is_absolute ? 0 : cpu_to_le32(SYMLINK_FLAG_RELATIVE);

	/* Copy names to path_buffer */
	memcpy(data->path_buffer, sub_name_utf16, sub_len * sizeof(__le16));
	memcpy(data->path_buffer + sub_len, prt_name_utf16, prt_len * sizeof(__le16));

	err = ntfs_set_ntfs_reparse_data(ni, (char *)reparse, total_reparse_len);
	if (!err) {
		int len = strlen(sub_name);

		for (i = 0; i < len; i++) {
			if (sub_name[i] == '\\')
				sub_name[i] = '/';
		}
		ni->target = sub_name;
		sub_name = NULL;
		if (prt_sub_shared)
			prt_name = NULL;
		ni->reparse_tag = IO_REPARSE_TAG_SYMLINK;
		ni->reparse_flags = is_absolute ? 0 :
			cpu_to_le32(SYMLINK_FLAG_RELATIVE);
	}

out:
	kfree(prt_name);
	if (!prt_sub_shared)
		kfree(sub_name);
	kvfree(sub_name_utf16);
	kvfree(prt_name_utf16);
	kvfree(reparse);
	return err;
}

/*
 * Set reparse data for a WSL special file other than a symlink
 * (socket, fifo, character or block device)
 */
int ntfs_reparse_set_wsl_not_symlink(struct ntfs_inode *ni, mode_t mode)
{
	int err;
	int len;
	int reparse_len;
	__le32 reparse_tag;
	struct reparse_point *reparse;

	len = 0;
	if (S_ISSOCK(mode))
		reparse_tag = IO_REPARSE_TAG_AF_UNIX;
	else if (S_ISFIFO(mode))
		reparse_tag = IO_REPARSE_TAG_LX_FIFO;
	else if (S_ISCHR(mode))
		reparse_tag = IO_REPARSE_TAG_LX_CHR;
	else if (S_ISBLK(mode))
		reparse_tag = IO_REPARSE_TAG_LX_BLK;
	else
		return -EOPNOTSUPP;

	reparse_len = sizeof(struct reparse_point) + len;
	reparse = kvzalloc(reparse_len, GFP_NOFS);
	if (!reparse)
		err = -ENOMEM;
	else {
		reparse->reparse_tag = reparse_tag;
		reparse->reparse_data_length = cpu_to_le16(len);
		reparse->reserved = cpu_to_le16(0);
		err = ntfs_set_ntfs_reparse_data(ni, (char *)reparse,
						 reparse_len);
		kvfree(reparse);
		if (!err) {
			ni->reparse_tag = reparse_tag;
			ni->reparse_flags = 0;
		}
	}

	return err;
}