/*
 * 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_node.c,v 1.54.52.1 2005/05/27 02:35:28 lindak Exp $
 */

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

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/cred.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/vfs.h>
#include <sys/vnode.h>
#include <sys/kmem.h>
#include <sys/stat.h>
#include <sys/atomic.h>
#include <sys/cmn_err.h>
#include <sys/sysmacros.h>
#include <sys/bitmap.h>

#include <netsmb/smb_osdep.h>

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

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

/*
 * Lack of inode numbers leads us to the problem of generating them.
 * Partially this problem can be solved by having a dir/file cache
 * with inode numbers generated from the incremented by one counter.
 * However this way will require too much kernel memory, gives all
 * sorts of locking and consistency problems, not to mentinon counter
 * overflows. So, I'm decided to use a hash function to generate
 * pseudo random (and [often?] unique) inode numbers.
 */

/* Magic constants for name hashing. */
#define	FNV_32_PRIME ((uint32_t)0x01000193UL)
#define	FNV1_32_INIT ((uint32_t)33554467UL)

static inline uint32_t
smbfs_hash(uint32_t ival, const char *name, int nmlen)
{
	uint32_t v;

	for (v = ival; nmlen; name++, nmlen--) {
		v *= FNV_32_PRIME;
		v ^= (uint32_t)*name;
	}
	return (v);
}

/*
 * Compute the hash of the full (remote) path name
 * using the three parts supplied separately.
 */
uint32_t
smbfs_gethash(const char *rpath, int rplen)
{
	uint32_t v;

	v = smbfs_hash(FNV1_32_INIT, rpath, rplen);
	return (v);
}

/*
 * Like smbfs_gethash, but optimized a little by
 * starting with the directory hash.
 */
uint32_t
smbfs_getino(struct smbnode *dnp, const char *name, int nmlen)
{
	uint32_t ino;
	char sep;

	/* Start with directory hash */
	ino = (uint32_t)dnp->n_ino;

	/* separator (maybe) */
	sep = SMBFS_DNP_SEP(dnp);
	if (sep)
		ino = smbfs_hash(ino, &sep, 1);

	/* Now hash this component. */
	ino = smbfs_hash(ino, name, nmlen);

	return (ino);
}

/*
 * Allocate and copy a string of passed length.
 * The passed length does NOT include the null.
 */
char *
smbfs_name_alloc(const char *name, int nmlen)
{
	char *cp;

	cp = kmem_alloc(nmlen + 1, KM_SLEEP);
	bcopy(name, cp, nmlen);
	cp[nmlen] = 0;

	return (cp);
}

/*
 * Free string from smbfs_name_alloc().  Again,
 * the passed length does NOT include the null.
 */
void
smbfs_name_free(const char *name, int nmlen)
{
	kmem_free((char *)name, nmlen + 1);
}

/*
 * smbfs_nget()
 *
 * Find or create a node under some directory node.
 */
int
smbfs_nget(vnode_t *dvp, const char *name, int nmlen,
	struct smbfattr *fap, vnode_t **vpp)
{
	struct smbnode *dnp = VTOSMB(dvp);
	struct smbnode *np;
	vnode_t *vp;
	char sep;

	ASSERT(fap != NULL);
	*vpp = NULL;

	/* Don't expect "" or "." or ".." here anymore. */
	if (nmlen == 0 || (nmlen == 1 && name[0] == '.') ||
	    (nmlen == 2 && name[0] == '.' && name[1] == '.')) {
		return (EINVAL);
	}
	sep = SMBFS_DNP_SEP(dnp);

	/* Find or create the node. */
	np = smbfs_node_findcreate(dnp->n_mount,
	    dnp->n_rpath, dnp->n_rplen,
	    name, nmlen, sep, fap);

	/*
	 * We should have np now, because we passed
	 * fap != NULL to smbfs_node_findcreate.
	 */
	ASSERT(np != NULL);
	vp = SMBTOV(np);

	/*
	 * Files in an XATTR dir are also XATTR.
	 */
	if (dnp->n_flag & N_XATTR) {
		mutex_enter(&np->r_statelock);
		np->n_flag |= N_XATTR;
		mutex_exit(&np->r_statelock);
	}

	/* BSD symlink hack removed (smb_symmagic) */

	*vpp = vp;

	return (0);
}

/*
 * Update the local notion of the mtime of some directory.
 * See comments re. r_mtime in smbfs_node.h
 */
void
smbfs_attr_touchdir(struct smbnode *dnp)
{

	mutex_enter(&dnp->r_statelock);

	/*
	 * Now that we keep the client's notion of mtime
	 * separately from the server, this is easy.
	 */
	dnp->r_mtime = gethrtime();

	/*
	 * Invalidate the cache, so that we go to the wire
	 * to check that the server doesn't have a better
	 * timestamp next time we care.
	 */
	smbfs_attrcache_rm_locked(dnp);
	mutex_exit(&dnp->r_statelock);
}

void
smbfs_attrcache_remove(struct smbnode *np)
{
	mutex_enter(&np->r_statelock);
	/* smbfs_attrcache_rm_locked(np); */
	np->r_attrtime = gethrtime();
	mutex_exit(&np->r_statelock);
}

/* See smbfs_node.h */
#undef smbfs_attrcache_rm_locked
void
smbfs_attrcache_rm_locked(struct smbnode *np)
{
	ASSERT(MUTEX_HELD(&np->r_statelock));
	np->r_attrtime = gethrtime();
}