/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

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

/*
 * Password Keychain storage mechanism.
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/errno.h>
#include <sys/sysmacros.h>
#include <sys/uio.h>
#include <sys/buf.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/file.h>
#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/cmn_err.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunldi.h>
#include <sys/policy.h>
#include <sys/zone.h>
#include <sys/pathname.h>
#include <sys/mount.h>
#include <sys/sdt.h>
#include <fs/fs_subr.h>
#include <sys/devops.h>
#include <sys/thread.h>
#include <sys/mkdev.h>
#include <sys/avl.h>
#include <sys/avl_impl.h>
#include <sys/u8_textprep.h>

#include <netsmb/smb_osdep.h>

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

/*
 * The smb_ptd is a cache of Uid's, User names, passwords and domain names.
 * It will be used for storing the password information for a user and will
 * be used to for connections without entering the pasword again if its
 * already keyed in by the user. Its a kind of Key-Chain mechanism
 * implemented by Apple folks.
 */

/*
 * Information stored in the nodes:
 * UID:  Uid of the person who initiated the login request.
 * ZoneID: ZoneID of the zone from where the login request is initiated.
 * Username: Username in the CIFS server.
 * Srvdom: Domain name/ Server name of the CIFS server.
 * Password: Password of the user.
 * For more information, see smb_pass.h and sys/avl.h
 */

/*
 * Information retrieved from the node.
 * Node/password information can only be retrived with a call
 * to smb_pkey_getpw(). Password never gets copied to the userspace.
 * It will be copied to the Kernel data structure smbioc_ossn->ioc_password
 * when needed for doing the "Session Setup". All other calls will return
 * either a success or a failure.
 */

avl_tree_t smb_ptd; /* AVL password tree descriptor */
unsigned int smb_list_len = 0;	/* No. of elements in the tree. */
kmutex_t smb_ptd_lock; 	/* Mutex lock for controlled access */

int smb_pkey_check(smbioc_pk_t *pk, cred_t *cr);
int smb_pkey_deluid(uid_t ioc_uid, cred_t *cr);

/*
 * This routine is called by AVL tree calls when they want to find a
 * node, find the next position in the tree to add or for deletion.
 * Compare nodes from the tree to find the actual node based on
 * uid/zoneid/username/domainname.
 */
int
smb_pkey_cmp(const void *a, const void *b)
{
	const smb_passid_t *pa = (smb_passid_t *)a;
	const smb_passid_t *pb = (smb_passid_t *)b;
	int duser, dsrv, error;

	ASSERT(MUTEX_HELD(&smb_ptd_lock));

	/*
	 * The nodes are added sorted on the uid/zoneid/domainname/username
	 * We will do this:
	 * Compare uid's. The owner who stored the node gets access.
	 * Then zoneid to check if the access is from the same zone.
	 * Compare usernames.
	 * If the above are same, then compare domain/server names.
	 */
	if (pa->uid < pb->uid)
		return (-1);
	if (pa->uid > pb->uid)
		return (+1);
	if (pa->zoneid < pb->zoneid)
		return (-1);
	if (pa->zoneid > pb->zoneid)
		return (+1);
	dsrv = u8_strcmp(pa->srvdom, pb->srvdom, 0,
	    U8_STRCMP_CI_LOWER, U8_UNICODE_LATEST, &error);
	if (dsrv < 0)
		return (-1);
	if (dsrv > 0)
		return (+1);
	duser = u8_strcmp(pa->username, pb->username, 0,
	    U8_STRCMP_CI_LOWER, U8_UNICODE_LATEST, &error);
	if (duser < 0)
		return (-1);
	if (duser > 0)
		return (+1);
	return (0);
}

/*
 * Initialization of the code that deals with uid and passwords.
 */
void
smb_pkey_init()
{
	avl_create(&smb_ptd,
	    smb_pkey_cmp,
	    sizeof (smb_passid_t),
	    offsetof(smb_passid_t,
	    cpnode));
	mutex_init(&smb_ptd_lock, NULL, MUTEX_DEFAULT, NULL);
}

/*
 * Destroy the full AVL tree.
 * Called just before unload.
 */
void
smb_pkey_fini()
{
	(void) smb_pkey_deluid((uid_t)-1, kcred);
	avl_destroy(&smb_ptd);
	mutex_destroy(&smb_ptd_lock);
}

/*
 * Driver unload calls this to ask if we
 * have any stored passwords
 */
int
smb_pkey_idle()
{
	int n;

	mutex_enter(&smb_ptd_lock);
	n = avl_numnodes(&smb_ptd);
	mutex_exit(&smb_ptd_lock);

	return ((n) ? EBUSY : 0);
}

static void
smb_pkey_delete(smb_passid_t *tmp)
{
	ASSERT(MUTEX_HELD(&smb_ptd_lock));
	avl_remove(&smb_ptd, tmp);
	strfree(tmp->srvdom);
	strfree(tmp->username);
	kmem_free(tmp, sizeof (*tmp));
}


/*
 * Remove a node from the AVL tree identified by cpid.
 */
int
smb_pkey_del(smbioc_pk_t *pk, cred_t *cr)
{
	avl_index_t where;
	smb_passid_t buf, *cpid, *tmp;
	uid_t uid;

	tmp = &buf;
	uid = pk->pk_uid;
	if (uid == (uid_t)-1)
		uid = crgetruid(cr);
	else {
		if (secpolicy_smbfs_login(cr, uid))
			return (EPERM);
	}
	tmp->uid = uid;
	tmp->zoneid = getzoneid();
	tmp->srvdom = pk->pk_dom;
	tmp->username = pk->pk_usr;

	mutex_enter(&smb_ptd_lock);
	if ((cpid = (smb_passid_t *)avl_find(&smb_ptd,
	    tmp, &where)) != NULL) {
		smb_pkey_delete(cpid);
	}
	mutex_exit(&smb_ptd_lock);

	return (0);
}

/*
 * Delete the entries owned by a particular user
 * based on uid. We go through all the nodes and
 * delete the nodes whereever the uid matches.
 *
 * Also implements "delete all" when uid == -1.
 *
 * You must have privilege to use any uid other
 * than your real uid.
 */
int
smb_pkey_deluid(uid_t ioc_uid, cred_t *cr)
{
	smb_passid_t *cpid, *tmp;

	if (secpolicy_smbfs_login(cr, ioc_uid))
		return (EPERM);

	mutex_enter(&smb_ptd_lock);
	for (tmp = avl_first(&smb_ptd); tmp != NULL;
	    tmp = cpid) {
		cpid = AVL_NEXT(&smb_ptd, tmp);
		if (ioc_uid == (uid_t)-1 ||
		    ioc_uid == tmp->uid) {
			/*
			 * Delete the node.
			 */
			smb_pkey_delete(tmp);
		}
	}
	mutex_exit(&smb_ptd_lock);

	return (0);
}

/*
 * Add entry or modify existing.
 * Check for existing entry..
 * If present, delete.
 * Now, add the new entry.
 */
int
smb_pkey_add(smbioc_pk_t *pk, cred_t *cr)
{
	avl_tree_t *t = &smb_ptd;
	avl_index_t	where;
	smb_passid_t *tmp, *cpid;
	int ret;
	uid_t uid;

	uid = pk->pk_uid;
	if (uid == (uid_t)-1)
		uid = crgetruid(cr);
	else {
		if (secpolicy_smbfs_login(cr, uid))
			return (EPERM);
	}
	cpid = kmem_zalloc(sizeof (smb_passid_t), KM_SLEEP);
	cpid->uid = uid;
	cpid->zoneid = getzoneid();
	cpid->srvdom = strdup(pk->pk_dom);
	cpid->username = strdup(pk->pk_usr);
	bcopy(pk->pk_lmhash, cpid->lmhash, SMBIOC_HASH_SZ);
	bcopy(pk->pk_nthash, cpid->nthash, SMBIOC_HASH_SZ);

	/*
	 * XXX: Instead of calling smb_pkey_check here,
	 * should call avl_find directly, and hold the
	 * lock across: avl_find, avl_remove, avl_insert.
	 */

	/* If it already exists, delete it. */
	ret = smb_pkey_check(pk, cr);
	if (ret == 0) {
		(void) smb_pkey_del(pk, cr);
	}

	mutex_enter(&smb_ptd_lock);
	tmp = (smb_passid_t *)avl_find(t, cpid, &where);
	if (tmp == NULL) {
		avl_insert(t, cpid, where);
	} else {
		strfree(cpid->srvdom);
		strfree(cpid->username);
		kmem_free(cpid, sizeof (smb_passid_t));
	}
	mutex_exit(&smb_ptd_lock);

	return (0);
}

/*
 * Determine if a node with uid,zoneid, uname & dname exists in the tree
 * given the information, and if found, return the hashes.
 */
int
smb_pkey_check(smbioc_pk_t *pk, cred_t *cr)
{
	avl_tree_t *t = &smb_ptd;
	avl_index_t	where;
	smb_passid_t *tmp, *cpid;
	int error = ENOENT;
	uid_t uid;

	uid = pk->pk_uid;
	if (uid == (uid_t)-1)
		uid = crgetruid(cr);
	else {
		if (secpolicy_smbfs_login(cr, uid))
			return (EPERM);
	}
	cpid = kmem_alloc(sizeof (smb_passid_t), KM_SLEEP);
	cpid->uid = uid;
	cpid->zoneid = getzoneid();
	cpid->srvdom = pk->pk_dom;
	cpid->username = pk->pk_usr;

	mutex_enter(&smb_ptd_lock);
	tmp = (smb_passid_t *)avl_find(t, cpid, &where);
	mutex_exit(&smb_ptd_lock);

	if (tmp != NULL) {
		bcopy(tmp->lmhash, pk->pk_lmhash, SMBIOC_HASH_SZ);
		bcopy(tmp->nthash, pk->pk_nthash, SMBIOC_HASH_SZ);
		error = 0;
	}

	kmem_free(cpid, sizeof (smb_passid_t));
	return (error);
}


int
smb_pkey_ioctl(int cmd, intptr_t arg, int flags, cred_t *cr)
{
	smbioc_pk_t  *pk;
	uid_t uid;
	int err = 0;

	pk = kmem_alloc(sizeof (*pk), KM_SLEEP);

	switch (cmd) {
	case SMBIOC_PK_ADD:
	case SMBIOC_PK_DEL:
	case SMBIOC_PK_CHK:
		if (ddi_copyin((void *)arg, pk,
		    sizeof (*pk), flags)) {
			err = EFAULT;
			goto out;
		}
		/* Make strlen (etc) on these safe. */
		pk->pk_dom[SMBIOC_MAX_NAME-1] = '\0';
		pk->pk_usr[SMBIOC_MAX_NAME-1] = '\0';
		break;
	}

	switch (cmd) {
	case SMBIOC_PK_ADD:
		err = smb_pkey_add(pk, cr);
		break;

	case SMBIOC_PK_DEL:
		err = smb_pkey_del(pk, cr);
		break;

	case SMBIOC_PK_CHK:
		err = smb_pkey_check(pk, cr);
		/* This is just a hash now. */
		(void) ddi_copyout(pk, (void *)arg,
		    sizeof (*pk), flags);
		break;

	case SMBIOC_PK_DEL_OWNER:
		uid = crgetruid(cr);
		err = smb_pkey_deluid(uid, cr);
		break;

	case SMBIOC_PK_DEL_EVERYONE:
		uid = (uid_t)-1;
		err = smb_pkey_deluid(uid, cr);
		break;

	default:
		err = ENODEV;
	}

out:
	kmem_free(pk, sizeof (*pk));
	return (err);
}