diff --git a/sys/netsmb/smb_conn.c b/sys/netsmb/smb_conn.c index 3480181502d3..2307f97ff50b 100644 --- a/sys/netsmb/smb_conn.c +++ b/sys/netsmb/smb_conn.c @@ -1,906 +1,903 @@ /*- * 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. */ /* * Connection engine. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static struct smb_connobj smb_vclist; static int smb_vcnext = 1; /* next unique id for VC */ SYSCTL_NODE(_net, OID_AUTO, smb, CTLFLAG_RW, NULL, "SMB protocol"); MALLOC_DEFINE(M_SMBCONN, "smb_conn", "SMB connection"); static void smb_co_init(struct smb_connobj *cp, int level, char *ilockname, - char *lockname, struct thread *td); + char *lockname); static void smb_co_done(struct smb_connobj *cp); -static int smb_co_lockstatus(struct smb_connobj *cp, struct thread *td); +static int smb_co_lockstatus(struct smb_connobj *cp); static int smb_vc_disconnect(struct smb_vc *vcp); static void smb_vc_free(struct smb_connobj *cp); static void smb_vc_gone(struct smb_connobj *cp, struct smb_cred *scred); static smb_co_free_t smb_share_free; static smb_co_gone_t smb_share_gone; static int smb_sysctl_treedump(SYSCTL_HANDLER_ARGS); SYSCTL_PROC(_net_smb, OID_AUTO, treedump, CTLFLAG_RD | CTLTYPE_OPAQUE, NULL, 0, smb_sysctl_treedump, "S,treedump", "Requester tree"); int smb_sm_init(void) { - smb_co_init(&smb_vclist, SMBL_SM, "smbsm ilock", "smbsm", curthread); - smb_co_unlock(&smb_vclist, 0, curthread); + smb_co_init(&smb_vclist, SMBL_SM, "smbsm ilock", "smbsm"); + smb_co_unlock(&smb_vclist, 0); return 0; } int smb_sm_done(void) { /* XXX: hold the mutex */ if (smb_vclist.co_usecount > 1) { SMBERROR("%d connections still active\n", smb_vclist.co_usecount - 1); return EBUSY; } - lockmgr(&smb_vclist.co_lock, LK_DRAIN, 0); + lockmgr(&smb_vclist.co_lock, LK_DRAIN, NULL); smb_co_done(&smb_vclist); return 0; } static int -smb_sm_lockvclist(int flags, struct thread *td) +smb_sm_lockvclist(int flags) { - return smb_co_lock(&smb_vclist, flags | LK_CANRECURSE, td); + return smb_co_lock(&smb_vclist, flags | LK_CANRECURSE); } static void -smb_sm_unlockvclist(struct thread *td) +smb_sm_unlockvclist(void) { - smb_co_unlock(&smb_vclist, LK_RELEASE, td); + smb_co_unlock(&smb_vclist, LK_RELEASE); } static int smb_sm_lookupint(struct smb_vcspec *vcspec, struct smb_sharespec *shspec, struct smb_cred *scred, struct smb_vc **vcpp) { - struct thread *td = scred->scr_td; struct smb_connobj *scp; struct smb_vc *vcp; int exact = 1; int error; vcspec->shspec = shspec; error = ENOENT; vcp = NULL; SMBCO_FOREACH(scp, &smb_vclist) { vcp = (struct smb_vc *)scp; - error = smb_vc_lock(vcp, LK_EXCLUSIVE, td); + error = smb_vc_lock(vcp, LK_EXCLUSIVE); if (error) continue; if ((vcp->obj.co_flags & SMBV_PRIVATE) || !CONNADDREQ(vcp->vc_paddr, vcspec->sap) || strcmp(vcp->vc_username, vcspec->username) != 0) goto err1; if (vcspec->owner != SMBM_ANY_OWNER) { if (vcp->vc_uid != vcspec->owner) goto err1; } else exact = 0; if (vcspec->group != SMBM_ANY_GROUP) { if (vcp->vc_grp != vcspec->group) goto err1; } else exact = 0; if (vcspec->mode & SMBM_EXACT) { if (!exact || (vcspec->mode & SMBM_MASK) != vcp->vc_mode) goto err1; } if (smb_vc_access(vcp, scred, vcspec->mode) != 0) goto err1; vcspec->ssp = NULL; if (shspec) { error = (int)smb_vc_lookupshare(vcp, shspec, scred, &vcspec->ssp); if (error) goto fail; } error = 0; break; err1: error = 1; fail: - smb_vc_unlock(vcp, 0, td); + smb_vc_unlock(vcp, 0); } if (vcp) { smb_vc_ref(vcp); *vcpp = vcp; } return (error); } int smb_sm_lookup(struct smb_vcspec *vcspec, struct smb_sharespec *shspec, struct smb_cred *scred, struct smb_vc **vcpp) { - struct thread *td = scred->scr_td; struct smb_vc *vcp; struct smb_share *ssp = NULL; int error; *vcpp = vcp = NULL; - error = smb_sm_lockvclist(LK_EXCLUSIVE, td); + error = smb_sm_lockvclist(LK_EXCLUSIVE); if (error) return error; error = smb_sm_lookupint(vcspec, shspec, scred, vcpp); if (error == 0 || (vcspec->flags & SMBV_CREATE) == 0) { - smb_sm_unlockvclist(td); + smb_sm_unlockvclist(); return error; } error = smb_sm_lookupint(vcspec, NULL, scred, &vcp); if (error) { error = smb_vc_create(vcspec, scred, &vcp); if (error) goto out; error = smb_vc_connect(vcp, scred); if (error) goto out; } if (shspec == NULL) goto out; error = smb_share_create(vcp, shspec, scred, &ssp); if (error) goto out; error = smb_smb_treeconnect(ssp, scred); if (error == 0) vcspec->ssp = ssp; else smb_share_put(ssp, scred); out: - smb_sm_unlockvclist(td); + smb_sm_unlockvclist(); if (error == 0) *vcpp = vcp; else if (vcp) { - smb_vc_lock(vcp, LK_EXCLUSIVE, scred->scr_td); + smb_vc_lock(vcp, LK_EXCLUSIVE); smb_vc_put(vcp, scred); } return error; } /* * Common code for connection object */ static void -smb_co_init(struct smb_connobj *cp, int level, char *ilockname, char *lockname, - struct thread *td) +smb_co_init(struct smb_connobj *cp, int level, char *ilockname, char *lockname) { SLIST_INIT(&cp->co_children); smb_sl_init(&cp->co_interlock, ilockname); lockinit(&cp->co_lock, PZERO, lockname, 0, 0); cp->co_level = level; cp->co_usecount = 1; - if (smb_co_lock(cp, LK_EXCLUSIVE, td) != 0) + if (smb_co_lock(cp, LK_EXCLUSIVE) != 0) panic("smb_co_init: lock failed"); } static void smb_co_done(struct smb_connobj *cp) { smb_sl_destroy(&cp->co_interlock); - lockmgr(&cp->co_lock, LK_RELEASE, 0); + lockmgr(&cp->co_lock, LK_RELEASE, NULL); lockdestroy(&cp->co_lock); } static void smb_co_gone(struct smb_connobj *cp, struct smb_cred *scred) { struct smb_connobj *parent; if (cp->co_gone) cp->co_gone(cp, scred); parent = cp->co_parent; if (parent) { - smb_co_lock(parent, LK_EXCLUSIVE, scred->scr_td); + smb_co_lock(parent, LK_EXCLUSIVE); SLIST_REMOVE(&parent->co_children, cp, smb_connobj, co_next); smb_co_put(parent, scred); } if (cp->co_free) cp->co_free(cp); } void smb_co_ref(struct smb_connobj *cp) { SMB_CO_LOCK(cp); cp->co_usecount++; SMB_CO_UNLOCK(cp); } void smb_co_rele(struct smb_connobj *cp, struct smb_cred *scred) { SMB_CO_LOCK(cp); if (cp->co_usecount > 1) { cp->co_usecount--; SMB_CO_UNLOCK(cp); return; } if (cp->co_usecount == 0) { SMBERROR("negative use_count for object %d", cp->co_level); SMB_CO_UNLOCK(cp); return; } cp->co_usecount--; cp->co_flags |= SMBO_GONE; lockmgr(&cp->co_lock, LK_DRAIN | LK_INTERLOCK, &cp->co_interlock); smb_co_gone(cp, scred); } int smb_co_get(struct smb_connobj *cp, int flags, struct smb_cred *scred) { int error; if ((flags & LK_INTERLOCK) == 0) SMB_CO_LOCK(cp); cp->co_usecount++; - error = smb_co_lock(cp, flags | LK_INTERLOCK, scred->scr_td); + error = smb_co_lock(cp, flags | LK_INTERLOCK); if (error) { SMB_CO_LOCK(cp); cp->co_usecount--; SMB_CO_UNLOCK(cp); return error; } return 0; } void smb_co_put(struct smb_connobj *cp, struct smb_cred *scred) { SMB_CO_LOCK(cp); if (cp->co_usecount > 1) { cp->co_usecount--; } else if (cp->co_usecount == 1) { cp->co_usecount--; cp->co_flags |= SMBO_GONE; } else { SMBERROR("negative usecount"); } lockmgr(&cp->co_lock, LK_RELEASE | LK_INTERLOCK, &cp->co_interlock); if ((cp->co_flags & SMBO_GONE) == 0) return; lockmgr(&cp->co_lock, LK_DRAIN, NULL); smb_co_gone(cp, scred); } int -smb_co_lockstatus(struct smb_connobj *cp, struct thread *td) +smb_co_lockstatus(struct smb_connobj *cp) { return lockstatus(&cp->co_lock); } int -smb_co_lock(struct smb_connobj *cp, int flags, struct thread *td) +smb_co_lock(struct smb_connobj *cp, int flags) { if (cp->co_flags & SMBO_GONE) return EINVAL; if ((flags & LK_TYPE_MASK) == 0) flags |= LK_EXCLUSIVE; - if (smb_co_lockstatus(cp, td) == LK_EXCLUSIVE && + if (smb_co_lockstatus(cp) == LK_EXCLUSIVE && (flags & LK_CANRECURSE) == 0) { SMBERROR("recursive lock for object %d\n", cp->co_level); return 0; } return lockmgr(&cp->co_lock, flags, &cp->co_interlock); } void -smb_co_unlock(struct smb_connobj *cp, int flags, struct thread *td) +smb_co_unlock(struct smb_connobj *cp, int flags) { (void)lockmgr(&cp->co_lock, flags | LK_RELEASE, &cp->co_interlock); } static void smb_co_addchild(struct smb_connobj *parent, struct smb_connobj *child) { - KASSERT(smb_co_lockstatus(parent, curthread) == LK_EXCLUSIVE, ("smb_co_addchild: parent not locked")); - KASSERT(smb_co_lockstatus(child, curthread) == LK_EXCLUSIVE, ("smb_co_addchild: child not locked")); + + KASSERT(smb_co_lockstatus(parent) == LK_EXCLUSIVE, + ("smb_co_addchild: parent not locked")); + KASSERT(smb_co_lockstatus(child) == LK_EXCLUSIVE, + ("smb_co_addchild: child not locked")); smb_co_ref(parent); SLIST_INSERT_HEAD(&parent->co_children, child, co_next); child->co_parent = parent; } /* * Session implementation */ int smb_vc_create(struct smb_vcspec *vcspec, struct smb_cred *scred, struct smb_vc **vcpp) { struct smb_vc *vcp; - struct thread *td = scred->scr_td; struct ucred *cred = scred->scr_cred; uid_t uid = vcspec->owner; gid_t gid = vcspec->group; uid_t realuid = cred->cr_uid; char *domain = vcspec->domain; 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; vcp = smb_zmalloc(sizeof(*vcp), M_SMBCONN, M_WAITOK); - smb_co_init(VCTOCP(vcp), SMBL_VC, "smb_vc ilock", "smb_vc", td); + smb_co_init(VCTOCP(vcp), SMBL_VC, "smb_vc ilock", "smb_vc"); vcp->obj.co_free = smb_vc_free; vcp->obj.co_gone = smb_vc_gone; vcp->vc_number = smb_vcnext++; vcp->vc_timo = SMB_DEFRQTIMO; vcp->vc_smbuid = SMB_UID_UNKNOWN; vcp->vc_mode = vcspec->rights & SMBM_MASK; vcp->obj.co_flags = vcspec->flags & (SMBV_PRIVATE | SMBV_SINGLESHARE); vcp->vc_tdesc = &smb_tran_nbtcp_desc; vcp->vc_seqno = 0; vcp->vc_mackey = NULL; vcp->vc_mackeylen = 0; if (uid == SMBM_ANY_OWNER) uid = realuid; if (gid == SMBM_ANY_GROUP) gid = cred->cr_groups[0]; vcp->vc_uid = uid; vcp->vc_grp = gid; smb_sl_init(&vcp->vc_stlock, "vcstlock"); error = ENOMEM; vcp->vc_paddr = sodupsockaddr(vcspec->sap, M_WAITOK); if (vcp->vc_paddr == NULL) goto fail; vcp->vc_laddr = sodupsockaddr(vcspec->lap, M_WAITOK); if (vcp->vc_laddr == NULL) goto fail; vcp->vc_pass = smb_strdup(vcspec->pass); if (vcp->vc_pass == NULL) goto fail; vcp->vc_domain = smb_strdup((domain && domain[0]) ? domain : "NODOMAIN"); if (vcp->vc_domain == NULL) goto fail; vcp->vc_srvname = smb_strdup(vcspec->srvname); if (vcp->vc_srvname == NULL) goto fail; vcp->vc_username = smb_strdup(vcspec->username); if (vcp->vc_username == NULL) goto fail; error = (int)iconv_open("tolower", vcspec->localcs, &vcp->vc_tolower); if (error) goto fail; error = (int)iconv_open("toupper", vcspec->localcs, &vcp->vc_toupper); if (error) goto fail; if (vcspec->servercs[0]) { error = (int)iconv_open(vcspec->servercs, vcspec->localcs, &vcp->vc_toserver); if (error) goto fail; error = (int)iconv_open(vcspec->localcs, vcspec->servercs, &vcp->vc_tolocal); if (error) goto fail; } error = (int)smb_iod_create(vcp); if (error) goto fail; *vcpp = vcp; smb_co_addchild(&smb_vclist, VCTOCP(vcp)); return (0); fail: smb_vc_put(vcp, scred); return (error); } static void smb_vc_free(struct smb_connobj *cp) { struct smb_vc *vcp = CPTOVC(cp); if (vcp->vc_iod) smb_iod_destroy(vcp->vc_iod); SMB_STRFREE(vcp->vc_username); SMB_STRFREE(vcp->vc_srvname); SMB_STRFREE(vcp->vc_pass); SMB_STRFREE(vcp->vc_domain); if (vcp->vc_mackey) free(vcp->vc_mackey, M_SMBTEMP); if (vcp->vc_paddr) free(vcp->vc_paddr, M_SONAME); if (vcp->vc_laddr) free(vcp->vc_laddr, M_SONAME); if (vcp->vc_tolower) iconv_close(vcp->vc_tolower); if (vcp->vc_toupper) iconv_close(vcp->vc_toupper); if (vcp->vc_tolocal) iconv_close(vcp->vc_tolocal); if (vcp->vc_toserver) iconv_close(vcp->vc_toserver); smb_co_done(VCTOCP(vcp)); smb_sl_destroy(&vcp->vc_stlock); free(vcp, M_SMBCONN); } /* * Called when use count of VC dropped to zero. * VC should be locked on enter with LK_DRAIN. */ static void smb_vc_gone(struct smb_connobj *cp, struct smb_cred *scred) { struct smb_vc *vcp = CPTOVC(cp); smb_vc_disconnect(vcp); } void smb_vc_ref(struct smb_vc *vcp) { smb_co_ref(VCTOCP(vcp)); } void smb_vc_rele(struct smb_vc *vcp, struct smb_cred *scred) { smb_co_rele(VCTOCP(vcp), scred); } int smb_vc_get(struct smb_vc *vcp, int flags, struct smb_cred *scred) { return smb_co_get(VCTOCP(vcp), flags, scred); } void smb_vc_put(struct smb_vc *vcp, struct smb_cred *scred) { smb_co_put(VCTOCP(vcp), scred); } int -smb_vc_lock(struct smb_vc *vcp, int flags, struct thread *td) +smb_vc_lock(struct smb_vc *vcp, int flags) { - return smb_co_lock(VCTOCP(vcp), flags, td); + return smb_co_lock(VCTOCP(vcp), flags); } void -smb_vc_unlock(struct smb_vc *vcp, int flags, struct thread *td) +smb_vc_unlock(struct smb_vc *vcp, int flags) { - smb_co_unlock(VCTOCP(vcp), flags, td); + smb_co_unlock(VCTOCP(vcp), flags); } 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; } static int smb_vc_cmpshare(struct smb_share *ssp, struct smb_sharespec *dp) { int exact = 1; if (strcmp(ssp->ss_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 *dp, struct smb_cred *scred, struct smb_share **sspp) { - struct thread *td = scred->scr_td; struct smb_connobj *scp = NULL; struct smb_share *ssp = NULL; int error; *sspp = NULL; dp->scred = scred; SMBCO_FOREACH(scp, VCTOCP(vcp)) { ssp = (struct smb_share *)scp; - error = smb_share_lock(ssp, LK_EXCLUSIVE, td); + error = smb_share_lock(ssp, LK_EXCLUSIVE); if (error) continue; if (smb_vc_cmpshare(ssp, dp) == 0) break; - smb_share_unlock(ssp, 0, td); + smb_share_unlock(ssp, 0); } if (ssp) { smb_share_ref(ssp); *sspp = ssp; error = 0; } else error = ENOENT; return error; } int smb_vc_connect(struct smb_vc *vcp, struct smb_cred *scred) { return smb_iod_request(vcp->vc_iod, SMBIOD_EV_CONNECT | SMBIOD_EV_SYNC, NULL); } /* * Destroy VC to server, invalidate shares linked with it. * Transport should be locked on entry. */ int smb_vc_disconnect(struct smb_vc *vcp) { smb_iod_request(vcp->vc_iod, SMBIOD_EV_DISCONNECT | SMBIOD_EV_SYNC, NULL); return 0; } static char smb_emptypass[] = ""; const char * smb_vc_getpass(struct smb_vc *vcp) { if (vcp->vc_pass) return vcp->vc_pass; return smb_emptypass; } 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 = vcp->obj.co_usecount; vip->uid = vcp->vc_uid; vip->gid = vcp->vc_grp; vip->mode = vcp->vc_mode; vip->flags = vcp->obj.co_flags; vip->sopt = vcp->vc_sopt; vip->iodstate = vcp->vc_iod->iod_state; bzero(&vip->sopt.sv_skey, sizeof(vip->sopt.sv_skey)); snprintf(vip->srvname, sizeof(vip->srvname), "%s", vcp->vc_srvname); snprintf(vip->vcname, sizeof(vip->vcname), "%s", vcp->vc_username); return 0; } u_short smb_vc_nextmid(struct smb_vc *vcp) { u_short r; SMB_CO_LOCK(&vcp->obj); r = vcp->vc_mid++; SMB_CO_UNLOCK(&vcp->obj); return r; } /* * Share implementation */ /* * Allocate share structure and attach it to the given 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 smb_share *ssp; - struct thread *td = scred->scr_td; 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); return EEXIST; } if (uid == SMBM_ANY_OWNER) uid = realuid; if (gid == SMBM_ANY_GROUP) gid = cred->cr_groups[0]; ssp = smb_zmalloc(sizeof(*ssp), M_SMBCONN, M_WAITOK); - smb_co_init(SSTOCP(ssp), SMBL_SHARE, "smbss ilock", "smbss", td); + smb_co_init(SSTOCP(ssp), SMBL_SHARE, "smbss ilock", "smbss"); ssp->obj.co_free = smb_share_free; ssp->obj.co_gone = smb_share_gone; smb_sl_init(&ssp->ss_stlock, "ssstlock"); ssp->ss_name = smb_strdup(shspec->name); if (shspec->pass && shspec->pass[0]) ssp->ss_pass = smb_strdup(shspec->pass); ssp->ss_type = shspec->stype; ssp->ss_tid = SMB_TID_UNKNOWN; ssp->ss_uid = uid; ssp->ss_grp = gid; ssp->ss_mode = shspec->rights & SMBM_MASK; smb_co_addchild(VCTOCP(vcp), SSTOCP(ssp)); *sspp = ssp; return 0; } static void smb_share_free(struct smb_connobj *cp) { struct smb_share *ssp = CPTOSS(cp); SMB_STRFREE(ssp->ss_name); SMB_STRFREE(ssp->ss_pass); smb_sl_destroy(&ssp->ss_stlock); smb_co_done(SSTOCP(ssp)); free(ssp, M_SMBCONN); } static void smb_share_gone(struct smb_connobj *cp, struct smb_cred *scred) { struct smb_share *ssp = CPTOSS(cp); smb_smb_treedisconnect(ssp, scred); } void smb_share_ref(struct smb_share *ssp) { smb_co_ref(SSTOCP(ssp)); } void smb_share_rele(struct smb_share *ssp, struct smb_cred *scred) { smb_co_rele(SSTOCP(ssp), scred); } int smb_share_get(struct smb_share *ssp, int flags, struct smb_cred *scred) { return smb_co_get(SSTOCP(ssp), flags, scred); } void smb_share_put(struct smb_share *ssp, struct smb_cred *scred) { smb_co_put(SSTOCP(ssp), scred); } int -smb_share_lock(struct smb_share *ssp, int flags, struct thread *td) +smb_share_lock(struct smb_share *ssp, int flags) { - return smb_co_lock(SSTOCP(ssp), flags, td); + return smb_co_lock(SSTOCP(ssp), flags); } void -smb_share_unlock(struct smb_share *ssp, int flags, struct thread *td) +smb_share_unlock(struct smb_share *ssp, int flags) { - smb_co_unlock(SSTOCP(ssp), flags, td); + smb_co_unlock(SSTOCP(ssp), flags); } 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; } void smb_share_invalidate(struct smb_share *ssp) { ssp->ss_tid = SMB_TID_UNKNOWN; } int smb_share_valid(struct smb_share *ssp) { return ssp->ss_tid != SMB_TID_UNKNOWN && ssp->ss_vcgenid == SSTOVC(ssp)->vc_genid; } const char* smb_share_getpass(struct smb_share *ssp) { struct smb_vc *vcp; if (ssp->ss_pass) return ssp->ss_pass; vcp = SSTOVC(ssp); if (vcp->vc_pass) return vcp->vc_pass; return smb_emptypass; } 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 = ssp->obj.co_usecount; sip->tid = ssp->ss_tid; sip->type= ssp->ss_type; sip->uid = ssp->ss_uid; sip->gid = ssp->ss_grp; sip->mode= ssp->ss_mode; sip->flags = ssp->obj.co_flags; snprintf(sip->sname, sizeof(sip->sname), "%s", ssp->ss_name); return 0; } /* * Dump an entire tree into sysctl call */ static int smb_sysctl_treedump(SYSCTL_HANDLER_ARGS) { struct thread *td = req->td; struct smb_cred scred; struct smb_connobj *scp1, *scp2; struct smb_vc *vcp; struct smb_share *ssp; struct smb_vc_info vci; struct smb_share_info ssi; int error, itype; smb_makescred(&scred, td, td->td_ucred); error = sysctl_wire_old_buffer(req, 0); if (error) return (error); - error = smb_sm_lockvclist(LK_SHARED, td); + error = smb_sm_lockvclist(LK_SHARED); if (error) return error; SMBCO_FOREACH(scp1, &smb_vclist) { vcp = (struct smb_vc *)scp1; - error = smb_vc_lock(vcp, LK_SHARED, td); + error = smb_vc_lock(vcp, LK_SHARED); if (error) continue; smb_vc_getinfo(vcp, &vci); error = SYSCTL_OUT(req, &vci, sizeof(struct smb_vc_info)); if (error) { - smb_vc_unlock(vcp, 0, td); + smb_vc_unlock(vcp, 0); break; } SMBCO_FOREACH(scp2, VCTOCP(vcp)) { ssp = (struct smb_share *)scp2; - error = smb_share_lock(ssp, LK_SHARED, td); + error = smb_share_lock(ssp, LK_SHARED); if (error) { error = 0; continue; } smb_share_getinfo(ssp, &ssi); - smb_share_unlock(ssp, 0, td); + smb_share_unlock(ssp, 0); error = SYSCTL_OUT(req, &ssi, sizeof(struct smb_share_info)); if (error) break; } - smb_vc_unlock(vcp, 0, td); + smb_vc_unlock(vcp, 0); if (error) break; } if (!error) { itype = SMB_INFO_NONE; error = SYSCTL_OUT(req, &itype, sizeof(itype)); } - smb_sm_unlockvclist(td); + smb_sm_unlockvclist(); return error; } diff --git a/sys/netsmb/smb_conn.h b/sys/netsmb/smb_conn.h index 6dc95ab6ca43..153c83a2a99e 100644 --- a/sys/netsmb/smb_conn.h +++ b/sys/netsmb/smb_conn.h @@ -1,467 +1,467 @@ /*- * 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. * * $FreeBSD$ */ /* * Two levels of connection hierarchy */ #define SMBL_SM 0 #define SMBL_VC 1 #define SMBL_SHARE 2 #define SMBL_NUM 3 #define SMBL_NONE (-1) #define SMB_CS_NONE 0x0000 #define SMB_CS_UPPER 0x0001 /* convert passed string to upper case */ #define SMB_CS_LOWER 0x0002 /* convert passed string to lower case */ /* * Common object flags */ #define SMBO_GONE 0x1000000 /* * access modes */ #define SMBM_READ 0400 /* read conn attrs.(like list shares) */ #define SMBM_WRITE 0200 /* modify conn attrs */ #define SMBM_EXEC 0100 /* can send SMB requests */ #define SMBM_READGRP 0040 #define SMBM_WRITEGRP 0020 #define SMBM_EXECGRP 0010 #define SMBM_READOTH 0004 #define SMBM_WRITEOTH 0002 #define SMBM_EXECOTH 0001 #define SMBM_MASK 0777 #define SMBM_EXACT 010000 /* check for specified mode exactly */ #define SMBM_ALL (SMBM_READ | SMBM_WRITE | SMBM_EXEC) #define SMBM_DEFAULT (SMBM_READ | SMBM_WRITE | SMBM_EXEC) #define SMBM_ANY_OWNER ((uid_t)-1) #define SMBM_ANY_GROUP ((gid_t)-1) /* * VC flags */ #define SMBV_PERMANENT 0x0002 #define SMBV_LONGNAMES 0x0004 /* connection is configured to use long names */ #define SMBV_ENCRYPT 0x0008 /* server asked for encrypted password */ #define SMBV_WIN95 0x0010 /* used to apply bugfixes for this OS */ #define SMBV_PRIVATE 0x0020 /* connection can be used only by creator */ #define SMBV_RECONNECTING 0x0040 /* conn is in the process of reconnection */ #define SMBV_SINGLESHARE 0x0080 /* only one share connecting should be allowed */ #define SMBV_CREATE 0x0100 /* lookup for create operation */ /*#define SMBV_FAILED 0x0200*/ /* last reconnect attempt has failed */ #define SMBV_UNICODE 0x0400 /* connection is configured to use Unicode */ /* * smb_share flags */ #define SMBS_PERMANENT 0x0001 #define SMBS_RECONNECTING 0x0002 #define SMBS_CONNECTED 0x0004 /* * share types */ #define SMB_ST_DISK 0x0 /* A: */ #define SMB_ST_PRINTER 0x1 /* LPT: */ #define SMB_ST_PIPE 0x2 /* IPC */ #define SMB_ST_COMM 0x3 /* COMM */ #define SMB_ST_ANY 0x4 #define SMB_ST_MAX 0x4 #define SMB_ST_NONE 0xff /* not a part of protocol */ /* * Negotiated protocol parameters */ struct smb_sopt { int sv_proto; int16_t sv_tz; /* offset in min relative to UTC */ u_int32_t sv_maxtx; /* maximum transmit buf size */ u_char sv_sm; /* security mode */ u_int16_t sv_maxmux; /* max number of outstanding rq's */ u_int16_t sv_maxvcs; /* max number of VCs */ u_int16_t sv_rawmode; u_int32_t sv_maxraw; /* maximum raw-buffer size */ u_int32_t sv_skey; /* session key */ u_int32_t sv_caps; /* capabilities SMB_CAP_ */ }; /* * network IO daemon states */ enum smbiod_state { SMBIOD_ST_NOTCONN, /* no connect request was made */ SMBIOD_ST_RECONNECT, /* a [re]connect attempt is in progress */ SMBIOD_ST_TRANACTIVE, /* transport level is up */ SMBIOD_ST_VCACTIVE, /* session established */ SMBIOD_ST_DEAD /* connection broken, transport is down */ }; /* * Info structures */ #define SMB_INFO_NONE 0 #define SMB_INFO_VC 2 #define SMB_INFO_SHARE 3 struct smb_vc_info { int itype; int usecount; uid_t uid; /* user id of connection */ gid_t gid; /* group of connection */ mode_t mode; /* access mode */ int flags; enum smbiod_state iodstate; struct smb_sopt sopt; char srvname[SMB_MAXSRVNAMELEN + 1]; char vcname[128]; }; struct smb_share_info { int itype; int usecount; u_short tid; /* TID */ int type; /* share type */ uid_t uid; /* user id of connection */ gid_t gid; /* group of connection */ mode_t mode; /* access mode */ int flags; char sname[128]; }; #ifdef _KERNEL #include #include #include #define CONNADDREQ(a1,a2) ((a1)->sa_len == (a2)->sa_len && \ bcmp(a1, a2, (a1)->sa_len) == 0) struct smb_vc; struct smb_share; struct smb_cred; struct smb_rq; struct mbdata; struct smbioc_oshare; struct smbioc_ossn; struct uio; TAILQ_HEAD(smb_rqhead, smb_rq); #define SMB_DEFRQTIMO 5 #define SMB_DIALECT(vcp) ((vcp)->vc_sopt.sv_proto) struct smb_tran_desc; /* * Connection object */ struct smb_connobj; typedef void smb_co_gone_t (struct smb_connobj *cp, struct smb_cred *scred); typedef void smb_co_free_t (struct smb_connobj *cp); #define SMB_CO_LOCK(cp) smb_sl_lock(&(cp)->co_interlock) #define SMB_CO_UNLOCK(cp) smb_sl_unlock(&(cp)->co_interlock) struct smb_connobj { int co_level; /* SMBL_ */ int co_flags; struct lock co_lock; struct smb_slock co_interlock; int co_usecount; struct smb_connobj * co_parent; SLIST_HEAD(,smb_connobj)co_children; SLIST_ENTRY(smb_connobj)co_next; smb_co_gone_t * co_gone; smb_co_free_t * co_free; }; #define SMBCO_FOREACH(var, cp) SLIST_FOREACH((var), &(cp)->co_children, co_next) /* * Virtual Circuit (session) to a server. * This is the most (over)complicated part of SMB protocol. * For the user security level (usl), each session with different remote * user name has its own VC. * It is unclear however, should share security level (ssl) allow additional * VCs, because user name is not used and can be the same. On other hand, * multiple VCs allows us to create separate sessions to server on a per * user basis. */ /* * This lock protects vc_flags */ #define SMBC_ST_LOCK(vcp) smb_sl_lock(&(vcp)->vc_stlock) #define SMBC_ST_UNLOCK(vcp) smb_sl_unlock(&(vcp)->vc_stlock) struct smb_vc { struct smb_connobj obj; char * vc_srvname; struct sockaddr*vc_paddr; /* server addr */ struct sockaddr*vc_laddr; /* local addr, if any */ char * vc_username; char * vc_pass; /* password for usl case */ char * vc_domain; /* workgroup/primary domain */ u_int vc_timo; /* default request timeout */ int vc_maxvcs; /* maximum number of VC per connection */ void * vc_tolower; /* local charset */ void * vc_toupper; /* local charset */ void * vc_toserver; /* local charset to server one */ void * vc_tolocal; /* server charset to local one */ int vc_number; /* number of this VC from the client side */ int vc_genid; uid_t vc_uid; /* user id of connection */ gid_t vc_grp; /* group of connection */ mode_t vc_mode; /* access mode */ u_short vc_smbuid; /* unique vc id assigned by server */ u_char vc_hflags; /* or'ed with flags in the smb header */ u_short vc_hflags2; /* or'ed with flags in the smb header */ void * vc_tdata; /* transport control block */ struct smb_tran_desc *vc_tdesc; int vc_chlen; /* actual challenge length */ u_char vc_ch[SMB_MAXCHALLENGELEN]; u_short vc_mid; /* multiplex id */ struct smb_sopt vc_sopt; /* server options */ int vc_txmax; /* max tx/rx packet size */ int vc_rxmax; /* max readx data size */ int vc_wxmax; /* max writex data size */ struct smbiod * vc_iod; struct smb_slock vc_stlock; u_int32_t vc_seqno; /* my next sequence number */ u_int8_t *vc_mackey; /* MAC key */ int vc_mackeylen; /* length of MAC key */ }; #define vc_maxmux vc_sopt.sv_maxmux #define vc_flags obj.co_flags #define SMB_UNICODE_STRINGS(vcp) ((vcp)->vc_hflags2 & SMB_FLAGS2_UNICODE) /* * smb_share structure describes connection to the given SMB share (tree). * Connection to share is always built on top of the VC. */ /* * This lock protects ss_flags */ #define SMBS_ST_LOCK(ssp) smb_sl_lock(&(ssp)->ss_stlock) #define SMBS_ST_LOCKPTR(ssp) (&(ssp)->ss_stlock) #define SMBS_ST_UNLOCK(ssp) smb_sl_unlock(&(ssp)->ss_stlock) struct smb_share { struct smb_connobj obj; char * ss_name; u_short ss_tid; /* TID */ int ss_type; /* share type */ uid_t ss_uid; /* user id of connection */ gid_t ss_grp; /* group of connection */ mode_t ss_mode; /* access mode */ int ss_vcgenid; char * ss_pass; /* password to a share, can be null */ struct smb_slock ss_stlock; }; #define ss_flags obj.co_flags #define CPTOVC(cp) ((struct smb_vc*)(cp)) #define VCTOCP(vcp) (&(vcp)->obj) #define CPTOSS(cp) ((struct smb_share*)(cp)) #define SSTOVC(ssp) CPTOVC(((ssp)->obj.co_parent)) #define SSTOCP(ssp) (&(ssp)->obj) struct smb_vcspec { char * srvname; struct sockaddr*sap; struct sockaddr*lap; int flags; char * username; char * pass; char * domain; mode_t mode; mode_t rights; uid_t owner; gid_t group; char * localcs; char * servercs; struct smb_sharespec *shspec; struct smb_share *ssp; /* returned */ /* * The rest is an internal data */ struct smb_cred *scred; }; struct smb_sharespec { char * name; char * pass; mode_t mode; mode_t rights; uid_t owner; gid_t group; int stype; /* * The rest is an internal data */ struct smb_cred *scred; }; /* * Session level functions */ int smb_sm_init(void); int smb_sm_done(void); int smb_sm_lookup(struct smb_vcspec *vcspec, struct smb_sharespec *shspec, struct smb_cred *scred, struct smb_vc **vcpp); /* * Connection object */ void smb_co_ref(struct smb_connobj *cp); void smb_co_rele(struct smb_connobj *cp, struct smb_cred *scred); int smb_co_get(struct smb_connobj *cp, int flags, struct smb_cred *scred); void smb_co_put(struct smb_connobj *cp, struct smb_cred *scred); -int smb_co_lock(struct smb_connobj *cp, int flags, struct thread *td); -void smb_co_unlock(struct smb_connobj *cp, int flags, struct thread *td); +int smb_co_lock(struct smb_connobj *cp, int flags); +void smb_co_unlock(struct smb_connobj *cp, int flags); /* * session level functions */ int smb_vc_create(struct smb_vcspec *vcspec, struct smb_cred *scred, struct smb_vc **vcpp); int smb_vc_connect(struct smb_vc *vcp, struct smb_cred *scred); int smb_vc_access(struct smb_vc *vcp, struct smb_cred *scred, mode_t mode); int smb_vc_get(struct smb_vc *vcp, int flags, struct smb_cred *scred); void smb_vc_put(struct smb_vc *vcp, struct smb_cred *scred); void smb_vc_ref(struct smb_vc *vcp); void smb_vc_rele(struct smb_vc *vcp, struct smb_cred *scred); -int smb_vc_lock(struct smb_vc *vcp, int flags, struct thread *td); -void smb_vc_unlock(struct smb_vc *vcp, int flags, struct thread *td); +int smb_vc_lock(struct smb_vc *vcp, int flags); +void smb_vc_unlock(struct smb_vc *vcp, int flags); int smb_vc_lookupshare(struct smb_vc *vcp, struct smb_sharespec *shspec, struct smb_cred *scred, struct smb_share **sspp); const char * smb_vc_getpass(struct smb_vc *vcp); u_short smb_vc_nextmid(struct smb_vc *vcp); /* * share level functions */ int smb_share_create(struct smb_vc *vcp, struct smb_sharespec *shspec, struct smb_cred *scred, struct smb_share **sspp); int smb_share_access(struct smb_share *ssp, struct smb_cred *scred, mode_t mode); void smb_share_ref(struct smb_share *ssp); void smb_share_rele(struct smb_share *ssp, struct smb_cred *scred); int smb_share_get(struct smb_share *ssp, int flags, struct smb_cred *scred); void smb_share_put(struct smb_share *ssp, struct smb_cred *scred); -int smb_share_lock(struct smb_share *ssp, int flags, struct thread *td); -void smb_share_unlock(struct smb_share *ssp, int flags, struct thread *td); +int smb_share_lock(struct smb_share *ssp, int flags); +void smb_share_unlock(struct smb_share *ssp, int flags); void smb_share_invalidate(struct smb_share *ssp); int smb_share_valid(struct smb_share *ssp); const char * smb_share_getpass(struct smb_share *ssp); /* * SMB protocol level functions */ int smb_smb_negotiate(struct smb_vc *vcp, struct smb_cred *scred); int smb_smb_ssnsetup(struct smb_vc *vcp, struct smb_cred *scred); int smb_smb_ssnclose(struct smb_vc *vcp, struct smb_cred *scred); int smb_smb_treeconnect(struct smb_share *ssp, struct smb_cred *scred); int smb_smb_treedisconnect(struct smb_share *ssp, struct smb_cred *scred); int smb_read(struct smb_share *ssp, u_int16_t fid, struct uio *uio, struct smb_cred *scred); int smb_write(struct smb_share *ssp, u_int16_t fid, struct uio *uio, struct smb_cred *scred); int smb_smb_echo(struct smb_vc *vcp, struct smb_cred *scred); /* * smbiod thread */ #define SMBIOD_EV_NEWRQ 0x0001 #define SMBIOD_EV_SHUTDOWN 0x0002 #define SMBIOD_EV_CONNECT 0x0003 #define SMBIOD_EV_DISCONNECT 0x0004 #define SMBIOD_EV_TREECONNECT 0x0005 #define SMBIOD_EV_MASK 0x00ff #define SMBIOD_EV_SYNC 0x0100 #define SMBIOD_EV_PROCESSING 0x0200 struct smbiod_event { int ev_type; int ev_error; void * ev_ident; STAILQ_ENTRY(smbiod_event) ev_link; }; #define SMBIOD_SHUTDOWN 0x0001 struct smbiod { int iod_id; int iod_flags; enum smbiod_state iod_state; int iod_muxcnt; /* number of active outstanding requests */ int iod_sleeptimo; struct smb_vc * iod_vc; struct smb_slock iod_rqlock; /* iod_rqlist, iod_muxwant */ struct smb_rqhead iod_rqlist; /* list of outstanding requests */ int iod_muxwant; struct proc * iod_p; struct thread * iod_td; struct smb_cred iod_scred; struct smb_slock iod_evlock; /* iod_evlist */ STAILQ_HEAD(,smbiod_event) iod_evlist; struct timespec iod_lastrqsent; struct timespec iod_pingtimo; }; int smb_iod_init(void); int smb_iod_done(void); int smb_iod_create(struct smb_vc *vcp); int smb_iod_destroy(struct smbiod *iod); int smb_iod_request(struct smbiod *iod, int event, void *ident); int smb_iod_addrq(struct smb_rq *rqp); int smb_iod_waitrq(struct smb_rq *rqp); int smb_iod_removerq(struct smb_rq *rqp); #endif /* _KERNEL */