/*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;
}
