1374 lines
29 KiB
C
1374 lines
29 KiB
C
![]() |
/* $NetBSD: smb_conn.c,v 1.1 2000/12/07 03:48:09 deberg Exp $ */
|
||
|
|
||
|
/*
|
||
|
* Copyright (c) 2000, 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.
|
||
|
*/
|
||
|
|
||
|
#include <sys/param.h>
|
||
|
#include <sys/systm.h>
|
||
|
#include <sys/kernel.h>
|
||
|
#include <sys/malloc.h>
|
||
|
#include <sys/proc.h>
|
||
|
#include <sys/lock.h>
|
||
|
#include <uvm/uvm_extern.h>
|
||
|
#include <sys/sysctl.h>
|
||
|
#include <sys/socket.h>
|
||
|
#include <sys/socketvar.h>
|
||
|
|
||
|
#include <sys/tree.h>
|
||
|
|
||
|
#include "iconv.h"
|
||
|
|
||
|
#include <netsmb/smb.h>
|
||
|
#include <netsmb/smb_conn.h>
|
||
|
#include <netsmb/smb_rq.h>
|
||
|
#include <netsmb/smb_subr.h>
|
||
|
#include <netsmb/smb_tran.h>
|
||
|
#include <netsmb/smb_trantcp.h>
|
||
|
|
||
|
static struct tree cetree;
|
||
|
|
||
|
extern struct linker_set sysctl_net_smb;
|
||
|
|
||
|
#ifdef SYSCTL_DECL
|
||
|
SYSCTL_DECL(_net_smb);
|
||
|
#endif
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
SYSCTL_NODE(_net, OID_AUTO, smb, CTLFLAG_RW, NULL, "SMB protocol");
|
||
|
|
||
|
MALLOC_DEFINE(M_SMBCONN, "SMB conn", "SMB connection");
|
||
|
#endif
|
||
|
|
||
|
#ifdef NetBSD
|
||
|
static struct callout smb_timer_ch;
|
||
|
#endif
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
static struct callout_handle smb_timer_handle;
|
||
|
#endif
|
||
|
static int smb_timer_tick;
|
||
|
|
||
|
static void smb_conn_free(struct smb_conn *scp);
|
||
|
static void smb_vc_free(struct smb_vc *vcp);
|
||
|
static void smb_share_free(struct smb_share *ssp);
|
||
|
static void smb_conn_gone(struct smb_conn *scp, struct smb_cred *scred);
|
||
|
static void smb_vc_gone(struct smb_vc *vcp, struct smb_cred *scred);
|
||
|
static void smb_vc_timo(struct smb_vc *vcp);
|
||
|
static void smb_share_gone(struct smb_share *ssp, struct smb_cred *scred);
|
||
|
static void smb_timer(void *arg);
|
||
|
#ifndef NetBSD
|
||
|
#if __FreeBSD_version > 500000
|
||
|
static int smb_sysctl_treedump(SYSCTL_HANDLER_ARGS);
|
||
|
#else
|
||
|
static int smb_sysctl_treedump SYSCTL_HANDLER_ARGS;
|
||
|
#endif
|
||
|
#endif
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
SYSCTL_PROC(_net_smb, OID_AUTO, treedump, CTLFLAG_RD | CTLTYPE_OPAQUE,
|
||
|
NULL, 0, smb_sysctl_treedump, "S,treedump", "Requester tree");
|
||
|
#endif
|
||
|
|
||
|
static int
|
||
|
smb_sm_node_alloc(struct tnode *tp, void *data)
|
||
|
{
|
||
|
struct smb_ce *cep;
|
||
|
struct smb_conn *scp;
|
||
|
struct smb_share *ssp;
|
||
|
struct smb_vc *vcp;
|
||
|
int error, ntype;
|
||
|
|
||
|
error = 0;
|
||
|
ntype = TTYPE(tp);
|
||
|
switch(ntype) {
|
||
|
case TSMB_CE:
|
||
|
MALLOC(cep, struct smb_ce *, sizeof(*cep), M_SMBCONN, M_WAITOK);
|
||
|
if (cep == NULL)
|
||
|
return ENOMEM;
|
||
|
bzero(cep, sizeof(*cep));
|
||
|
cep->ce_nextconn = 1;
|
||
|
TNTOCE(tp) = cep;
|
||
|
CETOTN(cep) = tp;
|
||
|
break;
|
||
|
case TSMB_CONN:
|
||
|
if (tp->t_tree->tr_root == NULL) {
|
||
|
SMBERROR("no root");
|
||
|
return EINVAL;
|
||
|
}
|
||
|
MALLOC(scp, struct smb_conn*, sizeof(*scp), M_SMBCONN, M_WAITOK);
|
||
|
if (scp == NULL)
|
||
|
return ENOMEM;
|
||
|
bzero(scp, sizeof(*scp));
|
||
|
TNTOCN(tp) = scp;
|
||
|
CNTOTN(scp) = tp;
|
||
|
break;
|
||
|
case TSMB_VC:
|
||
|
MALLOC(vcp, struct smb_vc*, sizeof(*vcp), M_SMBCONN, M_WAITOK);
|
||
|
if (vcp == NULL)
|
||
|
return ENOMEM;
|
||
|
bzero(vcp, sizeof(*vcp));
|
||
|
TNTOVC(tp) = vcp;
|
||
|
VCTOTN(vcp) = tp;
|
||
|
break;
|
||
|
case TSMB_SHARE:
|
||
|
MALLOC(ssp, struct smb_share*, sizeof(*ssp), M_SMBCONN, M_WAITOK);
|
||
|
if (ssp == NULL)
|
||
|
return ENOMEM;
|
||
|
bzero(ssp, sizeof(*ssp));
|
||
|
TNTOSS(tp) = ssp;
|
||
|
SSTOTN(ssp) = tp;
|
||
|
break;
|
||
|
default:
|
||
|
return EINVAL;
|
||
|
}
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
smb_sm_node_free(struct tnode *tp)
|
||
|
{
|
||
|
struct smb_ce *cep;
|
||
|
|
||
|
if (tp->t_mdata == NULL)
|
||
|
return;
|
||
|
switch (TTYPE(tp)) {
|
||
|
case TSMB_CE:
|
||
|
cep = TNTOCE(tp);
|
||
|
free(cep, M_SMBCONN);
|
||
|
break;
|
||
|
case TSMB_CONN:
|
||
|
smb_conn_free(TNTOCN(tp));
|
||
|
break;
|
||
|
case TSMB_VC:
|
||
|
smb_vc_free(TNTOVC(tp));
|
||
|
break;
|
||
|
case TSMB_SHARE:
|
||
|
smb_share_free(TNTOSS(tp));
|
||
|
break;
|
||
|
default:
|
||
|
return;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
smb_sm_node_gone(struct tnode *tp, struct proc *p)
|
||
|
{
|
||
|
struct smb_cred scred;
|
||
|
|
||
|
if (!TISGONE(tp)) {
|
||
|
SMBERROR("bug in the tree.c code: gone\n");
|
||
|
tunlock(tp, 0, p);
|
||
|
return;
|
||
|
}
|
||
|
smb_makescred(&scred, p, NULL);
|
||
|
switch (TTYPE(tp)) {
|
||
|
case TSMB_CE:
|
||
|
tunlock(tp, 0, p);
|
||
|
break;
|
||
|
case TSMB_CONN:
|
||
|
smb_conn_gone(TNTOCN(tp), &scred);
|
||
|
break;
|
||
|
case TSMB_VC:
|
||
|
smb_vc_gone(TNTOVC(tp), &scred);
|
||
|
break;
|
||
|
case TSMB_SHARE:
|
||
|
smb_share_gone(TNTOSS(tp), &scred);
|
||
|
break;
|
||
|
default:
|
||
|
return;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
|
||
|
struct tnode_ops smb_connops = {
|
||
|
smb_sm_node_alloc,
|
||
|
smb_sm_node_free,
|
||
|
NULL,
|
||
|
smb_sm_node_gone
|
||
|
};
|
||
|
|
||
|
int
|
||
|
smb_sm_init(void)
|
||
|
{
|
||
|
struct compname cn;
|
||
|
struct tnode *tp;
|
||
|
struct timeval tv;
|
||
|
int error;
|
||
|
|
||
|
tree_init(&cetree, &smb_connops);
|
||
|
compname_init(&cn, "\\\\", 0, curproc);
|
||
|
error = tree_node_alloc(&cetree, &cn, TFL_DIR | TSMB_CE, NULL, &tp);
|
||
|
if (error)
|
||
|
return error;
|
||
|
cetree.tr_root = tp;
|
||
|
tunlock(tp, 0, curproc);
|
||
|
tv.tv_sec = 1;
|
||
|
tv.tv_usec = 0;
|
||
|
#ifndef NetBSD
|
||
|
smb_timer_tick = tvtohz(&tv);
|
||
|
smb_timer_handle = timeout(smb_timer, NULL, smb_timer_tick);
|
||
|
#else
|
||
|
callout_init(&smb_timer_ch);
|
||
|
smb_timer_tick = hzto(&tv);
|
||
|
callout_reset(&smb_timer_ch, smb_timer_tick, smb_timer, NULL);
|
||
|
#endif
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_sm_done(void)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
untimeout(smb_timer, NULL, smb_timer_handle);
|
||
|
#else
|
||
|
callout_stop(&smb_timer_ch);
|
||
|
#endif
|
||
|
tp = cetree.tr_root;
|
||
|
trele(tp);
|
||
|
if (!TISGONE(tp)) {
|
||
|
SMBERROR("%d connections were active\n", tp->t_usecount);
|
||
|
return EBUSY;
|
||
|
}
|
||
|
tree_node_free(tp);
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
static int
|
||
|
smb_sm_getce(struct smb_cred *scred, int flags, struct smb_ce **cepp)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
struct smb_ce *cep;
|
||
|
|
||
|
tp = cetree.tr_root;
|
||
|
cep = TNTOCE(tp);
|
||
|
*cepp = cep;
|
||
|
if (flags == 0)
|
||
|
return 0;
|
||
|
return smb_ce_lock(cep, flags, scred->scr_p);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Connection engine implementation
|
||
|
*/
|
||
|
static int
|
||
|
smb_ce_cmpconn(struct tnode *tp, void *data)
|
||
|
{
|
||
|
struct smb_conn *scp = TNTOCN(tp);
|
||
|
struct smb_connspec *dp = data;
|
||
|
int error;
|
||
|
|
||
|
if (TTYPE(tp) != TSMB_CONN || !TISDIR(tp)) {
|
||
|
SMBERROR("wrong type for node %s\n", tp->t_name);
|
||
|
return 1;
|
||
|
}
|
||
|
if (!CONNADDREQ(scp->sc_paddr, dp->sap))
|
||
|
return 1;
|
||
|
if (dp->vcspec == NULL)
|
||
|
return 0;
|
||
|
error = smb_conn_lookupvc(scp, dp->vcspec, dp->scred, &dp->vcp);
|
||
|
return error == 0 ? 0 : 1;
|
||
|
}
|
||
|
|
||
|
static int
|
||
|
smb_ce_lookupconn(smb_rc_t cep, struct smb_connspec *csp,
|
||
|
struct smb_cred *scred, struct smb_conn **scpp)
|
||
|
{
|
||
|
struct tnode *dtp, *tp;
|
||
|
int error;
|
||
|
|
||
|
dtp = CETOTN(cep);
|
||
|
csp->scred = scred;
|
||
|
csp->vcp = NULL;
|
||
|
error = tree_node_lookupbin(dtp, smb_ce_cmpconn, csp, &tp);
|
||
|
if (error == 0)
|
||
|
*scpp = TNTOCN(tp);
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Lock entire conn/share tree
|
||
|
*/
|
||
|
int
|
||
|
smb_ce_lock(smb_rc_t cep, int flags, struct proc *p)
|
||
|
{
|
||
|
#if 0
|
||
|
struct tnode *tp = CETOTN(cep);
|
||
|
|
||
|
return tlock(tp, flags | LK_CANRECURSE, p);
|
||
|
#endif
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_ce_unlock(smb_rc_t cep, struct proc *p)
|
||
|
{
|
||
|
#if 0
|
||
|
struct tnode *tp = CETOTN(cep);
|
||
|
|
||
|
tunlock(tp, 0, p);
|
||
|
#endif
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Allocate new connection with given name(addr).
|
||
|
*/
|
||
|
int
|
||
|
smb_ce_createconn(struct smb_connspec *csp,
|
||
|
struct smb_cred *scred, struct smb_conn **scpp)
|
||
|
{
|
||
|
smb_rc_t cep;
|
||
|
struct smb_conn *scp;
|
||
|
struct tnode *dtp, *tp;
|
||
|
struct compname cn;
|
||
|
struct proc *p = scred->scr_p;
|
||
|
int error;
|
||
|
|
||
|
error = smb_sm_getce(scred, LK_EXCLUSIVE, &cep);
|
||
|
if (error)
|
||
|
return error;
|
||
|
csp->vcspec = NULL;
|
||
|
error = smb_ce_lookupconn(cep, csp, scred, &scp);
|
||
|
if (!error) {
|
||
|
smb_conn_put(scp, scred);
|
||
|
smb_ce_unlock(cep, p);
|
||
|
return EEXIST;
|
||
|
}
|
||
|
dtp = CETOTN(cep);
|
||
|
compname_init(&cn, csp->name, 0, p);
|
||
|
error = tree_node_alloc(dtp->t_tree, &cn, TSMB_CONN | TFL_DIR, NULL, &tp);
|
||
|
if (error) {
|
||
|
smb_ce_unlock(cep, p);
|
||
|
return error;
|
||
|
}
|
||
|
scp = TNTOCN(tp);
|
||
|
cep->ce_conncnt++;
|
||
|
scp->sc_index = cep->ce_nextconn++;
|
||
|
scp->sc_paddr = dup_sockaddr(csp->sap, 1);
|
||
|
scp->sc_timo = SMB_DEFRQTIMO;
|
||
|
tree_node_addchild(dtp, tp);
|
||
|
*scpp = scp;
|
||
|
smb_ce_unlock(cep, p);
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* General lookup in the tree.
|
||
|
*/
|
||
|
int
|
||
|
smb_sm_lookup(struct smb_connspec *cnspec, struct smb_vcspec *vcspec,
|
||
|
struct smb_sharespec *shspec, struct smb_cred *scred,
|
||
|
struct smb_conn **scpp)
|
||
|
{
|
||
|
struct smb_conn *scp;
|
||
|
struct smb_ce *cep;
|
||
|
int error;
|
||
|
|
||
|
*scpp = NULL;
|
||
|
error = smb_sm_getce(scred, LK_SHARED, &cep);
|
||
|
if (error)
|
||
|
return error;
|
||
|
cnspec->vcspec = vcspec;
|
||
|
if (vcspec)
|
||
|
vcspec->shspec = shspec;
|
||
|
error = smb_ce_lookupconn(cep, cnspec, scred, &scp);
|
||
|
if (error == 0) {
|
||
|
if (smb_conn_get(scp, scred) != 0) {
|
||
|
if (cnspec->vcp)
|
||
|
smb_vc_put(cnspec->vcp, scred);
|
||
|
if (vcspec && vcspec->ssp)
|
||
|
smb_share_put(vcspec->ssp, scred->scr_p);
|
||
|
error = ENOENT;
|
||
|
} else
|
||
|
*scpp = scp;
|
||
|
} else
|
||
|
error = ENOENT;
|
||
|
smb_ce_unlock(cep, scred->scr_p);
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Connection implementation
|
||
|
*/
|
||
|
static void
|
||
|
smb_conn_free(struct smb_conn *scp)
|
||
|
{
|
||
|
if (scp == NULL)
|
||
|
return;
|
||
|
if (scp->sc_paddr)
|
||
|
free(scp->sc_paddr, M_SONAME);
|
||
|
if (scp->sc_laddr)
|
||
|
free(scp->sc_laddr, M_SONAME);
|
||
|
if (scp->sc_tolower)
|
||
|
iconv_close(scp->sc_tolower);
|
||
|
if (scp->sc_toupper)
|
||
|
iconv_close(scp->sc_toupper);
|
||
|
if (scp->sc_tolocal)
|
||
|
iconv_close(scp->sc_tolocal);
|
||
|
if (scp->sc_toserver)
|
||
|
iconv_close(scp->sc_toserver);
|
||
|
free(scp, M_SMBCONN);
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_conn_get(struct smb_conn *scp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
int error;
|
||
|
|
||
|
tp = CNTOTN(scp);
|
||
|
if (TISGONE(tp))
|
||
|
return EINVAL;
|
||
|
error = tget(tp, LK_EXCLUSIVE | LK_CANRECURSE, scred->scr_p);
|
||
|
if (error == ERESTART)
|
||
|
return EINTR;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
smb_conn_gone(struct smb_conn *scp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp, *dtp;
|
||
|
struct smb_ce *cep;
|
||
|
struct proc *p = scred->scr_p;
|
||
|
int error;
|
||
|
|
||
|
tp = CNTOTN(scp);
|
||
|
dtp = tp->t_parent;
|
||
|
cep = TNTOCE(dtp);
|
||
|
error = tget(dtp, LK_EXCLUSIVE, p);
|
||
|
if (error) {
|
||
|
SMBERROR("can't lock parent %s", dtp->t_name);
|
||
|
tunlock(tp, 0, p);
|
||
|
return;
|
||
|
}
|
||
|
tree_node_rmchild(dtp, tp);
|
||
|
tput(dtp, p);
|
||
|
tunlock(tp, 0, p);
|
||
|
tree_node_free(tp);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_conn_put(struct smb_conn *scp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
|
||
|
tp = CNTOTN(scp);
|
||
|
if (TISGONE(tp)) {
|
||
|
SMBERROR("too bad, node %s is already gone\n", tp->t_name);
|
||
|
return;
|
||
|
}
|
||
|
tput(tp, scred->scr_p);
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
smb_conn_rele(struct smb_conn *scp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
|
||
|
tp = CNTOTN(scp);
|
||
|
if (!TISGONE(tp)) {
|
||
|
trele(tp);
|
||
|
if (!TISGONE(tp))
|
||
|
return;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
static int
|
||
|
smb_conn_cmpvc(struct tnode *tp, void *data)
|
||
|
{
|
||
|
struct smb_vc *vcp = TNTOVC(tp);
|
||
|
struct smb_vcspec *dp = data;
|
||
|
int exact = 1;
|
||
|
|
||
|
if (strcmp(tp->t_name, dp->user) != 0)
|
||
|
return 1;
|
||
|
if ((vcp->vc_flags & SMBV_PRIVATE) &&
|
||
|
vcp->vc_uid != dp->scred->scr_cred->cr_uid)
|
||
|
return 1;
|
||
|
if (dp->owner != SMBM_ANY_OWNER) {
|
||
|
if (vcp->vc_uid != dp->owner)
|
||
|
return 1;
|
||
|
} else
|
||
|
exact = 0;
|
||
|
if (dp->group != SMBM_ANY_GROUP) {
|
||
|
if (vcp->vc_grp != dp->group)
|
||
|
return 1;
|
||
|
} else
|
||
|
exact = 0;
|
||
|
|
||
|
if (dp->mode & SMBM_EXACT) {
|
||
|
if (!exact)
|
||
|
return 1;
|
||
|
return (dp->mode & SMBM_MASK) == vcp->vc_mode ? 0 : 1;
|
||
|
}
|
||
|
if (smb_vc_access(vcp, dp->scred, dp->mode) != 0)
|
||
|
return 1;
|
||
|
if (dp->shspec == NULL)
|
||
|
return 0;
|
||
|
dp->ssp = NULL;
|
||
|
return smb_vc_lookupshare(vcp, dp->shspec, dp->scred, &dp->ssp) ? 1 : 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Lookup VC in the connection. VC referenced and locked on return.
|
||
|
* Connection expected to be locked on entry and will be left locked
|
||
|
* on exit.
|
||
|
*/
|
||
|
int
|
||
|
smb_conn_lookupvc(struct smb_conn *scp, struct smb_vcspec *vcsp,
|
||
|
struct smb_cred *scred, struct smb_vc **vcpp)
|
||
|
{
|
||
|
struct smb_vc *vcp;
|
||
|
struct tnode *dtp, *tp;
|
||
|
int error;
|
||
|
|
||
|
*vcpp = NULL;
|
||
|
dtp = CNTOTN(scp);
|
||
|
vcsp->scred = scred;
|
||
|
error = tree_node_lookupbin(dtp, smb_conn_cmpvc, vcsp, &tp);
|
||
|
if (error == 0) {
|
||
|
vcp = TNTOVC(tp);
|
||
|
if (smb_vc_get(vcp, scred) != 0)
|
||
|
error = ENOENT;
|
||
|
else
|
||
|
*vcpp = vcp;
|
||
|
} else
|
||
|
error = ENOENT;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_conn_lock(struct smb_conn *scp, struct proc *p)
|
||
|
{
|
||
|
/* return tlock(CNTOTN(scp), LK_EXCLUSIVE, p); */
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
int
|
||
|
smb_conn_unlock(struct smb_conn *scp, struct proc *p)
|
||
|
{
|
||
|
/* return tunlock(CNTOTN(scp), 0, p); */
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
void
|
||
|
smb_conn_timo(struct smb_conn *scp)
|
||
|
{
|
||
|
struct tnode *tp, *parent;
|
||
|
|
||
|
parent = CNTOTN(scp);
|
||
|
SLIST_FOREACH(tp, &parent->t_ddata->tm_children, t_link)
|
||
|
smb_vc_timo(TNTOVC(tp));
|
||
|
}
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
static int
|
||
|
smb_conn_getinfo(struct smb_conn *scp, struct smb_conn_info *cip)
|
||
|
{
|
||
|
bzero(cip, sizeof(struct smb_conn_info));
|
||
|
cip->itype = SMB_INFO_CONN;
|
||
|
cip->usecount = CNTOTN(scp)->t_usecount;
|
||
|
cip->flags = scp->sc_flags;
|
||
|
snprintf(cip->srvname, sizeof(cip->srvname), "%s", CNTOTN(scp)->t_name);
|
||
|
return 0;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
static void
|
||
|
smb_timer(void *arg)
|
||
|
{
|
||
|
struct smb_conn *scp;
|
||
|
struct tnode *parent, *tp;
|
||
|
struct smb_ce *cep;
|
||
|
struct smb_cred scred;
|
||
|
|
||
|
smb_makescred(&scred, NULL, NULL);
|
||
|
if (smb_sm_getce(&scred, LK_SHARED | LK_NOWAIT, &cep) == 0) {
|
||
|
parent = CETOTN(cep);
|
||
|
SLIST_FOREACH(tp, &parent->t_ddata->tm_children, t_link) {
|
||
|
scp = TNTOCN(tp);
|
||
|
smb_conn_timo(scp);
|
||
|
}
|
||
|
smb_ce_unlock(cep, NULL);
|
||
|
}
|
||
|
#ifndef NetBSD
|
||
|
smb_timer_handle = timeout(smb_timer, NULL, smb_timer_tick);
|
||
|
#else
|
||
|
callout_reset(&smb_timer_ch, smb_timer_tick, smb_timer, NULL);
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Session implementation
|
||
|
*/
|
||
|
|
||
|
/*
|
||
|
* Allocate VC structure and attach it to the connection.
|
||
|
* Connection expected to be locked on entry. VC will be returned
|
||
|
* in locked state.
|
||
|
*/
|
||
|
int
|
||
|
smb_vc_create(struct smb_vcspec *vcspec, char *pass, const char *domain,
|
||
|
struct smb_conn *scp, struct smb_cred *scred, struct smb_vc **vcpp)
|
||
|
{
|
||
|
struct tnode *tp, *dtp;
|
||
|
struct smb_vc *vcp;
|
||
|
struct compname cn;
|
||
|
struct proc *p = scred->scr_p;
|
||
|
struct ucred *cred = scred->scr_cred;
|
||
|
uid_t uid = vcspec->owner;
|
||
|
gid_t gid = vcspec->group;
|
||
|
uid_t realuid = cred->cr_uid;
|
||
|
int error, isroot;
|
||
|
|
||
|
isroot = smb_suser(cred) == 0;
|
||
|
/*
|
||
|
* Only superuser can create VCs with different uid and gid
|
||
|
*/
|
||
|
if (uid != SMBM_ANY_OWNER && uid != realuid && !isroot)
|
||
|
return EPERM;
|
||
|
if (gid != SMBM_ANY_GROUP && !groupmember(gid, cred) && !isroot)
|
||
|
return EPERM;
|
||
|
error = smb_conn_lookupvc(scp, vcspec, scred, &vcp);
|
||
|
if (!error) {
|
||
|
smb_vc_put(vcp, scred);
|
||
|
return EEXIST;
|
||
|
}
|
||
|
if (uid == SMBM_ANY_OWNER)
|
||
|
uid = realuid;
|
||
|
if (gid == SMBM_ANY_GROUP)
|
||
|
gid = cred->cr_groups[0];
|
||
|
dtp = CNTOTN(scp);
|
||
|
compname_init(&cn, vcspec->user, 0, p);
|
||
|
error = tree_node_alloc(dtp->t_tree, &cn, TSMB_VC | TFL_DIR, NULL, &tp);
|
||
|
if (error) {
|
||
|
return error;
|
||
|
}
|
||
|
vcp = TNTOVC(tp);
|
||
|
vcp->vc_id = SMB_UID_UNKNOWN;
|
||
|
scp->sc_vcnt++;
|
||
|
vcp->vc_domain = smb_strdup((domain && domain[0]) ? domain : "NODOMAIN");
|
||
|
if (vcp->vc_domain == NULL) {
|
||
|
tree_node_free(tp);
|
||
|
return ENOMEM;
|
||
|
}
|
||
|
vcp->vc_uid = uid;
|
||
|
vcp->vc_grp = gid;
|
||
|
vcp->vc_pass = smb_strdup(pass);
|
||
|
vcp->vc_mode = vcspec->rights & SMBM_MASK;
|
||
|
vcp->vc_flags = vcspec->flags & (SMBV_PRIVATE | SMBV_SINGLESHARE);
|
||
|
TAILQ_INIT(&vcp->vc_rqlist);
|
||
|
tree_node_addchild(dtp, tp);
|
||
|
*vcpp = vcp;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
smb_vc_free(struct smb_vc *vcp)
|
||
|
{
|
||
|
if (vcp == NULL)
|
||
|
return;
|
||
|
if (vcp->vc_pass)
|
||
|
smb_strfree(vcp->vc_pass);
|
||
|
if (vcp->vc_domain)
|
||
|
smb_strfree(vcp->vc_domain);
|
||
|
free(vcp, M_SMBCONN);
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_access(struct smb_vc *vcp, struct smb_cred *scred, mode_t mode)
|
||
|
{
|
||
|
struct ucred *cred = scred->scr_cred;
|
||
|
|
||
|
if (smb_suser(cred) == 0 || cred->cr_uid == vcp->vc_uid)
|
||
|
return 0;
|
||
|
mode >>= 3;
|
||
|
if (!groupmember(vcp->vc_grp, cred))
|
||
|
mode >>= 3;
|
||
|
return (vcp->vc_mode & mode) == mode ? 0 : EACCES;
|
||
|
}
|
||
|
|
||
|
|
||
|
int
|
||
|
smb_vc_get(struct smb_vc *vcp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
int error;
|
||
|
|
||
|
tp = VCTOTN(vcp);
|
||
|
if (TISGONE(tp))
|
||
|
return EINVAL;
|
||
|
error = tget(tp, LK_EXCLUSIVE | LK_CANRECURSE, scred->scr_p);
|
||
|
if (error == ERESTART)
|
||
|
return EINTR;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
smb_vc_gone(struct smb_vc *vcp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp, *dtp;
|
||
|
struct smb_conn *scp;
|
||
|
struct proc *p = scred->scr_p;
|
||
|
int error;
|
||
|
|
||
|
tp = VCTOTN(vcp);
|
||
|
dtp = tp->t_parent;
|
||
|
scp = TNTOCN(dtp);
|
||
|
smb_vc_disconnect(vcp, scred);
|
||
|
error = tget(dtp, LK_EXCLUSIVE | LK_CANRECURSE, p);
|
||
|
if (error) {
|
||
|
SMBERROR("can't lock to parent %s", dtp->t_name);
|
||
|
tunlock(tp, 0, p);
|
||
|
return;
|
||
|
}
|
||
|
scp->sc_vcnt--;
|
||
|
tree_node_rmchild(dtp, tp);
|
||
|
tput(dtp, p);
|
||
|
tunlock(tp, 0, p);
|
||
|
tree_node_free(tp);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_vc_put(struct smb_vc *vcp, struct smb_cred *scred)
|
||
|
{
|
||
|
tput(VCTOTN(vcp), scred->scr_p);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_vc_rele(struct smb_vc *vcp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
|
||
|
tp = VCTOTN(vcp);
|
||
|
if (!TISGONE(tp)) {
|
||
|
trele(tp);
|
||
|
if (!TISGONE(tp))
|
||
|
return;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_vc_unlock(struct smb_vc *vcp, int flags, struct smb_cred *scred)
|
||
|
{
|
||
|
tunlock(VCTOTN(vcp), flags, scred->scr_p);
|
||
|
}
|
||
|
|
||
|
static int
|
||
|
smb_vc_cmpshare(struct tnode *tp, void *data)
|
||
|
{
|
||
|
struct smb_share *ssp = TNTOSS(tp);
|
||
|
struct smb_sharespec *dp = data;
|
||
|
int exact = 1;
|
||
|
|
||
|
if (strcmp(tp->t_name, dp->name) != 0)
|
||
|
return 1;
|
||
|
if (dp->owner != SMBM_ANY_OWNER) {
|
||
|
if (ssp->ss_uid != dp->owner)
|
||
|
return 1;
|
||
|
} else
|
||
|
exact = 0;
|
||
|
if (dp->group != SMBM_ANY_GROUP) {
|
||
|
if (ssp->ss_grp != dp->group)
|
||
|
return 1;
|
||
|
} else
|
||
|
exact = 0;
|
||
|
|
||
|
if (dp->mode & SMBM_EXACT) {
|
||
|
if (!exact)
|
||
|
return 1;
|
||
|
return (dp->mode & SMBM_MASK) == ssp->ss_mode ? 0 : 1;
|
||
|
}
|
||
|
if (smb_share_access(ssp, dp->scred, dp->mode) != 0)
|
||
|
return 1;
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Lookup share in the given VC. Share referenced and locked on return.
|
||
|
* VC expected to be locked on entry and will be left locked on exit.
|
||
|
*/
|
||
|
int
|
||
|
smb_vc_lookupshare(struct smb_vc *vcp, struct smb_sharespec *data,
|
||
|
struct smb_cred *scred, struct smb_share **sspp)
|
||
|
{
|
||
|
struct smb_share *ssp;
|
||
|
struct tnode *dtp, *tp;
|
||
|
int error;
|
||
|
|
||
|
*sspp = NULL;
|
||
|
dtp = VCTOTN(vcp);
|
||
|
data->scred = scred;
|
||
|
error = tree_node_lookupbin(dtp, smb_vc_cmpshare, data, &tp);
|
||
|
if (error == 0) {
|
||
|
ssp = TNTOSS(tp);
|
||
|
if (smb_share_get(ssp, scred) != 0)
|
||
|
error = ENOENT;
|
||
|
else
|
||
|
*sspp = ssp;
|
||
|
} else
|
||
|
error = ENOENT;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_connect(struct smb_vc *vcp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct smb_conn *scp = VCTOCN(vcp);
|
||
|
struct sockaddr *sap = scp->sc_paddr;
|
||
|
struct proc *p = scred->scr_p;
|
||
|
struct smb_tran_desc *tdp;
|
||
|
int error, type;
|
||
|
|
||
|
if (vcp->vc_id != SMB_UID_UNKNOWN) {
|
||
|
SMBERROR("called for already opened connection");
|
||
|
return EISCONN;
|
||
|
}
|
||
|
if (sap == NULL)
|
||
|
return EDESTADDRREQ;
|
||
|
|
||
|
type = SMBT_NBTCP; /* now the only known one */
|
||
|
switch (type) {
|
||
|
case SMBT_NBTCP:
|
||
|
tdp = &smb_tran_nbtcp_desc;
|
||
|
break;
|
||
|
default:
|
||
|
return EAFNOSUPPORT;
|
||
|
}
|
||
|
error = smb_vc_tranlock(vcp, p);
|
||
|
if (error)
|
||
|
return error;
|
||
|
itry {
|
||
|
ierror(vcp->vc_tdata != NULL, EINPROGRESS);
|
||
|
vcp->vc_tdesc = tdp;
|
||
|
ithrow(SMB_TRAN_CREATE(vcp, p));
|
||
|
if (scp->sc_laddr) {
|
||
|
ithrow(SMB_TRAN_BIND(vcp, scp->sc_laddr, p));
|
||
|
}
|
||
|
ithrow(SMB_TRAN_CONNECT(vcp, sap, p));
|
||
|
vcp->vc_flags &= ~SMBV_INVALID;
|
||
|
ithrow(smb_smb_negotiate(vcp, scred));
|
||
|
ithrow(smb_smb_ssnsetup(vcp, scred));
|
||
|
} icatch(error) {
|
||
|
smb_vc_disconnect(vcp, scred);
|
||
|
vcp->vc_flags |= SMBV_INVALID;
|
||
|
} ifinally {
|
||
|
smb_vc_tranunlock(vcp, p);
|
||
|
} iendtry;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Destroy VC to server, invalidate shares linked with it.
|
||
|
* Transport should be locked on entry.
|
||
|
*/
|
||
|
int
|
||
|
smb_vc_disconnect(struct smb_vc *vcp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct proc *p = scred->scr_p;
|
||
|
|
||
|
smb_smb_ssnclose(vcp, scred);
|
||
|
smb_vc_invalidate(vcp);
|
||
|
if (vcp->vc_tdata != NULL) {
|
||
|
SMB_TRAN_DISCONNECT(vcp, p);
|
||
|
SMB_TRAN_DONE(vcp, p);
|
||
|
vcp->vc_tdata = NULL;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_reconnect(struct smb_vc *vcp)
|
||
|
{
|
||
|
struct smb_cred *scred = vcp->vc_scred;
|
||
|
struct tnode *tp, *parent;
|
||
|
int error;
|
||
|
|
||
|
error = smb_vc_tranlock(vcp, scred->scr_p);
|
||
|
if (error)
|
||
|
return error;
|
||
|
smb_vc_disconnect(vcp, scred);
|
||
|
smb_vc_tranunlock(vcp, scred->scr_p);
|
||
|
error = smb_vc_connect(vcp, scred);
|
||
|
if (error)
|
||
|
return error;
|
||
|
parent = VCTOTN(vcp);
|
||
|
SLIST_FOREACH(tp, &parent->t_ddata->tm_children, t_link)
|
||
|
smb_share_connect(TNTOSS(tp), scred);
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_vc_invalidate(struct smb_vc *vcp)
|
||
|
{
|
||
|
struct smb_rq *rqp;
|
||
|
struct tnode *tp, *parent;
|
||
|
|
||
|
if (!smb_vc_valid(vcp))
|
||
|
return;
|
||
|
vcp->vc_flags |= SMBV_INVALID;
|
||
|
vcp->vc_id = SMB_UID_UNKNOWN;
|
||
|
/*
|
||
|
* Invalidate all outstanding requests for this connection
|
||
|
*/
|
||
|
TAILQ_FOREACH(rqp, &vcp->vc_rqlist, sr_link) {
|
||
|
if (rqp->sr_rp.mb_top)
|
||
|
continue;
|
||
|
rqp->sr_flags |= SMBR_RESTART;
|
||
|
}
|
||
|
/*
|
||
|
* Mark all dependant shares as dead
|
||
|
*/
|
||
|
parent = VCTOTN(vcp);
|
||
|
SLIST_FOREACH(tp, &parent->t_ddata->tm_children, t_link)
|
||
|
smb_share_invalidate(TNTOSS(tp));
|
||
|
/*
|
||
|
* Interrupt all sleeping (in recv/send) processes
|
||
|
*/
|
||
|
SMB_TRAN_INTR(vcp);
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_valid(struct smb_vc *vcp)
|
||
|
{
|
||
|
return (vcp->vc_flags & SMBV_INVALID) == 0 && vcp->vc_tdata != NULL;
|
||
|
}
|
||
|
|
||
|
static char smb_emptypass[] = "";
|
||
|
|
||
|
char*
|
||
|
smb_vc_pass(struct smb_vc *vcp)
|
||
|
{
|
||
|
if (vcp->vc_pass)
|
||
|
return vcp->vc_pass;
|
||
|
return smb_emptypass;
|
||
|
}
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
static int
|
||
|
smb_vc_getinfo(struct smb_vc *vcp, struct smb_vc_info *vip)
|
||
|
{
|
||
|
bzero(vip, sizeof(struct smb_vc_info));
|
||
|
vip->itype = SMB_INFO_VC;
|
||
|
vip->usecount = VCTOTN(vcp)->t_usecount;
|
||
|
vip->uid = vcp->vc_uid;
|
||
|
vip->gid = vcp->vc_grp;
|
||
|
vip->mode = vcp->vc_mode;
|
||
|
vip->flags = vcp->vc_flags;
|
||
|
vip->sopt = vcp->vc_sopt;
|
||
|
bzero(&vip->sopt.sv_skey, sizeof(vip->sopt.sv_skey));
|
||
|
snprintf(vip->vcname, sizeof(vip->vcname), "%s", VCTOTN(vcp)->t_name);
|
||
|
return 0;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
static void
|
||
|
smb_vc_timo(struct smb_vc *vcp)
|
||
|
{
|
||
|
if (vcp->vc_locks & SMBV_LOCK)
|
||
|
return;
|
||
|
if (vcp->vc_tdata != NULL)
|
||
|
SMB_TRAN_TIMO(vcp);
|
||
|
}
|
||
|
|
||
|
u_short
|
||
|
smb_vc_nextmid(struct smb_vc *vcp)
|
||
|
{
|
||
|
u_short r;
|
||
|
|
||
|
simple_lock(&vcp->vc_tnode->t_interlock);
|
||
|
r = vcp->vc_mid++;
|
||
|
simple_unlock(&vcp->vc_tnode->t_interlock);
|
||
|
return r;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_tranlock(struct smb_vc *vcp, struct proc *p)
|
||
|
{
|
||
|
u_int *statep = &vcp->vc_locks;
|
||
|
int slpflag = 0, slptimeo = 0;
|
||
|
|
||
|
slpflag = PCATCH;
|
||
|
while (*statep & SMBV_LOCK) {
|
||
|
if (smb_proc_intr(p))
|
||
|
return EINTR;
|
||
|
*statep |= SMBV_WANT;
|
||
|
(void)tsleep((caddr_t)statep, slpflag | (PZERO - 1),
|
||
|
"smbtrlk", slptimeo);
|
||
|
if (slpflag == PCATCH) {
|
||
|
slpflag = 0;
|
||
|
slptimeo = 2 * hz;
|
||
|
}
|
||
|
}
|
||
|
*statep |= SMBV_LOCK;
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_tranunlock(struct smb_vc *vcp, struct proc *p)
|
||
|
{
|
||
|
u_int *statep = &vcp->vc_locks;
|
||
|
|
||
|
if ((*statep & SMBV_LOCK) == 0)
|
||
|
SMBPANIC("not locked\n");
|
||
|
*statep &= ~SMBV_LOCK;
|
||
|
if (*statep & SMBV_WANT) {
|
||
|
*statep &= ~SMBV_WANT;
|
||
|
wakeup((caddr_t)statep);
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_rqlock(struct smb_vc *vcp, struct proc *p)
|
||
|
{
|
||
|
u_int *statep = &vcp->vc_locks;
|
||
|
int slpflag = 0, slptimeo = 0;
|
||
|
|
||
|
slpflag = PCATCH;
|
||
|
while (*statep & SMBV_RQLISTLOCK) {
|
||
|
if (smb_proc_intr(p))
|
||
|
return EINTR;
|
||
|
*statep |= SMBV_RQLISTWANT;
|
||
|
(void)tsleep((caddr_t)statep, slpflag | (PZERO - 1),
|
||
|
"smbrqlk", slptimeo);
|
||
|
if (slpflag == PCATCH) {
|
||
|
slpflag = 0;
|
||
|
slptimeo = 2 * hz;
|
||
|
}
|
||
|
}
|
||
|
*statep |= SMBV_RQLISTLOCK;
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_vc_rqunlock(struct smb_vc *vcp, struct proc *p)
|
||
|
{
|
||
|
u_int *statep = &vcp->vc_locks;
|
||
|
|
||
|
if ((*statep & SMBV_RQLISTLOCK) == 0)
|
||
|
SMBPANIC("not locked\n");
|
||
|
*statep &= ~SMBV_RQLISTLOCK;
|
||
|
if (*statep & SMBV_RQLISTWANT) {
|
||
|
*statep &= ~SMBV_RQLISTWANT;
|
||
|
wakeup((caddr_t)statep);
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Share implementation
|
||
|
*/
|
||
|
/*
|
||
|
* Allocate share structure and attach it to the VC
|
||
|
* Connection expected to be locked on entry. Share will be returned
|
||
|
* in locked state.
|
||
|
*/
|
||
|
int
|
||
|
smb_share_create(struct smb_vc *vcp, struct smb_sharespec *shspec,
|
||
|
struct smb_cred *scred, struct smb_share **sspp)
|
||
|
{
|
||
|
struct tnode *tp, *dtp;
|
||
|
struct smb_share *ssp;
|
||
|
struct compname cn;
|
||
|
struct proc *p = scred->scr_p;
|
||
|
struct ucred *cred = scred->scr_cred;
|
||
|
uid_t realuid = cred->cr_uid;
|
||
|
uid_t uid = shspec->owner;
|
||
|
gid_t gid = shspec->group;
|
||
|
int error, isroot;
|
||
|
|
||
|
isroot = smb_suser(cred) == 0;
|
||
|
/*
|
||
|
* Only superuser can create shares with different uid and gid
|
||
|
*/
|
||
|
if (uid != SMBM_ANY_OWNER && uid != realuid && !isroot)
|
||
|
return EPERM;
|
||
|
if (gid != SMBM_ANY_GROUP && !groupmember(gid, cred) && !isroot)
|
||
|
return EPERM;
|
||
|
error = smb_vc_lookupshare(vcp, shspec, scred, &ssp);
|
||
|
if (!error) {
|
||
|
smb_share_put(ssp, scred->scr_p);
|
||
|
return EEXIST;
|
||
|
}
|
||
|
if (uid == SMBM_ANY_OWNER)
|
||
|
uid = realuid;
|
||
|
if (gid == SMBM_ANY_GROUP)
|
||
|
gid = cred->cr_groups[0];
|
||
|
dtp = VCTOTN(vcp);
|
||
|
compname_init(&cn, shspec->name, 0, p);
|
||
|
error = tree_node_alloc(dtp->t_tree, &cn, TSMB_SHARE, NULL, &tp);
|
||
|
if (error) {
|
||
|
return error;
|
||
|
}
|
||
|
ssp = TNTOSS(tp);
|
||
|
ssp->ss_type = shspec->stype;
|
||
|
ssp->ss_id = SMB_TID_UNKNOWN;
|
||
|
ssp->ss_uid = uid;
|
||
|
ssp->ss_grp = gid;
|
||
|
ssp->ss_mode = shspec->rights & SMBM_MASK;
|
||
|
tree_node_addchild(dtp, tp);
|
||
|
*sspp = ssp;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
smb_share_free(struct smb_share *ssp)
|
||
|
{
|
||
|
if (ssp == NULL)
|
||
|
return;
|
||
|
if (ssp->ss_pass)
|
||
|
smb_strfree(ssp->ss_pass);
|
||
|
free(ssp, M_SMBCONN);
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
smb_share_gone(struct smb_share *ssp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp, *dtp;
|
||
|
struct smb_vc *vcp;
|
||
|
struct proc *p = scred->scr_p;
|
||
|
int error;
|
||
|
|
||
|
tp = SSTOTN(ssp);
|
||
|
dtp = tp->t_parent;
|
||
|
vcp = TNTOVC(dtp);
|
||
|
smb_share_detach(ssp, scred);
|
||
|
error = tget(dtp, LK_EXCLUSIVE, p);
|
||
|
if (error) {
|
||
|
SMBERROR("can't lock parent %s\n", dtp->t_name);
|
||
|
tunlock(tp, 0, p);
|
||
|
return;
|
||
|
}
|
||
|
tree_node_rmchild(dtp, tp);
|
||
|
tput(dtp, p);
|
||
|
tunlock(tp, 0, p);
|
||
|
tree_node_free(tp);
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_share_access(struct smb_share *ssp, struct smb_cred *scred, mode_t mode)
|
||
|
{
|
||
|
struct ucred *cred = scred->scr_cred;
|
||
|
|
||
|
if (smb_suser(cred) == 0 || cred->cr_uid == ssp->ss_uid)
|
||
|
return 0;
|
||
|
mode >>= 3;
|
||
|
if (!groupmember(ssp->ss_grp, cred))
|
||
|
mode >>= 3;
|
||
|
return (ssp->ss_mode & mode) == mode ? 0 : EACCES;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_share_get(struct smb_share *ssp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
int error;
|
||
|
|
||
|
tp = SSTOTN(ssp);
|
||
|
if (TISGONE(tp))
|
||
|
return EINVAL;
|
||
|
error = tget(tp, LK_EXCLUSIVE | LK_CANRECURSE, scred->scr_p);
|
||
|
if (error == ERESTART)
|
||
|
return EINTR;
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_share_put(struct smb_share *ssp, struct proc *p)
|
||
|
{
|
||
|
struct tnode *tp = SSTOTN(ssp);
|
||
|
|
||
|
tput(tp, p);
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_share_unlock(struct smb_share *ssp, int flags, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
|
||
|
tp = SSTOTN(ssp);
|
||
|
tunlock(tp, flags, scred->scr_p);
|
||
|
}
|
||
|
|
||
|
/*
|
||
|
* Release share and destroy it if usecount drops to zero.
|
||
|
*/
|
||
|
void
|
||
|
smb_share_rele(struct smb_share *ssp, struct smb_cred *scred)
|
||
|
{
|
||
|
struct tnode *tp;
|
||
|
|
||
|
tp = SSTOTN(ssp);
|
||
|
if (!TISGONE(tp)) {
|
||
|
trele(tp);
|
||
|
if (!TISGONE(tp))
|
||
|
return;
|
||
|
}
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_share_connect(struct smb_share *ssp, struct smb_cred *scred)
|
||
|
{
|
||
|
int error;
|
||
|
|
||
|
error = smb_smb_treeconnect(ssp, scred);
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_share_detach(struct smb_share *ssp, struct smb_cred *scred)
|
||
|
{
|
||
|
int error;
|
||
|
|
||
|
error = smb_smb_treedisconnect(ssp, scred);
|
||
|
return error;
|
||
|
}
|
||
|
|
||
|
void
|
||
|
smb_share_invalidate(struct smb_share *ssp)
|
||
|
{
|
||
|
if (!smb_share_valid(ssp))
|
||
|
return;
|
||
|
ssp->ss_id = SMB_TID_UNKNOWN;
|
||
|
}
|
||
|
|
||
|
int
|
||
|
smb_share_valid(struct smb_share *ssp)
|
||
|
{
|
||
|
return ssp->ss_id != SMB_TID_UNKNOWN;
|
||
|
}
|
||
|
|
||
|
char*
|
||
|
smb_share_pass(struct smb_share *ssp)
|
||
|
{
|
||
|
struct smb_vc *vcp;
|
||
|
|
||
|
if (ssp->ss_pass)
|
||
|
return ssp->ss_pass;
|
||
|
vcp = TNTOVC(SSTOTN(ssp)->t_parent);
|
||
|
if (vcp->vc_pass)
|
||
|
return vcp->vc_pass;
|
||
|
return smb_emptypass;
|
||
|
}
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
static int
|
||
|
smb_share_getinfo(struct smb_share *ssp, struct smb_share_info *sip)
|
||
|
{
|
||
|
bzero(sip, sizeof(struct smb_share_info));
|
||
|
sip->itype = SMB_INFO_SHARE;
|
||
|
sip->usecount = SSTOTN(ssp)->t_usecount;
|
||
|
sip->id = ssp->ss_id;
|
||
|
sip->type= ssp->ss_type;
|
||
|
sip->uid = ssp->ss_uid;
|
||
|
sip->gid = ssp->ss_grp;
|
||
|
sip->mode= ssp->ss_mode;
|
||
|
sip->flags = ssp->ss_flags;
|
||
|
snprintf(sip->sname, sizeof(sip->sname), "%s", SSTOTN(ssp)->t_name);
|
||
|
return 0;
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#ifndef NetBSD
|
||
|
/*
|
||
|
* Dump an entire tree into sysctl call
|
||
|
*/
|
||
|
static int
|
||
|
#if __FreeBSD_version > 500000
|
||
|
smb_sysctl_treedump(SYSCTL_HANDLER_ARGS)
|
||
|
#else
|
||
|
smb_sysctl_treedump SYSCTL_HANDLER_ARGS
|
||
|
#endif
|
||
|
{
|
||
|
struct proc *p = req->p;
|
||
|
struct smb_cred scred;
|
||
|
struct tnode *parent, *tscp, *tvcp, *tssp;
|
||
|
struct smb_ce *cep;
|
||
|
struct smb_conn *scp;
|
||
|
struct smb_vc *vcp;
|
||
|
struct smb_conn_info sci;
|
||
|
int error, itype;
|
||
|
|
||
|
smb_makescred(&scred, p, p->p_ucred);
|
||
|
error = smb_sm_getce(&scred, LK_SHARED, &cep);
|
||
|
if (error)
|
||
|
return error;
|
||
|
parent = CETOTN(cep);
|
||
|
SLIST_FOREACH(tscp, &parent->t_ddata->tm_children, t_link) {
|
||
|
scp = TNTOCN(tscp);
|
||
|
smb_conn_getinfo(scp, &sci);
|
||
|
error = SYSCTL_OUT(req, &sci, sizeof(struct smb_conn_info));
|
||
|
if (error)
|
||
|
break;
|
||
|
SLIST_FOREACH(tvcp, &tscp->t_ddata->tm_children, t_link) {
|
||
|
struct smb_vc_info vci;
|
||
|
|
||
|
vcp = TNTOVC(tvcp);
|
||
|
smb_vc_getinfo(vcp, &vci);
|
||
|
error = SYSCTL_OUT(req, &vci, sizeof(struct smb_vc_info));
|
||
|
if (error)
|
||
|
break;
|
||
|
SLIST_FOREACH(tssp, &tvcp->t_ddata->tm_children, t_link) {
|
||
|
struct smb_share_info ssi;
|
||
|
|
||
|
smb_share_getinfo(TNTOSS(tssp), &ssi);
|
||
|
error = SYSCTL_OUT(req, &ssi, sizeof(struct smb_share_info));
|
||
|
if (error)
|
||
|
break;
|
||
|
}
|
||
|
if (error)
|
||
|
break;
|
||
|
}
|
||
|
if (error)
|
||
|
break;
|
||
|
}
|
||
|
if (!error) {
|
||
|
itype = SMB_INFO_NONE;
|
||
|
error = SYSCTL_OUT(req, &itype, sizeof(itype));
|
||
|
}
|
||
|
smb_ce_unlock(cep, p);
|
||
|
return(error);
|
||
|
}
|
||
|
#endif
|