The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netsmb/smb_conn.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 2000-2001 Boris Popov
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer.
   10  * 2. Redistributions in binary form must reproduce the above copyright
   11  *    notice, this list of conditions and the following disclaimer in the
   12  *    documentation and/or other materials provided with the distribution.
   13  * 3. All advertising materials mentioning features or use of this software
   14  *    must display the following acknowledgement:
   15  *    This product includes software developed by Boris Popov.
   16  * 4. Neither the name of the author nor the names of any co-contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  */
   32 
   33 /*
   34  * Connection engine.
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD$");
   39 
   40 #include <sys/param.h>
   41 #include <sys/systm.h>
   42 #include <sys/kernel.h>
   43 #include <sys/malloc.h>
   44 #include <sys/priv.h>
   45 #include <sys/proc.h>
   46 #include <sys/lock.h>
   47 #include <sys/sysctl.h>
   48 #include <sys/socketvar.h>
   49 
   50 #include <sys/iconv.h>
   51 
   52 #include <netsmb/smb.h>
   53 #include <netsmb/smb_subr.h>
   54 #include <netsmb/smb_conn.h>
   55 #include <netsmb/smb_tran.h>
   56 #include <netsmb/smb_trantcp.h>
   57 
   58 static struct smb_connobj smb_vclist;
   59 static int smb_vcnext = 1;      /* next unique id for VC */
   60 
   61 SYSCTL_NODE(_net, OID_AUTO, smb, CTLFLAG_RW, NULL, "SMB protocol");
   62 
   63 MALLOC_DEFINE(M_SMBCONN, "smb_conn", "SMB connection");
   64 
   65 static void smb_co_init(struct smb_connobj *cp, int level, char *ilockname,
   66     char *lockname, struct thread *td);
   67 static void smb_co_done(struct smb_connobj *cp);
   68 static int  smb_co_lockstatus(struct smb_connobj *cp, struct thread *td);
   69 
   70 static int  smb_vc_disconnect(struct smb_vc *vcp);
   71 static void smb_vc_free(struct smb_connobj *cp);
   72 static void smb_vc_gone(struct smb_connobj *cp, struct smb_cred *scred);
   73 static smb_co_free_t smb_share_free;
   74 static smb_co_gone_t smb_share_gone;
   75 
   76 static int  smb_sysctl_treedump(SYSCTL_HANDLER_ARGS);
   77 
   78 SYSCTL_PROC(_net_smb, OID_AUTO, treedump, CTLFLAG_RD | CTLTYPE_OPAQUE,
   79             NULL, 0, smb_sysctl_treedump, "S,treedump", "Requester tree");
   80 
   81 int
   82 smb_sm_init(void)
   83 {
   84 
   85         smb_co_init(&smb_vclist, SMBL_SM, "smbsm ilock", "smbsm", curthread);
   86         smb_co_unlock(&smb_vclist, 0, curthread);
   87         return 0;
   88 }
   89 
   90 int
   91 smb_sm_done(void)
   92 {
   93 
   94         /* XXX: hold the mutex */
   95         if (smb_vclist.co_usecount > 1) {
   96                 SMBERROR("%d connections still active\n", smb_vclist.co_usecount - 1);
   97                 return EBUSY;
   98         }
   99         lockmgr(&smb_vclist.co_lock, LK_DRAIN, 0, curthread);
  100         smb_co_done(&smb_vclist);
  101         return 0;
  102 }
  103 
  104 static int
  105 smb_sm_lockvclist(int flags, struct thread *td)
  106 {
  107 
  108         return smb_co_lock(&smb_vclist, flags | LK_CANRECURSE, td);
  109 }
  110 
  111 static void
  112 smb_sm_unlockvclist(struct thread *td)
  113 {
  114 
  115         smb_co_unlock(&smb_vclist, LK_RELEASE, td);
  116 }
  117 
  118 static int
  119 smb_sm_lookupint(struct smb_vcspec *vcspec, struct smb_sharespec *shspec,
  120         struct smb_cred *scred, struct smb_vc **vcpp)
  121 {
  122         struct thread *td = scred->scr_td;
  123         struct smb_connobj *scp;
  124         struct smb_vc *vcp;
  125         int exact = 1;
  126         int error;
  127 
  128         vcspec->shspec = shspec;
  129         error = ENOENT;
  130         vcp = NULL;
  131         SMBCO_FOREACH(scp, &smb_vclist) {
  132                 vcp = (struct smb_vc *)scp;
  133                 error = smb_vc_lock(vcp, LK_EXCLUSIVE, td);
  134                 if (error)
  135                         continue;
  136 
  137                 if ((vcp->obj.co_flags & SMBV_PRIVATE) ||
  138                     !CONNADDREQ(vcp->vc_paddr, vcspec->sap) ||
  139                     strcmp(vcp->vc_username, vcspec->username) != 0)
  140                         goto err1;
  141                 if (vcspec->owner != SMBM_ANY_OWNER) {
  142                         if (vcp->vc_uid != vcspec->owner)
  143                                 goto err1;
  144                 } else
  145                         exact = 0;
  146                 if (vcspec->group != SMBM_ANY_GROUP) {
  147                         if (vcp->vc_grp != vcspec->group)
  148                                 goto err1;
  149                 } else
  150                         exact = 0;
  151                 if (vcspec->mode & SMBM_EXACT) {
  152                         if (!exact || (vcspec->mode & SMBM_MASK) !=
  153                             vcp->vc_mode)
  154                                 goto err1;
  155                 }
  156                 if (smb_vc_access(vcp, scred, vcspec->mode) != 0)
  157                         goto err1;
  158                 vcspec->ssp = NULL;
  159                 if (shspec) {
  160                         error = (int)smb_vc_lookupshare(vcp, shspec, scred,
  161                             &vcspec->ssp);
  162                         if (error)
  163                                 goto fail;
  164                 }
  165                 error = 0;
  166                 break;
  167         err1:
  168                 error = 1;
  169         fail:
  170                 smb_vc_unlock(vcp, 0, td);
  171         }
  172         if (vcp) {
  173                 smb_vc_ref(vcp);
  174                 *vcpp = vcp;
  175         }
  176         return (error);
  177 }
  178 
  179 int
  180 smb_sm_lookup(struct smb_vcspec *vcspec, struct smb_sharespec *shspec,
  181         struct smb_cred *scred, struct smb_vc **vcpp)
  182 {
  183         struct thread *td = scred->scr_td;
  184         struct smb_vc *vcp;
  185         struct smb_share *ssp = NULL;
  186         int error;
  187 
  188         *vcpp = vcp = NULL;
  189 
  190         error = smb_sm_lockvclist(LK_EXCLUSIVE, td);
  191         if (error)
  192                 return error;
  193         error = smb_sm_lookupint(vcspec, shspec, scred, vcpp);
  194         if (error == 0 || (vcspec->flags & SMBV_CREATE) == 0) {
  195                 smb_sm_unlockvclist(td);
  196                 return error;
  197         }
  198         error = smb_sm_lookupint(vcspec, NULL, scred, &vcp);
  199         if (error) {
  200                 error = smb_vc_create(vcspec, scred, &vcp);
  201                 if (error)
  202                         goto out;
  203                 error = smb_vc_connect(vcp, scred);
  204                 if (error)
  205                         goto out;
  206         }
  207         if (shspec == NULL)
  208                 goto out;
  209         error = smb_share_create(vcp, shspec, scred, &ssp);
  210         if (error)
  211                 goto out;
  212         error = smb_smb_treeconnect(ssp, scred);
  213         if (error == 0)
  214                 vcspec->ssp = ssp;
  215         else
  216                 smb_share_put(ssp, scred);
  217 out:
  218         smb_sm_unlockvclist(td);
  219         if (error == 0)
  220                 *vcpp = vcp;
  221         else if (vcp)
  222                 smb_vc_put(vcp, scred);
  223         return error;
  224 }
  225 
  226 /*
  227  * Common code for connection object
  228  */
  229 static void
  230 smb_co_init(struct smb_connobj *cp, int level, char *ilockname, char *lockname,
  231     struct thread *td)
  232 {
  233         SLIST_INIT(&cp->co_children);
  234         smb_sl_init(&cp->co_interlock, ilockname);
  235         lockinit(&cp->co_lock, PZERO, lockname, 0, 0);
  236         cp->co_level = level;
  237         cp->co_usecount = 1;
  238         if (smb_co_lock(cp, LK_EXCLUSIVE, td) != 0)
  239             panic("smb_co_init: lock failed");
  240 }
  241 
  242 static void
  243 smb_co_done(struct smb_connobj *cp)
  244 {
  245         smb_sl_destroy(&cp->co_interlock);
  246         lockmgr(&cp->co_lock, LK_RELEASE, 0, curthread);
  247         lockdestroy(&cp->co_lock);
  248 }
  249 
  250 static void
  251 smb_co_gone(struct smb_connobj *cp, struct smb_cred *scred)
  252 {
  253         struct smb_connobj *parent;
  254 
  255         if (cp->co_gone)
  256                 cp->co_gone(cp, scred);
  257         parent = cp->co_parent;
  258         if (parent) {
  259                 smb_co_lock(parent, LK_EXCLUSIVE, scred->scr_td);
  260                 SLIST_REMOVE(&parent->co_children, cp, smb_connobj, co_next);
  261                 smb_co_put(parent, scred);
  262         }
  263         if (cp->co_free)
  264                 cp->co_free(cp);
  265 }
  266 
  267 void
  268 smb_co_ref(struct smb_connobj *cp)
  269 {
  270 
  271         SMB_CO_LOCK(cp);
  272         cp->co_usecount++;
  273         SMB_CO_UNLOCK(cp);
  274 }
  275 
  276 void
  277 smb_co_rele(struct smb_connobj *cp, struct smb_cred *scred)
  278 {
  279         struct thread *td = scred->scr_td;
  280 
  281         SMB_CO_LOCK(cp);
  282         if (cp->co_usecount > 1) {
  283                 cp->co_usecount--;
  284                 SMB_CO_UNLOCK(cp);
  285                 return;
  286         }
  287         if (cp->co_usecount == 0) {
  288                 SMBERROR("negative use_count for object %d", cp->co_level);
  289                 SMB_CO_UNLOCK(cp);
  290                 return;
  291         }
  292         cp->co_usecount--;
  293         cp->co_flags |= SMBO_GONE;
  294 
  295         lockmgr(&cp->co_lock, LK_DRAIN | LK_INTERLOCK, &cp->co_interlock, td);
  296         smb_co_gone(cp, scred);
  297 }
  298 
  299 int
  300 smb_co_get(struct smb_connobj *cp, int flags, struct smb_cred *scred)
  301 {
  302         int error;
  303 
  304         if ((flags & LK_INTERLOCK) == 0)
  305                 SMB_CO_LOCK(cp);
  306         cp->co_usecount++;
  307         error = smb_co_lock(cp, flags | LK_INTERLOCK, scred->scr_td);
  308         if (error) {
  309                 SMB_CO_LOCK(cp);
  310                 cp->co_usecount--;
  311                 SMB_CO_UNLOCK(cp);
  312                 return error;
  313         }
  314         return 0;
  315 }
  316 
  317 void
  318 smb_co_put(struct smb_connobj *cp, struct smb_cred *scred)
  319 {
  320         struct thread *td = scred->scr_td;
  321 
  322         SMB_CO_LOCK(cp);
  323         if (cp->co_usecount > 1) {
  324                 cp->co_usecount--;
  325         } else if (cp->co_usecount == 1) {
  326                 cp->co_usecount--;
  327                 cp->co_flags |= SMBO_GONE;
  328         } else {
  329                 SMBERROR("negative usecount");
  330         }
  331         lockmgr(&cp->co_lock, LK_RELEASE | LK_INTERLOCK, &cp->co_interlock, td);
  332         if ((cp->co_flags & SMBO_GONE) == 0)
  333                 return;
  334         lockmgr(&cp->co_lock, LK_DRAIN, NULL, td);
  335         smb_co_gone(cp, scred);
  336 }
  337 
  338 int
  339 smb_co_lockstatus(struct smb_connobj *cp, struct thread *td)
  340 {
  341         return lockstatus(&cp->co_lock, td);
  342 }
  343 
  344 int
  345 smb_co_lock(struct smb_connobj *cp, int flags, struct thread *td)
  346 {
  347 
  348         if (cp->co_flags & SMBO_GONE)
  349                 return EINVAL;
  350         if ((flags & LK_TYPE_MASK) == 0)
  351                 flags |= LK_EXCLUSIVE;
  352         if (smb_co_lockstatus(cp, td) == LK_EXCLUSIVE && 
  353             (flags & LK_CANRECURSE) == 0) {
  354                 SMBERROR("recursive lock for object %d\n", cp->co_level);
  355                 return 0;
  356         }
  357         return lockmgr(&cp->co_lock, flags, &cp->co_interlock, td);
  358 }
  359 
  360 void
  361 smb_co_unlock(struct smb_connobj *cp, int flags, struct thread *td)
  362 {
  363         (void)lockmgr(&cp->co_lock, flags | LK_RELEASE, &cp->co_interlock, td);
  364 }
  365 
  366 static void
  367 smb_co_addchild(struct smb_connobj *parent, struct smb_connobj *child)
  368 {
  369         KASSERT(smb_co_lockstatus(parent, curthread) == LK_EXCLUSIVE, ("smb_co_addchild: parent not locked"));
  370         KASSERT(smb_co_lockstatus(child, curthread) == LK_EXCLUSIVE, ("smb_co_addchild: child not locked"));
  371 
  372         smb_co_ref(parent);
  373         SLIST_INSERT_HEAD(&parent->co_children, child, co_next);
  374         child->co_parent = parent;
  375 }
  376 
  377 /*
  378  * Session implementation
  379  */
  380 
  381 int
  382 smb_vc_create(struct smb_vcspec *vcspec,
  383         struct smb_cred *scred, struct smb_vc **vcpp)
  384 {
  385         struct smb_vc *vcp;
  386         struct thread *td = scred->scr_td;
  387         struct ucred *cred = scred->scr_cred;
  388         uid_t uid = vcspec->owner;
  389         gid_t gid = vcspec->group;
  390         uid_t realuid = cred->cr_uid;
  391         char *domain = vcspec->domain;
  392         int error, isroot;
  393 
  394         isroot = smb_suser(cred) == 0;
  395         /*
  396          * Only superuser can create VCs with different uid and gid
  397          */
  398         if (uid != SMBM_ANY_OWNER && uid != realuid && !isroot)
  399                 return EPERM;
  400         if (gid != SMBM_ANY_GROUP && !groupmember(gid, cred) && !isroot)
  401                 return EPERM;
  402 
  403         vcp = smb_zmalloc(sizeof(*vcp), M_SMBCONN, M_WAITOK);
  404         smb_co_init(VCTOCP(vcp), SMBL_VC, "smb_vc ilock", "smb_vc", td);
  405         vcp->obj.co_free = smb_vc_free;
  406         vcp->obj.co_gone = smb_vc_gone;
  407         vcp->vc_number = smb_vcnext++;
  408         vcp->vc_timo = SMB_DEFRQTIMO;
  409         vcp->vc_smbuid = SMB_UID_UNKNOWN;
  410         vcp->vc_mode = vcspec->rights & SMBM_MASK;
  411         vcp->obj.co_flags = vcspec->flags & (SMBV_PRIVATE | SMBV_SINGLESHARE);
  412         vcp->vc_tdesc = &smb_tran_nbtcp_desc;
  413         vcp->vc_seqno = 0;
  414         vcp->vc_mackey = NULL;
  415         vcp->vc_mackeylen = 0;
  416 
  417         if (uid == SMBM_ANY_OWNER)
  418                 uid = realuid;
  419         if (gid == SMBM_ANY_GROUP)
  420                 gid = cred->cr_groups[0];
  421         vcp->vc_uid = uid;
  422         vcp->vc_grp = gid;
  423 
  424         smb_sl_init(&vcp->vc_stlock, "vcstlock");
  425         error = ENOMEM;
  426 
  427         vcp->vc_paddr = sodupsockaddr(vcspec->sap, M_WAITOK);
  428         if (vcp->vc_paddr == NULL)
  429                 goto fail;
  430         vcp->vc_laddr = sodupsockaddr(vcspec->lap, M_WAITOK);
  431         if (vcp->vc_laddr == NULL)
  432                 goto fail;
  433         vcp->vc_pass = smb_strdup(vcspec->pass);
  434         if (vcp->vc_pass == NULL)
  435                 goto fail;
  436         vcp->vc_domain = smb_strdup((domain && domain[0]) ? domain :
  437             "NODOMAIN");
  438         if (vcp->vc_domain == NULL)
  439                 goto fail;
  440         vcp->vc_srvname = smb_strdup(vcspec->srvname);
  441         if (vcp->vc_srvname == NULL)
  442                 goto fail;
  443         vcp->vc_username = smb_strdup(vcspec->username);
  444         if (vcp->vc_username == NULL)
  445                 goto fail;
  446         error = (int)iconv_open("tolower", vcspec->localcs, &vcp->vc_tolower);
  447         if (error)
  448                 goto fail;
  449         error = (int)iconv_open("toupper", vcspec->localcs, &vcp->vc_toupper);
  450         if (error)
  451                 goto fail;
  452         if (vcspec->servercs[0]) {
  453                 error = (int)iconv_open(vcspec->servercs, vcspec->localcs,
  454                     &vcp->vc_toserver);
  455                 if (error)
  456                         goto fail;
  457                 error = (int)iconv_open(vcspec->localcs, vcspec->servercs,
  458                     &vcp->vc_tolocal);
  459                 if (error)
  460                         goto fail;
  461         }
  462         error = (int)smb_iod_create(vcp);
  463         if (error)
  464                 goto fail;
  465         *vcpp = vcp;
  466         smb_co_addchild(&smb_vclist, VCTOCP(vcp));
  467         return (0);
  468 
  469  fail:
  470         smb_vc_put(vcp, scred);
  471         return (error);
  472 }
  473 
  474 static void
  475 smb_vc_free(struct smb_connobj *cp)
  476 {
  477         struct smb_vc *vcp = CPTOVC(cp);
  478 
  479         if (vcp->vc_iod)
  480                 smb_iod_destroy(vcp->vc_iod);
  481         SMB_STRFREE(vcp->vc_username);
  482         SMB_STRFREE(vcp->vc_srvname);
  483         SMB_STRFREE(vcp->vc_pass);
  484         SMB_STRFREE(vcp->vc_domain);
  485         if (vcp->vc_mackey)
  486                 free(vcp->vc_mackey, M_SMBTEMP);
  487         if (vcp->vc_paddr)
  488                 free(vcp->vc_paddr, M_SONAME);
  489         if (vcp->vc_laddr)
  490                 free(vcp->vc_laddr, M_SONAME);
  491         if (vcp->vc_tolower)
  492                 iconv_close(vcp->vc_tolower);
  493         if (vcp->vc_toupper)
  494                 iconv_close(vcp->vc_toupper);
  495         if (vcp->vc_tolocal)
  496                 iconv_close(vcp->vc_tolocal);
  497         if (vcp->vc_toserver)
  498                 iconv_close(vcp->vc_toserver);
  499         smb_co_done(VCTOCP(vcp));
  500         smb_sl_destroy(&vcp->vc_stlock);
  501         free(vcp, M_SMBCONN);
  502 }
  503 
  504 /*
  505  * Called when use count of VC dropped to zero.
  506  * VC should be locked on enter with LK_DRAIN.
  507  */
  508 static void
  509 smb_vc_gone(struct smb_connobj *cp, struct smb_cred *scred)
  510 {
  511         struct smb_vc *vcp = CPTOVC(cp);
  512 
  513         smb_vc_disconnect(vcp);
  514 }
  515 
  516 void
  517 smb_vc_ref(struct smb_vc *vcp)
  518 {
  519         smb_co_ref(VCTOCP(vcp));
  520 }
  521 
  522 void
  523 smb_vc_rele(struct smb_vc *vcp, struct smb_cred *scred)
  524 {
  525         smb_co_rele(VCTOCP(vcp), scred);
  526 }
  527 
  528 int
  529 smb_vc_get(struct smb_vc *vcp, int flags, struct smb_cred *scred)
  530 {
  531         return smb_co_get(VCTOCP(vcp), flags, scred);
  532 }
  533 
  534 void
  535 smb_vc_put(struct smb_vc *vcp, struct smb_cred *scred)
  536 {
  537         smb_co_put(VCTOCP(vcp), scred);
  538 }
  539 
  540 int
  541 smb_vc_lock(struct smb_vc *vcp, int flags, struct thread *td)
  542 {
  543         return smb_co_lock(VCTOCP(vcp), flags, td);
  544 }
  545 
  546 void
  547 smb_vc_unlock(struct smb_vc *vcp, int flags, struct thread *td)
  548 {
  549         smb_co_unlock(VCTOCP(vcp), flags, td);
  550 }
  551 
  552 int
  553 smb_vc_access(struct smb_vc *vcp, struct smb_cred *scred, mode_t mode)
  554 {
  555         struct ucred *cred = scred->scr_cred;
  556 
  557         if (smb_suser(cred) == 0 || cred->cr_uid == vcp->vc_uid)
  558                 return 0;
  559         mode >>= 3;
  560         if (!groupmember(vcp->vc_grp, cred))
  561                 mode >>= 3;
  562         return (vcp->vc_mode & mode) == mode ? 0 : EACCES;
  563 }
  564 
  565 static int
  566 smb_vc_cmpshare(struct smb_share *ssp, struct smb_sharespec *dp)
  567 {
  568         int exact = 1;
  569 
  570         if (strcmp(ssp->ss_name, dp->name) != 0)
  571                 return 1;
  572         if (dp->owner != SMBM_ANY_OWNER) {
  573                 if (ssp->ss_uid != dp->owner)
  574                         return 1;
  575         } else
  576                 exact = 0;
  577         if (dp->group != SMBM_ANY_GROUP) {
  578                 if (ssp->ss_grp != dp->group)
  579                         return 1;
  580         } else
  581                 exact = 0;
  582 
  583         if (dp->mode & SMBM_EXACT) {
  584                 if (!exact)
  585                         return 1;
  586                 return (dp->mode & SMBM_MASK) == ssp->ss_mode ? 0 : 1;
  587         }
  588         if (smb_share_access(ssp, dp->scred, dp->mode) != 0)
  589                 return 1;
  590         return 0;
  591 }
  592 
  593 /*
  594  * Lookup share in the given VC. Share referenced and locked on return.
  595  * VC expected to be locked on entry and will be left locked on exit.
  596  */
  597 int
  598 smb_vc_lookupshare(struct smb_vc *vcp, struct smb_sharespec *dp,
  599         struct smb_cred *scred, struct smb_share **sspp)
  600 {
  601         struct thread *td = scred->scr_td;
  602         struct smb_connobj *scp = NULL;
  603         struct smb_share *ssp = NULL;
  604         int error;
  605 
  606         *sspp = NULL;
  607         dp->scred = scred;
  608         SMBCO_FOREACH(scp, VCTOCP(vcp)) {
  609                 ssp = (struct smb_share *)scp;
  610                 error = smb_share_lock(ssp, LK_EXCLUSIVE, td);
  611                 if (error)
  612                         continue;
  613                 if (smb_vc_cmpshare(ssp, dp) == 0)
  614                         break;
  615                 smb_share_unlock(ssp, 0, td);
  616         }
  617         if (ssp) {
  618                 smb_share_ref(ssp);
  619                 *sspp = ssp;
  620                 error = 0;
  621         } else
  622                 error = ENOENT;
  623         return error;
  624 }
  625 
  626 int
  627 smb_vc_connect(struct smb_vc *vcp, struct smb_cred *scred)
  628 {
  629 
  630         return smb_iod_request(vcp->vc_iod, SMBIOD_EV_CONNECT | SMBIOD_EV_SYNC, NULL);
  631 }
  632 
  633 /*
  634  * Destroy VC to server, invalidate shares linked with it.
  635  * Transport should be locked on entry.
  636  */
  637 int
  638 smb_vc_disconnect(struct smb_vc *vcp)
  639 {
  640 
  641         smb_iod_request(vcp->vc_iod, SMBIOD_EV_DISCONNECT | SMBIOD_EV_SYNC, NULL);
  642         return 0;
  643 }
  644 
  645 static char smb_emptypass[] = "";
  646 
  647 const char *
  648 smb_vc_getpass(struct smb_vc *vcp)
  649 {
  650         if (vcp->vc_pass)
  651                 return vcp->vc_pass;
  652         return smb_emptypass;
  653 }
  654 
  655 static int
  656 smb_vc_getinfo(struct smb_vc *vcp, struct smb_vc_info *vip)
  657 {
  658         bzero(vip, sizeof(struct smb_vc_info));
  659         vip->itype = SMB_INFO_VC;
  660         vip->usecount = vcp->obj.co_usecount;
  661         vip->uid = vcp->vc_uid;
  662         vip->gid = vcp->vc_grp;
  663         vip->mode = vcp->vc_mode;
  664         vip->flags = vcp->obj.co_flags;
  665         vip->sopt = vcp->vc_sopt;
  666         vip->iodstate = vcp->vc_iod->iod_state;
  667         bzero(&vip->sopt.sv_skey, sizeof(vip->sopt.sv_skey));
  668         snprintf(vip->srvname, sizeof(vip->srvname), "%s", vcp->vc_srvname);
  669         snprintf(vip->vcname, sizeof(vip->vcname), "%s", vcp->vc_username);
  670         return 0;
  671 }
  672 
  673 u_short
  674 smb_vc_nextmid(struct smb_vc *vcp)
  675 {
  676         u_short r;
  677 
  678         SMB_CO_LOCK(&vcp->obj);
  679         r = vcp->vc_mid++;
  680         SMB_CO_UNLOCK(&vcp->obj);
  681         return r;
  682 }
  683 
  684 /*
  685  * Share implementation
  686  */
  687 /*
  688  * Allocate share structure and attach it to the given VC
  689  * Connection expected to be locked on entry. Share will be returned
  690  * in locked state.
  691  */
  692 int
  693 smb_share_create(struct smb_vc *vcp, struct smb_sharespec *shspec,
  694         struct smb_cred *scred, struct smb_share **sspp)
  695 {
  696         struct smb_share *ssp;
  697         struct thread *td = scred->scr_td;
  698         struct ucred *cred = scred->scr_cred;
  699         uid_t realuid = cred->cr_uid;
  700         uid_t uid = shspec->owner;
  701         gid_t gid = shspec->group;
  702         int error, isroot;
  703 
  704         isroot = smb_suser(cred) == 0;
  705         /*
  706          * Only superuser can create shares with different uid and gid
  707          */
  708         if (uid != SMBM_ANY_OWNER && uid != realuid && !isroot)
  709                 return EPERM;
  710         if (gid != SMBM_ANY_GROUP && !groupmember(gid, cred) && !isroot)
  711                 return EPERM;
  712         error = smb_vc_lookupshare(vcp, shspec, scred, &ssp);
  713         if (!error) {
  714                 smb_share_put(ssp, scred);
  715                 return EEXIST;
  716         }
  717         if (uid == SMBM_ANY_OWNER)
  718                 uid = realuid;
  719         if (gid == SMBM_ANY_GROUP)
  720                 gid = cred->cr_groups[0];
  721         ssp = smb_zmalloc(sizeof(*ssp), M_SMBCONN, M_WAITOK);
  722         smb_co_init(SSTOCP(ssp), SMBL_SHARE, "smbss ilock", "smbss", td);
  723         ssp->obj.co_free = smb_share_free;
  724         ssp->obj.co_gone = smb_share_gone;
  725         smb_sl_init(&ssp->ss_stlock, "ssstlock");
  726         ssp->ss_name = smb_strdup(shspec->name);
  727         if (shspec->pass && shspec->pass[0])
  728                 ssp->ss_pass = smb_strdup(shspec->pass);
  729         ssp->ss_type = shspec->stype;
  730         ssp->ss_tid = SMB_TID_UNKNOWN;
  731         ssp->ss_uid = uid;
  732         ssp->ss_grp = gid;
  733         ssp->ss_mode = shspec->rights & SMBM_MASK;
  734         smb_co_addchild(VCTOCP(vcp), SSTOCP(ssp));
  735         *sspp = ssp;
  736         return 0;
  737 }
  738 
  739 static void
  740 smb_share_free(struct smb_connobj *cp)
  741 {
  742         struct smb_share *ssp = CPTOSS(cp);
  743 
  744         SMB_STRFREE(ssp->ss_name);
  745         SMB_STRFREE(ssp->ss_pass);
  746         smb_sl_destroy(&ssp->ss_stlock);
  747         smb_co_done(SSTOCP(ssp));
  748         free(ssp, M_SMBCONN);
  749 }
  750 
  751 static void
  752 smb_share_gone(struct smb_connobj *cp, struct smb_cred *scred)
  753 {
  754         struct smb_share *ssp = CPTOSS(cp);
  755 
  756         smb_smb_treedisconnect(ssp, scred);
  757 }
  758 
  759 void
  760 smb_share_ref(struct smb_share *ssp)
  761 {
  762         smb_co_ref(SSTOCP(ssp));
  763 }
  764 
  765 void
  766 smb_share_rele(struct smb_share *ssp, struct smb_cred *scred)
  767 {
  768         smb_co_rele(SSTOCP(ssp), scred);
  769 }
  770 
  771 int
  772 smb_share_get(struct smb_share *ssp, int flags, struct smb_cred *scred)
  773 {
  774         return smb_co_get(SSTOCP(ssp), flags, scred);
  775 }
  776 
  777 void
  778 smb_share_put(struct smb_share *ssp, struct smb_cred *scred)
  779 {
  780         smb_co_put(SSTOCP(ssp), scred);
  781 }
  782 
  783 int
  784 smb_share_lock(struct smb_share *ssp, int flags, struct thread *td)
  785 {
  786         return smb_co_lock(SSTOCP(ssp), flags, td);
  787 }
  788 
  789 void
  790 smb_share_unlock(struct smb_share *ssp, int flags, struct thread *td)
  791 {
  792         smb_co_unlock(SSTOCP(ssp), flags, td);
  793 }
  794 
  795 int
  796 smb_share_access(struct smb_share *ssp, struct smb_cred *scred, mode_t mode)
  797 {
  798         struct ucred *cred = scred->scr_cred;
  799 
  800         if (smb_suser(cred) == 0 || cred->cr_uid == ssp->ss_uid)
  801                 return 0;
  802         mode >>= 3;
  803         if (!groupmember(ssp->ss_grp, cred))
  804                 mode >>= 3;
  805         return (ssp->ss_mode & mode) == mode ? 0 : EACCES;
  806 }
  807 
  808 void
  809 smb_share_invalidate(struct smb_share *ssp)
  810 {
  811         ssp->ss_tid = SMB_TID_UNKNOWN;
  812 }
  813 
  814 int
  815 smb_share_valid(struct smb_share *ssp)
  816 {
  817         return ssp->ss_tid != SMB_TID_UNKNOWN &&
  818             ssp->ss_vcgenid == SSTOVC(ssp)->vc_genid;
  819 }
  820 
  821 const char*
  822 smb_share_getpass(struct smb_share *ssp)
  823 {
  824         struct smb_vc *vcp;
  825 
  826         if (ssp->ss_pass)
  827                 return ssp->ss_pass;
  828         vcp = SSTOVC(ssp);
  829         if (vcp->vc_pass)
  830                 return vcp->vc_pass;
  831         return smb_emptypass;
  832 }
  833 
  834 static int
  835 smb_share_getinfo(struct smb_share *ssp, struct smb_share_info *sip)
  836 {
  837         bzero(sip, sizeof(struct smb_share_info));
  838         sip->itype = SMB_INFO_SHARE;
  839         sip->usecount = ssp->obj.co_usecount;
  840         sip->tid  = ssp->ss_tid;
  841         sip->type= ssp->ss_type;
  842         sip->uid = ssp->ss_uid;
  843         sip->gid = ssp->ss_grp;
  844         sip->mode= ssp->ss_mode;
  845         sip->flags = ssp->obj.co_flags;
  846         snprintf(sip->sname, sizeof(sip->sname), "%s", ssp->ss_name);
  847         return 0;
  848 }
  849 
  850 /*
  851  * Dump an entire tree into sysctl call
  852  */
  853 static int
  854 smb_sysctl_treedump(SYSCTL_HANDLER_ARGS)
  855 {
  856         struct thread *td = req->td;
  857         struct smb_cred scred;
  858         struct smb_connobj *scp1, *scp2;
  859         struct smb_vc *vcp;
  860         struct smb_share *ssp;
  861         struct smb_vc_info vci;
  862         struct smb_share_info ssi;
  863         int error, itype;
  864 
  865         smb_makescred(&scred, td, td->td_ucred);
  866         error = sysctl_wire_old_buffer(req, 0);
  867         if (error)
  868                 return (error);
  869         error = smb_sm_lockvclist(LK_SHARED, td);
  870         if (error)
  871                 return error;
  872         SMBCO_FOREACH(scp1, &smb_vclist) {
  873                 vcp = (struct smb_vc *)scp1;
  874                 error = smb_vc_lock(vcp, LK_SHARED, td);
  875                 if (error)
  876                         continue;
  877                 smb_vc_getinfo(vcp, &vci);
  878                 error = SYSCTL_OUT(req, &vci, sizeof(struct smb_vc_info));
  879                 if (error) {
  880                         smb_vc_unlock(vcp, 0, td);
  881                         break;
  882                 }
  883                 SMBCO_FOREACH(scp2, VCTOCP(vcp)) {
  884                         ssp = (struct smb_share *)scp2;
  885                         error = smb_share_lock(ssp, LK_SHARED, td);
  886                         if (error) {
  887                                 error = 0;
  888                                 continue;
  889                         }
  890                         smb_share_getinfo(ssp, &ssi);
  891                         smb_share_unlock(ssp, 0, td);
  892                         error = SYSCTL_OUT(req, &ssi, sizeof(struct smb_share_info));
  893                         if (error)
  894                                 break;
  895                 }
  896                 smb_vc_unlock(vcp, 0, td);
  897                 if (error)
  898                         break;
  899         }
  900         if (!error) {
  901                 itype = SMB_INFO_NONE;
  902                 error = SYSCTL_OUT(req, &itype, sizeof(itype));
  903         }
  904         smb_sm_unlockvclist(td);
  905         return error;
  906 }

Cache object: 514ae9e94178046480f55abe97ae5c9f


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.