/*ARGSUSED*/ static int nsmb_ioctl(dev_t dev, int cmd, intptr_t arg, int flags, /* model.h */ cred_t *cr, int *rvalp) { smb_dev_t *sdp; int err; sdp = ddi_get_soft_state(statep, getminor(dev)); if (sdp == NULL) { return (DDI_FAILURE); } if ((sdp->sd_flags & NSMBFL_OPEN) == 0) { return (EBADF); } /* * Dont give access if the zone id is not as the same as we * set in the nsmb_open or dont belong to the global zone. * Check if the user belongs to this zone.. */ if (sdp->zoneid != getzoneid()) return (EIO); /* * We have a zone_shutdown call back that kills all the VCs * in a zone that's shutting down. That action will cause * all of these ioctls to fail on such VCs, so no need to * check the zone status here on every ioctl call. */ err = 0; switch (cmd) { case SMBIOC_GETVERS: (void) ddi_copyout(&nsmb_version, (void *)arg, sizeof (nsmb_version), flags); break; case SMBIOC_FLAGS2: err = smb_usr_get_flags2(sdp, arg, flags); break; case SMBIOC_GETSSNKEY: err = smb_usr_get_ssnkey(sdp, arg, flags); break; case SMBIOC_DUP_DEV: err = smb_usr_dup_dev(sdp, arg, flags); break; case SMBIOC_REQUEST: err = smb_usr_simplerq(sdp, arg, flags, cr); break; case SMBIOC_T2RQ: err = smb_usr_t2request(sdp, arg, flags, cr); break; case SMBIOC_READ: case SMBIOC_WRITE: err = smb_usr_rw(sdp, cmd, arg, flags, cr); break; case SMBIOC_NTCREATE: err = smb_usr_ntcreate(sdp, arg, flags, cr); break; case SMBIOC_PRINTJOB: err = smb_usr_printjob(sdp, arg, flags, cr); break; case SMBIOC_CLOSEFH: err = smb_usr_closefh(sdp, cr); break; case SMBIOC_SSN_CREATE: case SMBIOC_SSN_FIND: err = smb_usr_get_ssn(sdp, cmd, arg, flags, cr); break; case SMBIOC_SSN_KILL: case SMBIOC_SSN_RELE: err = smb_usr_drop_ssn(sdp, cmd); break; case SMBIOC_TREE_CONNECT: case SMBIOC_TREE_FIND: err = smb_usr_get_tree(sdp, cmd, arg, flags, cr); break; case SMBIOC_TREE_KILL: case SMBIOC_TREE_RELE: err = smb_usr_drop_tree(sdp, cmd); break; case SMBIOC_IOD_WORK: err = smb_usr_iod_work(sdp, arg, flags, cr); break; case SMBIOC_IOD_IDLE: case SMBIOC_IOD_RCFAIL: err = smb_usr_iod_ioctl(sdp, cmd, arg, flags); break; case SMBIOC_PK_ADD: case SMBIOC_PK_DEL: case SMBIOC_PK_CHK: case SMBIOC_PK_DEL_OWNER: case SMBIOC_PK_DEL_EVERYONE: err = smb_pkey_ioctl(cmd, arg, flags, cr); break; default: err = ENOTTY; break; } return (err); }
static int nsmb_dev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td) { struct smb_dev *sdp; struct smb_vc *vcp; struct smb_share *ssp; struct smb_cred *scred; int error = 0; SMB_CHECKMINOR(dev); if ((sdp->sd_flags & NSMBFL_OPEN) == 0) return EBADF; scred = malloc(sizeof(struct smb_cred), M_NSMBDEV, M_WAITOK); smb_makescred(scred, td, NULL); switch (cmd) { case SMBIOC_OPENSESSION: if (sdp->sd_vc) { error = EISCONN; goto out; } error = smb_usr_opensession((struct smbioc_ossn*)data, scred, &vcp); if (error) break; sdp->sd_vc = vcp; smb_vc_unlock(vcp, 0); sdp->sd_level = SMBL_VC; break; case SMBIOC_OPENSHARE: if (sdp->sd_share) { error = EISCONN; goto out; } if (sdp->sd_vc == NULL) { error = ENOTCONN; goto out; } error = smb_usr_openshare(sdp->sd_vc, (struct smbioc_oshare*)data, scred, &ssp); if (error) break; sdp->sd_share = ssp; smb_share_unlock(ssp, 0); sdp->sd_level = SMBL_SHARE; break; case SMBIOC_REQUEST: if (sdp->sd_share == NULL) { error = ENOTCONN; goto out; } error = smb_usr_simplerequest(sdp->sd_share, (struct smbioc_rq*)data, scred); break; case SMBIOC_T2RQ: if (sdp->sd_share == NULL) { error = ENOTCONN; goto out; } error = smb_usr_t2request(sdp->sd_share, (struct smbioc_t2rq*)data, scred); break; case SMBIOC_SETFLAGS: { struct smbioc_flags *fl = (struct smbioc_flags*)data; int on; if (fl->ioc_level == SMBL_VC) { if (fl->ioc_mask & SMBV_PERMANENT) { on = fl->ioc_flags & SMBV_PERMANENT; if ((vcp = sdp->sd_vc) == NULL) { error = ENOTCONN; goto out; } error = smb_vc_get(vcp, LK_EXCLUSIVE, scred); if (error) break; if (on && (vcp->obj.co_flags & SMBV_PERMANENT) == 0) { vcp->obj.co_flags |= SMBV_PERMANENT; smb_vc_ref(vcp); } else if (!on && (vcp->obj.co_flags & SMBV_PERMANENT)) { vcp->obj.co_flags &= ~SMBV_PERMANENT; smb_vc_rele(vcp, scred); } smb_vc_put(vcp, scred); } else error = EINVAL; } else if (fl->ioc_level == SMBL_SHARE) { if (fl->ioc_mask & SMBS_PERMANENT) { on = fl->ioc_flags & SMBS_PERMANENT; if ((ssp = sdp->sd_share) == NULL) { error = ENOTCONN; goto out; } error = smb_share_get(ssp, LK_EXCLUSIVE, scred); if (error) break; if (on && (ssp->obj.co_flags & SMBS_PERMANENT) == 0) { ssp->obj.co_flags |= SMBS_PERMANENT; smb_share_ref(ssp); } else if (!on && (ssp->obj.co_flags & SMBS_PERMANENT)) { ssp->obj.co_flags &= ~SMBS_PERMANENT; smb_share_rele(ssp, scred); } smb_share_put(ssp, scred); } else error = EINVAL; break; } else error = EINVAL; break; } case SMBIOC_LOOKUP: if (sdp->sd_vc || sdp->sd_share) { error = EISCONN; goto out; } vcp = NULL; ssp = NULL; error = smb_usr_lookup((struct smbioc_lookup*)data, scred, &vcp, &ssp); if (error) break; if (vcp) { sdp->sd_vc = vcp; smb_vc_unlock(vcp, 0); sdp->sd_level = SMBL_VC; } if (ssp) { sdp->sd_share = ssp; smb_share_unlock(ssp, 0); sdp->sd_level = SMBL_SHARE; } break; case SMBIOC_READ: case SMBIOC_WRITE: { struct smbioc_rw *rwrq = (struct smbioc_rw*)data; struct uio auio; struct iovec iov; if ((ssp = sdp->sd_share) == NULL) { error = ENOTCONN; goto out; } iov.iov_base = rwrq->ioc_base; iov.iov_len = rwrq->ioc_cnt; auio.uio_iov = &iov; auio.uio_iovcnt = 1; auio.uio_offset = rwrq->ioc_offset; auio.uio_resid = rwrq->ioc_cnt; auio.uio_segflg = UIO_USERSPACE; auio.uio_rw = (cmd == SMBIOC_READ) ? UIO_READ : UIO_WRITE; auio.uio_td = td; if (cmd == SMBIOC_READ) error = smb_read(ssp, rwrq->ioc_fh, &auio, scred); else error = smb_write(ssp, rwrq->ioc_fh, &auio, scred); rwrq->ioc_cnt -= auio.uio_resid; break; } default: error = ENODEV; } out: free(scred, M_NSMBDEV); return error; }