int
ncp_rq_dbase_path(struct ncp_rq *rqp, u_int8_t vol_num, u_int32_t dir_base,
int namelen, u_char *path, struct ncp_nlstables *nt)
{
struct mbchain *mbp = &rqp->rq;
int complen;
mb_put_uint8(mbp, vol_num);
mb_put_mem(mbp, (c_caddr_t)&dir_base, sizeof(dir_base), MB_MSYSTEM);
mb_put_uint8(mbp, 1); /* with dirbase */
if (path != NULL && path[0]) {
if (namelen < 0) {
namelen = *path++;
mb_put_uint8(mbp, namelen);
for(; namelen; namelen--) {
complen = *path++;
mb_put_uint8(mbp, complen);
mb_put_mem(mbp, path, complen, MB_MSYSTEM);
path += complen;
}
} else {
mb_put_uint8(mbp, 1); /* 1 component */
ncp_rq_pathstring(rqp, namelen, path, nt);
}
} else {
mb_put_uint8(mbp, 0);
mb_put_uint8(mbp, 0);
}
return 0;
}
/*
* Given a request with it's body already composed,
* rewind to the start and fill in the SMB header.
* This is called after the request is enqueued,
* so we have the final MID, seq num. etc.
*/
void
smb_rq_fillhdr(struct smb_rq *rqp)
{
struct mbchain mbtmp, *mbp = &mbtmp;
mblk_t *m;
/*
* Fill in the SMB header using a dup of the first mblk,
* which points at the same data but has its own wptr,
* so we can rewind without trashing the message.
*/
m = dupb(rqp->sr_rq.mb_top);
m->b_wptr = m->b_rptr; /* rewind */
mb_initm(mbp, m);
mb_put_mem(mbp, SMB_SIGNATURE, 4, MB_MSYSTEM);
mb_put_uint8(mbp, rqp->sr_cmd);
mb_put_uint32le(mbp, 0); /* status */
mb_put_uint8(mbp, rqp->sr_rqflags);
mb_put_uint16le(mbp, rqp->sr_rqflags2);
mb_put_uint16le(mbp, 0); /* pid-high */
mb_put_mem(mbp, NULL, 8, MB_MZERO); /* MAC sig. (later) */
mb_put_uint16le(mbp, 0); /* reserved */
mb_put_uint16le(mbp, rqp->sr_rqtid);
mb_put_uint16le(mbp, rqp->sr_pid);
mb_put_uint16le(mbp, rqp->sr_rquid);
mb_put_uint16le(mbp, rqp->sr_mid);
/* This will free the mblk from dupb. */
mb_done(mbp);
}
int
ncp_nsrename(struct ncp_conn *conn, int volume, int ns, int oldtype,
struct ncp_nlstables *nt,
nwdirent fdir, char *old_name, int oldlen,
nwdirent tdir, char *new_name, int newlen,
struct thread *td, struct ucred *cred)
{
struct ncp_rq *rqp;
int error;
error = ncp_rq_alloc(87, conn, td, cred, &rqp);
if (error)
return error;
mb_put_uint8(&rqp->rq, 4);
mb_put_uint8(&rqp->rq, ns);
mb_put_uint8(&rqp->rq, 1); /* RRenameToMySelf */
mb_put_uint16le(&rqp->rq, oldtype);
/* source Handle Path */
mb_put_uint8(&rqp->rq, volume);
mb_put_mem(&rqp->rq, (c_caddr_t)&fdir, sizeof(fdir), MB_MSYSTEM);
mb_put_uint8(&rqp->rq, 1);
mb_put_uint8(&rqp->rq, 1); /* 1 source component */
/* dest Handle Path */
mb_put_uint8(&rqp->rq, volume);
mb_put_mem(&rqp->rq, (c_caddr_t)&tdir, sizeof(tdir), MB_MSYSTEM);
mb_put_uint8(&rqp->rq, 1);
mb_put_uint8(&rqp->rq, 1); /* 1 destination component */
ncp_rq_pathstring(rqp, oldlen, old_name, nt);
ncp_rq_pathstring(rqp, newlen, new_name, nt);
error = ncp_request(rqp);
if (!error)
ncp_rq_done(rqp);
return error;
}
static int
smb_rq_new(struct smb_rq *rqp, u_char cmd)
{
struct smb_vc *vcp = rqp->sr_vc;
struct mbchain *mbp = &rqp->sr_rq;
int error;
rqp->sr_sendcnt = 0;
mb_done(mbp);
md_done(&rqp->sr_rp);
error = mb_init(mbp);
if (error)
return error;
mb_put_mem(mbp, SMB_SIGNATURE, SMB_SIGLEN, MB_MSYSTEM);
mb_put_uint8(mbp, cmd);
mb_put_uint32le(mbp, 0); /* DosError */
mb_put_uint8(mbp, vcp->vc_hflags);
mb_put_uint16le(mbp, vcp->vc_hflags2);
mb_put_mem(mbp, tzero, 12, MB_MSYSTEM);
rqp->sr_rqtid = (u_int16_t*)mb_reserve(mbp, sizeof(u_int16_t));
mb_put_uint16le(mbp, 1 /*scred->sc_p->p_pid & 0xffff*/);
rqp->sr_rquid = (u_int16_t*)mb_reserve(mbp, sizeof(u_int16_t));
mb_put_uint16le(mbp, rqp->sr_mid);
return 0;
}
int
smb_put_dmem(struct mbchain *mbp, struct smb_vc *vcp, const char *src,
int size, int caseopt)
{
struct iconv_drv *dp = vcp->vc_toserver;
if (size == 0)
return 0;
if (dp == NULL) {
return mb_put_mem(mbp, src, size, MB_MSYSTEM);
}
mbp->mb_copy = smb_copy_iconv;
mbp->mb_udata = dp;
return mb_put_mem(mbp, src, size, MB_MCUSTOM);
}
/*
* copies a uio scatter/gather list to an mbuf chain.
*/
int
mb_put_uio(struct mbchain *mbp, struct uio *uiop, int size)
{
long left;
int mtype, error;
mtype = (uiop->uio_segflg == UIO_SYSSPACE) ? MB_MSYSTEM : MB_MUSER;
while (size > 0 && uiop->uio_resid) {
if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
return EFBIG;
left = uiop->uio_iov->iov_len;
if (left == 0) {
uiop->uio_iov++;
uiop->uio_iovcnt--;
continue;
}
if (left > size)
left = size;
error = mb_put_mem(mbp, uiop->uio_iov->iov_base, left, mtype);
if (error)
return error;
uiop->uio_offset += left;
uiop->uio_resid -= left;
uiop->uio_iov->iov_base =
(char *)uiop->uio_iov->iov_base + left;
uiop->uio_iov->iov_len -= left;
size -= left;
}
return 0;
}
int
ncp_search_for_file_or_subdir(struct nwmount *nmp,
struct nw_search_seq *seq,
struct nw_entry_info *target,
struct thread *td,struct ucred *cred)
{
struct ncp_conn *conn = NWFSTOCONN(nmp);
struct ncp_rq *rqp;
int error;
error = ncp_rq_alloc(87, conn, td, cred, &rqp);
if (error)
return error;
mb_put_uint8(&rqp->rq, 3); /* subfunction */
mb_put_uint8(&rqp->rq, nmp->name_space);
mb_put_uint8(&rqp->rq, 0); /* data stream */
mb_put_uint16le(&rqp->rq, 0xffff); /* Search attribs */
mb_put_uint32le(&rqp->rq, IM_ALL); /* return info mask */
mb_put_mem(&rqp->rq, (caddr_t)seq, 9, MB_MSYSTEM);
mb_put_uint8(&rqp->rq, 2); /* 2 byte pattern */
mb_put_uint8(&rqp->rq, 0xff); /* following is a wildcard */
mb_put_uint8(&rqp->rq, '*');
rqp->nr_minrplen = sizeof(*seq) + 1 + NCP_INFOSZ + 1;
error = ncp_request(rqp);
if (error)
return error;
md_get_mem(&rqp->rp, (caddr_t)seq, sizeof(*seq), MB_MSYSTEM);
md_get_uint8(&rqp->rp, NULL); /* skip */
error = ncp_extract_file_info(nmp, rqp, target, 1);
ncp_rq_done(rqp);
return error;
}
int
ncp_modify_file_or_subdir_dos_info(struct nwmount *nmp, struct vnode *vp,
u_int32_t info_mask,
struct nw_modify_dos_info *info,
struct thread *td,struct ucred *cred)
{
struct nwnode *np=VTONW(vp);
struct ncp_rq *rqp;
u_int8_t volnum = nmp->n_volume;
u_int32_t dirent = np->n_fid.f_id;
struct ncp_conn *conn=NWFSTOCONN(nmp);
int error;
error = ncp_rq_alloc(87, conn, td, cred, &rqp);
if (error)
return error;
mb_put_uint8(&rqp->rq, 7); /* subfunction */
mb_put_uint8(&rqp->rq, nmp->name_space);
mb_put_uint8(&rqp->rq, 0); /* reserved */
mb_put_uint16le(&rqp->rq, SA_ALL); /* search attribs: all */
mb_put_uint32le(&rqp->rq, info_mask);
mb_put_mem(&rqp->rq, (caddr_t)info, sizeof(*info), MB_MSYSTEM);
ncp_rq_dbase_path(rqp, volnum, dirent, 0, NULL, NULL);
error = ncp_request(rqp);
if (!error)
ncp_rq_done(rqp);
return error;
}
static int
mb_put_sid(mbchain_t *mbp, i_ntsid_t *sid)
{
uint32_t *subauthp;
int error, i;
if (sid == NULL)
return (EINVAL);
ERRCHK(mb_put_uint8(mbp, sid->sid_revision));
ERRCHK(mb_put_uint8(mbp, sid->sid_subauthcount));
ERRCHK(mb_put_mem(mbp, sid->sid_authority, 6, MB_MSYSTEM));
subauthp = &sid->sid_subauthvec[0];
for (i = 0; i < sid->sid_subauthcount; i++) {
ERRCHK(mb_put_uint32le(mbp, *subauthp));
subauthp++;
}
/* Success! */
return (0);
errout:
return (error);
}
static int
smb_rq_new(struct smb_rq *rqp, uchar_t cmd)
{
struct mbchain *mbp = &rqp->sr_rq;
struct smb_vc *vcp = rqp->sr_vc;
int error;
ASSERT(rqp != NULL);
rqp->sr_sendcnt = 0;
rqp->sr_cmd = cmd;
mb_done(mbp);
md_done(&rqp->sr_rp);
error = mb_init(mbp);
if (error)
return (error);
/*
* Is this the right place to save the flags?
*/
rqp->sr_rqflags = vcp->vc_hflags;
rqp->sr_rqflags2 = vcp->vc_hflags2;
/*
* The SMB header is filled in later by
* smb_rq_fillhdr (see below)
* Just reserve space here.
*/
mb_put_mem(mbp, NULL, SMB_HDRLEN, MB_MZERO);
return (0);
}
int
smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime,
struct smb_cred *scred)
{
struct smb_rq *rqp;
struct mbchain *mbp;
u_long xtime;
int error;
error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_CLOSE, scred, &rqp);
if (error)
return error;
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (void *)&fid, sizeof(fid), MB_MSYSTEM);
if (mtime) {
smb_time_local2server(mtime, SSTOVC(ssp)->vc_sopt.sv_tz, &xtime);
} else
xtime = 0;
mb_put_uint32le(mbp, xtime);
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
smb_rq_done(rqp);
return error;
}
static int
smbfs_smb_seteof(struct smbnode *np, int64_t newsize, struct smb_cred *scred)
{
struct smb_t2rq *t2p;
struct smb_share *ssp = np->n_mount->sm_share;
struct mbchain *mbp;
int error;
error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
scred, &t2p);
if (error)
return error;
mbp = &t2p->t2_tparam;
mb_init(mbp);
mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
mb_put_uint16le(mbp, SMB_SET_FILE_END_OF_FILE_INFO);
mb_put_uint32le(mbp, 0);
mbp = &t2p->t2_tdata;
mb_init(mbp);
mb_put_int64le(mbp, newsize);
mb_put_uint32le(mbp, 0); /* padding */
mb_put_uint16le(mbp, 0);
t2p->t2_maxpcount = 2;
t2p->t2_maxdcount = 0;
error = smb_t2_request(t2p);
smb_t2_done(t2p);
return error;
}
int
smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime,
struct smb_cred *scred)
{
struct smb_rq *rqp;
struct mbchain *mbp;
u_long time;
int error;
rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK);
error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CLOSE, scred);
if (error) {
free(rqp, M_SMBFSDATA);
return error;
}
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
if (mtime) {
smb_time_local2server(mtime, SSTOVC(ssp)->vc_sopt.sv_tz, &time);
} else
time = 0;
mb_put_uint32le(mbp, time);
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
smb_rq_done(rqp);
free(rqp, M_SMBFSDATA);
return error;
}
int
smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred)
{
struct smb_share *ssp = np->n_mount->sm_share;
struct smb_rq rq, *rqp = &rq;
struct mbchain *mbp;
int error;
error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_WRITE, scred);
if (error)
return error;
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
mb_put_uint16le(mbp, 0);
mb_put_uint32le(mbp, newsize);
mb_put_uint16le(mbp, 0);
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
mb_put_uint8(mbp, SMB_DT_DATA);
mb_put_uint16le(mbp, 0);
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
smb_rq_done(rqp);
return error;
}
static int
smb_smb_flush(struct smbnode *np, struct smb_cred *scred)
{
struct smb_share *ssp = np->n_mount->sm_share;
struct smb_rq *rqp;
struct mbchain *mbp;
int error;
if ((np->n_flag & NOPEN) == 0 || !SMBTOV(np) ||
SMBTOV(np)->v_type != VREG)
return 0; /* not a regular open file */
rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK);
error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_FLUSH, scred);
if (error) {
free(rqp, M_SMBFSDATA);
return (error);
}
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
smb_rq_done(rqp);
free(rqp, M_SMBFSDATA);
if (!error)
np->n_flag &= ~NFLUSHWIRE;
return (error);
}
int
smbfs_smb_setfsize(struct smbnode *np, u_quad_t newsize,
struct smb_cred *scred)
{
struct smb_share *ssp = np->n_mount->sm_share;
struct smb_rq *rqp;
struct mbchain *mbp;
int error;
if (newsize >= (1LL << 32)) {
if (!(SMB_CAPS(SSTOVC(ssp)) & SMB_CAP_LARGE_FILES))
return EFBIG;
return smbfs_smb_seteof(np, (int64_t)newsize, scred);
}
error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp);
if (error)
return error;
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (void *)&np->n_fid, 2, MB_MSYSTEM);
mb_put_uint16le(mbp, 0);
mb_put_uint32le(mbp, newsize);
mb_put_uint16le(mbp, 0);
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
mb_put_uint8(mbp, SMB_DT_DATA);
mb_put_uint16le(mbp, 0);
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
smb_rq_done(rqp);
return error;
}
int
smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred)
{
struct smb_share *ssp = np->n_mount->sm_share;
struct smb_rq *rqp;
struct mbchain *mbp;
int error;
if (!smbfs_smb_seteof(np, (int64_t) newsize, scred)) {
np->n_flag |= NFLUSHWIRE;
return (0);
}
rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK);
error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_WRITE, scred);
if (error) {
free(rqp, M_SMBFSDATA);
return error;
}
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
mb_put_uint16le(mbp, 0);
mb_put_uint32le(mbp, newsize);
mb_put_uint16le(mbp, 0);
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
mb_put_uint8(mbp, SMB_DT_DATA);
mb_put_uint16le(mbp, 0);
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
smb_rq_done(rqp);
free(rqp, M_SMBFSDATA);
return error;
}
static inline int
smb_smb_read(struct smb_share *ssp, u_int16_t fid,
size_t *len, size_t *rresid, struct uio *uio, struct smb_cred *scred)
{
struct smb_rq *rqp;
struct mbchain *mbp;
struct mdchain *mdp;
u_int16_t resid, bc;
u_int8_t wc;
int error, rlen, blksz;
/* Cannot read at/beyond 4G */
if (uio->uio_offset >= (1LL << 32))
return (EFBIG);
error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_READ, scred, &rqp);
if (error)
return error;
blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16;
rlen = *len = min(blksz, *len);
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (void *)&fid, sizeof(fid), MB_MSYSTEM);
mb_put_uint16le(mbp, rlen);
mb_put_uint32le(mbp, uio->uio_offset);
mb_put_uint16le(mbp, min(uio->uio_resid, 0xffff));
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
smb_rq_bend(rqp);
do {
error = smb_rq_simple(rqp);
if (error)
break;
smb_rq_getreply(rqp, &mdp);
md_get_uint8(mdp, &wc);
if (wc != 5) {
error = EBADRPC;
break;
}
md_get_uint16le(mdp, &resid);
md_get_mem(mdp, NULL, 4 * 2, MB_MSYSTEM);
md_get_uint16le(mdp, &bc);
md_get_uint8(mdp, NULL); /* ignore buffer type */
md_get_uint16le(mdp, &resid);
if (resid == 0) {
*rresid = resid;
break;
}
error = md_get_uio(mdp, uio, resid);
if (error)
break;
*rresid = resid;
} while(0);
smb_rq_done(rqp);
return error;
}
static inline int
smb_smb_writex(struct smb_share *ssp, u_int16_t fid, size_t *len, size_t *rresid,
struct uio *uio, struct smb_cred *scred)
{
struct smb_rq *rqp;
struct mbchain *mbp;
struct mdchain *mdp;
int error;
u_int8_t wc;
u_int16_t resid;
error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE_ANDX, scred, &rqp);
if (error)
return (error);
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_uint8(mbp, 0xff); /* no secondary command */
mb_put_uint8(mbp, 0); /* MBZ */
mb_put_uint16le(mbp, 0); /* offset to secondary */
mb_put_mem(mbp, (void *)&fid, sizeof(fid), MB_MSYSTEM);
mb_put_uint32le(mbp, uio->uio_offset);
mb_put_uint32le(mbp, 0); /* MBZ (timeout) */
mb_put_uint16le(mbp, 0); /* !write-thru */
mb_put_uint16le(mbp, 0);
*len = min(SSTOVC(ssp)->vc_wxmax, *len);
mb_put_uint16le(mbp, *len >> 16);
mb_put_uint16le(mbp, *len);
mb_put_uint16le(mbp, 64); /* data offset from header start */
mb_put_uint32le(mbp, uio->uio_offset >> 32); /* OffsetHigh */
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
do {
mb_put_uint8(mbp, 0xee); /* mimic xp pad byte! */
error = mb_put_uio(mbp, uio, *len);
if (error)
break;
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
if (error)
break;
smb_rq_getreply(rqp, &mdp);
md_get_uint8(mdp, &wc);
if (wc != 6) {
error = EBADRPC;
break;
}
md_get_uint8(mdp, NULL);
md_get_uint8(mdp, NULL);
md_get_uint16(mdp, NULL);
md_get_uint16le(mdp, &resid);
*rresid = resid;
} while(0);
smb_rq_done(rqp);
return (error);
}
static inline int
smb_smb_write(struct smb_share *ssp, u_int16_t fid, size_t *len, size_t *rresid,
struct uio *uio, struct smb_cred *scred)
{
struct smb_rq *rqp;
struct mbchain *mbp;
struct mdchain *mdp;
u_int16_t resid;
u_int8_t wc;
int error, blksz;
/* Cannot write at/beyond 4G */
if (uio->uio_offset >= (1LL << 32))
return (EFBIG);
blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16;
if (blksz > 0xffff)
blksz = 0xffff;
resid = *len = min(blksz, *len);
error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp);
if (error)
return error;
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (void *)&fid, sizeof(fid), MB_MSYSTEM);
mb_put_uint16le(mbp, resid);
mb_put_uint32le(mbp, uio->uio_offset);
mb_put_uint16le(mbp, min(uio->uio_resid, 0xffff));
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
mb_put_uint8(mbp, SMB_DT_DATA);
mb_put_uint16le(mbp, resid);
do {
error = mb_put_uio(mbp, uio, resid);
if (error)
break;
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
if (error)
break;
smb_rq_getreply(rqp, &mdp);
md_get_uint8(mdp, &wc);
if (wc != 1) {
error = EBADRPC;
break;
}
md_get_uint16le(mdp, &resid);
*rresid = resid;
} while(0);
smb_rq_done(rqp);
return error;
}
int
ncp_rq_pathstring(struct ncp_rq *rqp, int size, const char *name,
struct ncp_nlstables *nt)
{
struct mbchain *mbp = &rqp->rq;
mb_put_uint8(mbp, size);
mbp->mb_copy = ncp_rq_pathstrhelp;
mbp->mb_udata = nt;
return mb_put_mem(mbp, (c_caddr_t)name, size, MB_MCUSTOM);
}
int
mb_put_pstring(struct mbdata *mbp, const char *s)
{
int error, len = strlen(s);
if (len > 255) {
len = 255;
}
if ((error = mb_put_uint8(mbp, len)) != 0)
return error;
return mb_put_mem(mbp, s, len);
}
static __inline int
smb_smb_write(struct smb_share *ssp, u_int16_t fid, int *len, int *rresid,
struct uio *uio, struct smb_cred *scred)
{
struct smb_rq *rqp;
struct mbchain *mbp;
struct mdchain *mdp;
u_int16_t resid;
u_int8_t wc;
int error, blksz;
/* write data must be real */
KKASSERT(uio->uio_segflg != UIO_NOCOPY);
blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16;
if (blksz > 0xffff)
blksz = 0xffff;
resid = *len = min(blksz, *len);
error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp);
if (error)
return error;
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
mb_put_uint16le(mbp, resid);
mb_put_uint32le(mbp, uio->uio_offset);
mb_put_uint16le(mbp, (unsigned short)szmin(uio->uio_resid, 0xffff));
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
mb_put_uint8(mbp, SMB_DT_DATA);
mb_put_uint16le(mbp, resid);
do {
error = mb_put_uio(mbp, uio, resid);
if (error)
break;
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
if (error)
break;
smb_rq_getreply(rqp, &mdp);
md_get_uint8(mdp, &wc);
if (wc != 1) {
error = EBADRPC;
break;
}
md_get_uint16le(mdp, &resid);
*rresid = resid;
} while(0);
smb_rq_done(rqp);
return error;
}
static int
smb_cpdatain(struct mbchain *mbp, int len, caddr_t data)
{
int error;
if (len == 0)
return 0;
error = mb_init(mbp);
if (error)
return error;
return mb_put_mem(mbp, data, len, MB_MUSER);
}
int
ncp_rq_pstring(struct ncp_rq *rqp, const char *s)
{
u_int len = strlen(s);
int error;
if (len > 255)
return EINVAL;
error = mb_put_uint8(&rqp->rq, len);
if (error)
return error;
return mb_put_mem(&rqp->rq, s, len, MB_MSYSTEM);
}
static int
smb_rq_new(struct smb_rq *rqp, u_char cmd)
{
struct smb_vc *vcp = rqp->sr_vc;
struct mbchain *mbp = &rqp->sr_rq;
int error;
u_int16_t flags2;
rqp->sr_sendcnt = 0;
mb_done(mbp);
md_done(&rqp->sr_rp);
error = mb_init(mbp);
if (error)
return error;
mb_put_mem(mbp, SMB_SIGNATURE, SMB_SIGLEN, MB_MSYSTEM);
mb_put_uint8(mbp, cmd);
mb_put_uint32le(mbp, 0); /* DosError */
mb_put_uint8(mbp, vcp->vc_hflags);
flags2 = vcp->vc_hflags2;
if (cmd == SMB_COM_TRANSACTION || cmd == SMB_COM_TRANSACTION_SECONDARY)
flags2 &= ~SMB_FLAGS2_UNICODE;
if (cmd == SMB_COM_NEGOTIATE)
flags2 &= ~SMB_FLAGS2_SECURITY_SIGNATURE;
mb_put_uint16le(mbp, flags2);
if ((flags2 & SMB_FLAGS2_SECURITY_SIGNATURE) == 0) {
mb_put_mem(mbp, tzero, 12, MB_MSYSTEM);
rqp->sr_rqsig = NULL;
} else {
mb_put_uint16le(mbp, 0 /*scred->sc_p->p_pid >> 16*/);
rqp->sr_rqsig = (u_int8_t *)mb_reserve(mbp, 8);
mb_put_uint16le(mbp, 0);
}
rqp->sr_rqtid = mb_reserve(mbp, sizeof(u_int16_t));
mb_put_uint16le(mbp, 1 /*scred->sc_p->p_pid & 0xffff*/);
rqp->sr_rquid = mb_reserve(mbp, sizeof(u_int16_t));
mb_put_uint16le(mbp, rqp->sr_mid);
return 0;
}
/*
* Setup a request for NT DIRECTORY CHANGE NOTIFY.
*/
int
smbfs_smb_nt_dirnotify_setup(struct smbnode *dnp, struct smb_rq **rqpp, struct smb_cred *scred, void (*notifyhook)(void *), void *notifyarg)
{
struct smb_rq *rqp;
struct smb_share *ssp = dnp->n_mount->sm_share;
struct mbchain *mbp;
int error;
error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_NT_TRANSACT, scred, &rqp);
if (error)
return error;
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_uint8(mbp, 0xff); /* Max setup words to return */
mb_put_uint16le(mbp, 0); /* Flags (according to Samba) */
mb_put_uint32le(mbp, 0); /* Total parameter bytes being sent*/
mb_put_uint32le(mbp, 0); /* Total data bytes being sent */
mb_put_uint32le(mbp, 10*1024); /* Max parameter bytes to return */
mb_put_uint32le(mbp, 0); /* Max data bytes to return */
mb_put_uint32le(mbp, 0); /* Parameter bytes sent this buffer */
mb_put_uint32le(mbp, 0); /* Offset (from h. start) to Param */
mb_put_uint32le(mbp, 0); /* Data bytes sent this buffer */
mb_put_uint32le(mbp, 0); /* Offset (from h. start) to Data */
mb_put_uint8(mbp, 4); /* Count of setup words */
mb_put_uint16le(mbp, SMB_NTTRANS_NOTIFY_CHANGE); /* Trans func code */
/* NT TRANSACT NOTIFY CHANGE: Request Change Notification */
mb_put_uint32le(mbp,
FILE_NOTIFY_CHANGE_NAME|FILE_NOTIFY_CHANGE_ATTRIBUTES|
FILE_NOTIFY_CHANGE_SIZE|FILE_NOTIFY_CHANGE_LAST_WRITE|
FILE_NOTIFY_CHANGE_CREATION); /* CompletionFilter */
mb_put_mem(mbp, (void *)&dnp->n_fid, 2, MB_MSYSTEM); /* FID */
mb_put_uint8(mbp, 0); /* WatchTree - Watch all subdirs too */
mb_put_uint8(mbp, 0); /* Reserved - must be zero */
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
smb_rq_bend(rqp);
/* No timeout */
rqp->sr_timo = -1;
smb_rq_setcallback(rqp, notifyhook, notifyarg);
error = smb_rq_enqueue(rqp);
if (!error)
*rqpp = rqp;
else
smb_rq_done(rqp);
return (error);
}
/*
* Set DOS file attributes. mtime should be NULL for dialects above lm10
*/
int
smbfs_smb_setpattr(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
struct smb_cred *scred)
{
struct smb_rq *rqp;
struct smb_share *ssp = np->n_mount->sm_share;
struct mbchain *mbp;
u_long time;
int error, svtz;
rqp = malloc(sizeof(struct smb_rq), M_SMBFSDATA, M_WAITOK);
error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION, scred);
if (error) {
free(rqp, M_SMBFSDATA);
return error;
}
svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
smb_rq_getrequest(rqp, &mbp);
smb_rq_wstart(rqp);
mb_put_uint16le(mbp, attr);
if (mtime) {
smb_time_local2server(mtime, svtz, &time);
} else
time = 0;
mb_put_uint32le(mbp, time); /* mtime */
mb_put_mem(mbp, NULL, 5 * 2, MB_MZERO);
smb_rq_wend(rqp);
smb_rq_bstart(rqp);
mb_put_uint8(mbp, SMB_DT_ASCII);
do {
error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
if (error)
break;
mb_put_uint8(mbp, SMB_DT_ASCII);
if (SMB_UNICODE_STRINGS(SSTOVC(ssp))) {
mb_put_padbyte(mbp);
mb_put_uint8(mbp, 0); /* 1st byte of NULL Unicode char */
}
mb_put_uint8(mbp, 0);
smb_rq_bend(rqp);
error = smb_rq_simple(rqp);
if (error) {
SMBERROR("smb_rq_simple(rqp) => error %d\n", error);
break;
}
} while(0);
smb_rq_done(rqp);
free(rqp, M_SMBFSDATA);
return error;
}
int
mb_put_padbyte(struct mbchain *mbp)
{
caddr_t dst;
uint8_t x = 0;
dst = mtod(mbp->mb_cur, caddr_t) + mbp->mb_cur->m_len;
/* Only add padding if address is odd */
if ((unsigned long)dst & 1)
return (mb_put_mem(mbp, (caddr_t)&x, sizeof(x), MB_MSYSTEM));
else
return (0);
}
int
mb_put_padbyte(struct mbchain *mbp)
{
caddr_t dst;
char x = 0;
dst = mtod(mbp->mb_cur, caddr_t) + mbp->mb_cur->m_len;
/* only add padding if address is odd */
if ((unsigned long)dst & 1)
return mb_put_mem(mbp, (caddr_t)&x, 1, MB_MSYSTEM);
else
return 0;
}
