xref: /illumos-gate/usr/src/uts/common/fs/smbclnt/smbfs/smbfs_subr.c (revision bb936843)

/*
 * Copyright (c) 2000-2001, Boris Popov
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    This product includes software developed by Boris Popov.
 * 4. Neither the name of the author nor the names of any co-contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $Id: smbfs_subr.c,v 1.18 2005/02/02 00:22:23 lindak Exp $
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2018 Nexenta Systems, Inc.  All rights reserved.
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/time.h>
#include <sys/vnode.h>
#include <sys/sunddi.h>

#include <netsmb/smb_osdep.h>

#include <netsmb/smb.h>
#include <netsmb/smb2.h>
#include <netsmb/smb_conn.h>
#include <netsmb/smb_subr.h>
#include <netsmb/smb_rq.h>

#include <smbfs/smbfs.h>
#include <smbfs/smbfs_node.h>
#include <smbfs/smbfs_subr.h>

/*
 * In the Darwin code, this function used to compute the full path
 * by following the chain of n_parent pointers back to the root.
 * In the Solaris port we found the n_parent pointers inconvenient
 * because they hold parent nodes busy.  We now keep the full path
 * in every node, so this function need only marshall the directory
 * path, and (if provided) the separator and last component name.
 *
 * Note that this logic must match that in smbfs_getino
 */
int
smbfs_fullpath(struct mbchain *mbp, struct smb_vc *vcp, struct smbnode *dnp,
	const char *name, int nmlen, u_int8_t sep)
{
	int caseopt = SMB_CS_NONE;
	int unicode = (SMB_UNICODE_STRINGS(vcp)) ? 1 : 0;
	int error;

	/*
	 * SMB1 may need an alignment pad before (not SMB2)
	 */
	if (((vcp)->vc_flags & SMBV_SMB2) == 0 &&
	    ((vcp)->vc_hflags2 & SMB_FLAGS2_UNICODE) != 0) {
		error = mb_put_padbyte(mbp);
		if (error)
			return (error);
	}

	error = smb_put_dmem(mbp, vcp,
	    dnp->n_rpath, dnp->n_rplen,
	    caseopt, NULL);
	if (name) {
		/*
		 * Special case at share root:
		 * Don't put another slash.
		 */
		if (dnp->n_rplen <= 1 && sep == '\\')
			sep = 0;
		/*
		 * More special cases, now for XATTR:
		 * Our "faked up" XATTR directories use a
		 * full path name ending with ":" so as to
		 * avoid conflicts with any real paths.
		 * (It is not a valid CIFS path name.)
		 * Therefore, when we're composing a full
		 * path name from an XATTR directory, we
		 * need to _ommit_ the ":" separator and
		 * instead copy the one from the "fake"
		 * parent node's path name.
		 */
		if (dnp->n_flag & N_XATTR)
			sep = 0;

		if (sep) {
			/* Put the separator */
			if (unicode)
				error = mb_put_uint16le(mbp, sep);
			else
				error = mb_put_uint8(mbp, sep);
			if (error)
				return (error);
		}
		/* Put the name */
		error = smb_put_dmem(mbp, vcp,
		    name, nmlen, caseopt, NULL);
		if (error)
			return (error);
	}

	/* SMB1 wants NULL termination. */
	if (((vcp)->vc_flags & SMBV_SMB2) == 0) {
		if (unicode)
			error = mb_put_uint16le(mbp, 0);
		else
			error = mb_put_uint8(mbp, 0);
	}

	return (error);
}

/*
 * Convert a Unicode directory entry to UTF-8
 */
void
smbfs_fname_tolocal(struct smbfs_fctx *ctx)
{
	uchar_t tmpbuf[SMB_MAXFNAMELEN+1];
	struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
	uchar_t *dst;
	const ushort_t *src;
	size_t inlen, outlen;
	int flags;

	if (ctx->f_nmlen == 0)
		return;

	if (!SMB_UNICODE_STRINGS(vcp))
		return;

	if (ctx->f_namesz < sizeof (tmpbuf)) {
		ASSERT(0);
		goto errout;
	}

	/*
	 * In-place conversions are not supported,
	 * so convert into tmpbuf and copy.
	 */
	dst = tmpbuf;
	outlen = SMB_MAXFNAMELEN;
	/*LINTED*/
	src = (const ushort_t *)ctx->f_name;
	inlen = ctx->f_nmlen / 2;	/* number of UCS-2 characters */
	flags = UCONV_IN_LITTLE_ENDIAN;

	if (uconv_u16tou8(src, &inlen, dst, &outlen, flags) != 0)
		goto errout;

	ASSERT(outlen < sizeof (tmpbuf));
	tmpbuf[outlen] = '\0';
	bcopy(tmpbuf, ctx->f_name, outlen + 1);
	ctx->f_nmlen = (int)outlen;
	return;

errout:
	/*
	 * Conversion failed, but our caller does not
	 * deal with errors here, so just put a "?".
	 * Don't expect to ever see this.
	 */
	(void) strlcpy(ctx->f_name, "?", ctx->f_namesz);
}

/*
 * Decode a directory entry from OtW form into ctx->f_attr
 *
 * Caller already put some (wire-format) directory entries
 * into ctx->f_mdchain and we expect to find one.
 *
 * Advancing correctly through the buffer can be tricky if one
 * tries to add up the size of an entry as you go (which is how
 * the darwin code this is derived from did it).  The easiest way
 * to correctly advance the position is to get a whole dirent
 * into another mdchain (entry_mdc) based on NextEntryOffset,
 * and then scan the data from that mdchain.  On the last entry,
 * we don't know the entire length, so just scan directly from
 * what remains of the multi-entry buffer instead of trying to
 * figure out the length to copy into a separate mdchain.
 */
int
smbfs_decode_dirent(struct smbfs_fctx *ctx)
{
	struct mdchain entry_mdc;
	struct mdchain *mdp = &ctx->f_mdchain;
	size_t nmlen;
	uint64_t llongint;
	uint32_t nmsize, dattr;
	uint32_t nextoff = 0;
	int error;

	/* In case we error out... */
	ctx->f_nmlen = 0;
	ctx->f_rkey = (uint32_t)-1;
	bzero(&entry_mdc, sizeof (entry_mdc));

	/*
	 * Setup mdp to point to an mbchain holding
	 * what should be a single directory entry.
	 */
	error = md_get_uint32le(mdp, &nextoff);
	if (error != 0)
		goto errout;
	if (nextoff >= 4) {
		/*
		 * More entries follow.  Make a new mbchain
		 * holding just this one entry, then advance.
		 */
		mblk_t *m = NULL;
		error = md_get_mbuf(mdp, nextoff - 4, &m);
		if (error != 0)
			goto errout;
		md_initm(&entry_mdc, m);
		mdp = &entry_mdc;
		ctx->f_eofs += nextoff;
	} else {
		/* Scan directly from ctx->f_mdchain */
		ctx->f_eofs = ctx->f_left;
	}

	/*
	 * Decode the fixed-size parts
	 */
	switch (ctx->f_infolevel) {
	case FileFullDirectoryInformation:
	case SMB_FIND_FULL_DIRECTORY_INFO:
		md_get_uint32le(mdp, &ctx->f_rkey);	/* resume key (idx) */
		md_get_uint64le(mdp, &llongint);	/* creation time */
		smb_time_NT2local(llongint, &ctx->f_attr.fa_createtime);
		md_get_uint64le(mdp, &llongint);
		smb_time_NT2local(llongint, &ctx->f_attr.fa_atime);
		md_get_uint64le(mdp, &llongint);
		smb_time_NT2local(llongint, &ctx->f_attr.fa_mtime);
		md_get_uint64le(mdp, &llongint);
		smb_time_NT2local(llongint, &ctx->f_attr.fa_ctime);
		md_get_uint64le(mdp, &llongint);	/* file size */
		ctx->f_attr.fa_size = llongint;
		md_get_uint64le(mdp, &llongint);	/* alloc. size */
		ctx->f_attr.fa_allocsz = llongint;
		md_get_uint32le(mdp, &dattr);	/* ext. file attributes */
		ctx->f_attr.fa_attr = dattr;
		error = md_get_uint32le(mdp, &nmsize);	/* name size (otw) */
		if (error)
			goto errout;
		md_get_uint32le(mdp, NULL);	/* Ea size */
		break;

	case FileStreamInformation:
		error = md_get_uint32le(mdp, &nmsize);	/* name size (otw) */
		md_get_uint64le(mdp, &llongint);	/* file size */
		ctx->f_attr.fa_size = llongint;
		md_get_uint64le(mdp, &llongint);	/* alloc. size */
		ctx->f_attr.fa_allocsz = llongint;
		/*
		 * Stream names start with a ':' that we want to skip.
		 * This is the easiest place to take care of that.
		 * Always unicode here.
		 */
		if (nmsize >= 2) {
			struct mdchain save_mdc;
			uint16_t wch;
			save_mdc = *mdp;
			md_get_uint16le(mdp, &wch);
			if (wch == ':') {
				/* OK, we skipped the ':' */
				nmsize -= 2;
			} else {
				SMBVDEBUG("No leading : in stream?\n");
				/* restore position */
				*mdp = save_mdc;
			}
		}
		break;

	default:
		SMBVDEBUG("unexpected info level %d\n", ctx->f_infolevel);
		error = EINVAL;
		goto errout;
	}

	/*
	 * Get the filename, and convert to utf-8
	 * Allocated f_name in findopen
	 */
	nmlen = ctx->f_namesz;
	error = smb_get_dstring(mdp, SSTOVC(ctx->f_ssp),
	    ctx->f_name, &nmlen, nmsize);
	if (error != 0)
		goto errout;
	ctx->f_nmlen = (int)nmlen;
	md_done(&entry_mdc);
	return (0);

errout:
	/*
	 * Something bad has happened and we ran out of data
	 * before we could parse all f_ecnt entries expected.
	 * Give up on the current buffer.
	 */
	SMBVDEBUG("ran out of data\n");
	ctx->f_eofs = ctx->f_left;
	md_done(&entry_mdc);
	return (error);
}

/*
 * Decode FileAllInformation
 *
 * The data is a concatenation of:
 *	FileBasicInformation
 *	FileStandardInformation
 *	FileInternalInformation
 *	FileEaInformation
 *	FileAccessInformation
 *	FilePositionInformation
 *	FileModeInformation
 *	FileAlignmentInformation
 *	FileNameInformation
 */
/*ARGSUSED*/
int
smbfs_decode_file_all_info(struct smb_share *ssp,
	struct mdchain *mdp, struct smbfattr *fap)
{
	uint64_t llongint, lsize;
	uint32_t dattr;
	int error;

	/*
	 * This part is: FileBasicInformation
	 */

	/* creation time */
	md_get_uint64le(mdp, &llongint);
	smb_time_NT2local(llongint, &fap->fa_createtime);

	/* last access time */
	md_get_uint64le(mdp, &llongint);
	smb_time_NT2local(llongint, &fap->fa_atime);

	/* last write time */
	md_get_uint64le(mdp, &llongint);
	smb_time_NT2local(llongint, &fap->fa_mtime);

	/* last change time */
	md_get_uint64le(mdp, &llongint);
	smb_time_NT2local(llongint, &fap->fa_ctime);

	/* attributes */
	md_get_uint32le(mdp, &dattr);
	fap->fa_attr = dattr;

	/* reserved */
	md_get_uint32le(mdp, NULL);

	/*
	 * This part is: FileStandardInformation
	 */

	/* allocation size */
	md_get_uint64le(mdp, &lsize);
	fap->fa_allocsz = lsize;

	/* File size */
	error = md_get_uint64le(mdp, &lsize);
	fap->fa_size = lsize;

	/*
	 * There's more after this but we don't need it:
	 * Remainder of FileStandardInformation
	 *	NumLlinks, DeletOnClose, IsDir, reserved.
	 * Then:
	 *	FileInternalInformation
	 *	FileEaInformation
	 *	FileAccessInformation
	 *	FilePositionInformation
	 *	FileModeInformation
	 *	FileAlignmentInformation
	 *	FileNameInformation
	 */

	return (error);
}

/*
 * Decode FileFsAttributeInformation
 *
 *    ULONG FileSystemAttributes;
 *    LONG MaximumComponentNameLength;
 *    ULONG FileSystemNameLength;
 *    WCHAR FileSystemName[1];
 */
int
smbfs_decode_fs_attr_info(struct smb_share *ssp,
	struct mdchain *mdp, struct smb_fs_attr_info *fsa)
{
	struct smb_vc *vcp = SSTOVC(ssp);
	uint32_t nlen;
	int error;

	md_get_uint32le(mdp, &fsa->fsa_aflags);
	md_get_uint32le(mdp, &fsa->fsa_maxname);
	error = md_get_uint32le(mdp, &nlen);	/* fs name length */
	if (error)
		goto out;

	/*
	 * Get the FS type name.
	 */
	bzero(fsa->fsa_tname, FSTYPSZ);
	if (SMB_UNICODE_STRINGS(vcp)) {
		uint16_t tmpbuf[FSTYPSZ];
		size_t tmplen, outlen;

		if (nlen > sizeof (tmpbuf))
			nlen = sizeof (tmpbuf);
		error = md_get_mem(mdp, tmpbuf, nlen, MB_MSYSTEM);
		if (error != 0)
			goto out;
		tmplen = nlen / 2;	/* UCS-2 chars */
		outlen = FSTYPSZ - 1;
		error = uconv_u16tou8(tmpbuf, &tmplen,
		    (uchar_t *)fsa->fsa_tname, &outlen,
		    UCONV_IN_LITTLE_ENDIAN);
	} else {
		if (nlen > (FSTYPSZ - 1))
			nlen = FSTYPSZ - 1;
		error = md_get_mem(mdp, fsa->fsa_tname, nlen, MB_MSYSTEM);
	}

out:
	return (error);
}