git.samba.org / samba.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
r4069: better error code for SMBwriteBMPX
[samba.git] / source4 / smb_server / reply.c
diff --git a/source4/smb_server/reply.c b/source4/smb_server/reply.c
index 94317bfc39830bffd46963ab3feb9a32207c396f..d81b2bfeefb84479bb0197813efd2fb51073eefd 100644 (file)
--- a/source4/smb_server/reply.c
+++ b/source4/smb_server/reply.c
@@ -24,6 +24,8 @@
 */
 
 #include "includes.h"
+#include "smb_server/smb_server.h"
+
 
 /* useful way of catching wct errors with file and line number */
 #define REQ_CHECK_WCT(req, wcount) do { \
@@ -34,10 +36,10 @@
                return; \
        }} while (0)
 
-/* check req->async.status and if not OK then send an error reply */
+/* check req->async_states->status and if not OK then send an error reply */
 #define CHECK_ASYNC_STATUS do { \
-       if (!NT_STATUS_IS_OK(req->async.status)) { \
-               req_reply_error(req, req->async.status); \
+       if (!NT_STATUS_IS_OK(req->async_states->status)) { \
+               req_reply_error(req, req->async_states->status); \
                return; \
        }} while (0)
        
@@ -55,8 +57,8 @@
    immediately
 */
 #define REQ_ASYNC_TAIL do { \
-       if (!(req->control_flags & REQ_CONTROL_ASYNC)) { \
-               req->async.send_fn(req); \
+       if (!(req->async_states->state & NTVFS_ASYNC_STATE_ASYNC)) { \
+               req->async_states->send_fn(req); \
        }} while (0)
 
 /* zero out some reserved fields in a reply */
@@ -81,7 +83,7 @@ void reply_tcon(struct smbsrv_request *req)
 {
        union smb_tcon con;
        NTSTATUS status;
-       char *p;
+       uint8_t *p;
        
        /* parse request */
        REQ_CHECK_WCT(req, 0);
@@ -124,7 +126,7 @@ void reply_tcon_and_X(struct smbsrv_request *req)
 {
        NTSTATUS status;
        union smb_tcon con;
-       char *p;
+       uint8_t *p;
        uint16_t passlen;
 
        con.tconx.level = RAW_TCON_TCONX;
@@ -206,7 +208,7 @@ void reply_unknown(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_ioctl_send(struct smbsrv_request *req)
 {
-       union smb_ioctl *io = req->async.private;
+       union smb_ioctl *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -236,11 +238,12 @@ void reply_ioctl(struct smbsrv_request *req)
        io->ioctl.in.fnum     = req_fnum(req, req->in.vwv, VWV(0));
        io->ioctl.in.request  = IVAL(req->in.vwv, VWV(1));
 
-       req->async.send_fn = reply_ioctl_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_ioctl_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->ioctl(req, io);
+       req->async_states->status = ntvfs_ioctl(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -257,9 +260,10 @@ void reply_chkpth(struct smbsrv_request *req)
 
        req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE);
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
-       req->async.status = req->tcon->ntvfs_ops->chkpath(req, io);
+       req->async_states->status = ntvfs_chkpath(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -269,7 +273,7 @@ void reply_chkpth(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_getatr_send(struct smbsrv_request *req)
 {
-       union smb_fileinfo *st = req->async.private;
+       union smb_fileinfo *st = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
        
@@ -304,11 +308,12 @@ void reply_getatr(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_getatr_send;
-       req->async.private = st;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_getatr_send;
+       req->async_states->private_data = st;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->qpathinfo(req, st);
+       req->async_states->status = ntvfs_qpathinfo(req, st);
 
        REQ_ASYNC_TAIL;
 }
@@ -336,10 +341,11 @@ void reply_setatr(struct smbsrv_request *req)
                return;
        }
        
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->setpathinfo(req, st);
+       req->async_states->status = ntvfs_setpathinfo(req, st);
 
        REQ_ASYNC_TAIL;
 }
@@ -350,7 +356,7 @@ void reply_setatr(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_dskattr_send(struct smbsrv_request *req)
 {
-       union smb_fsinfo *fs = req->async.private;
+       union smb_fsinfo *fs = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
        
@@ -379,11 +385,12 @@ void reply_dskattr(struct smbsrv_request *req)
        
        fs->dskattr.level = RAW_QFS_DSKATTR;
 
-       req->async.send_fn = reply_dskattr_send;
-       req->async.private = fs;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_dskattr_send;
+       req->async_states->private_data = fs;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->fsinfo(req, fs);
+       req->async_states->status = ntvfs_fsinfo(req, fs);
 
        REQ_ASYNC_TAIL;
 }
@@ -395,18 +402,18 @@ void reply_dskattr(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_open_send(struct smbsrv_request *req)
 {
-       union smb_open *oi = req->async.private;
+       union smb_open *oi = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
        /* construct reply */
        req_setup_reply(req, 7, 0);
 
-       SSVAL(req->out.vwv, VWV(0), oi->open.out.fnum);
-       SSVAL(req->out.vwv, VWV(1), oi->open.out.attrib);
-       srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(2), oi->open.out.write_time);
-       SIVAL(req->out.vwv, VWV(4), oi->open.out.size);
-       SSVAL(req->out.vwv, VWV(6), oi->open.out.rmode);
+       SSVAL(req->out.vwv, VWV(0), oi->openold.out.fnum);
+       SSVAL(req->out.vwv, VWV(1), oi->openold.out.attrib);
+       srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(2), oi->openold.out.write_time);
+       SIVAL(req->out.vwv, VWV(4), oi->openold.out.size);
+       SSVAL(req->out.vwv, VWV(6), oi->openold.out.rmode);
 
        req_send_reply(req);
 }
@@ -422,22 +429,23 @@ void reply_open(struct smbsrv_request *req)
        REQ_CHECK_WCT(req, 2);
        REQ_TALLOC(oi, sizeof(*oi));
 
-       oi->open.level = RAW_OPEN_OPEN;
-       oi->open.in.flags = SVAL(req->in.vwv, VWV(0));
-       oi->open.in.search_attrs = SVAL(req->in.vwv, VWV(1));
+       oi->openold.level = RAW_OPEN_OPEN;
+       oi->openold.in.flags = SVAL(req->in.vwv, VWV(0));
+       oi->openold.in.search_attrs = SVAL(req->in.vwv, VWV(1));
 
-       req_pull_ascii4(req, &oi->open.in.fname, req->in.data, STR_TERMINATE);
+       req_pull_ascii4(req, &oi->openold.in.fname, req->in.data, STR_TERMINATE);
 
-       if (!oi->open.in.fname) {
+       if (!oi->openold.in.fname) {
                req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND);
                return;
        }
 
-       req->async.send_fn = reply_open_send;
-       req->async.private = oi;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_open_send;
+       req->async_states->private_data = oi;
        
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->open(req, oi);
+       req->async_states->status = ntvfs_openfile(req, oi);
 
        REQ_ASYNC_TAIL;
 }
@@ -448,7 +456,7 @@ void reply_open(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_open_and_X_send(struct smbsrv_request *req)
 {
-       union smb_open *oi = req->async.private;
+       union smb_open *oi = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -508,11 +516,12 @@ void reply_open_and_X(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_open_and_X_send;
-       req->async.private = oi;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_open_and_X_send;
+       req->async_states->private_data = oi;
 
        /* call the backend */
-       req->async.status = req->tcon->ntvfs_ops->open(req, oi);
+       req->async_states->status = ntvfs_openfile(req, oi);
 
        REQ_ASYNC_TAIL;
 }
@@ -523,7 +532,7 @@ void reply_open_and_X(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_mknew_send(struct smbsrv_request *req)
 {
-       union smb_open *oi = req->async.private;
+       union smb_open *oi = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -547,7 +556,11 @@ void reply_mknew(struct smbsrv_request *req)
        REQ_CHECK_WCT(req, 3);
        REQ_TALLOC(oi, sizeof(*oi));
 
-       oi->mknew.level = RAW_OPEN_MKNEW;
+       if (CVAL(req->in.hdr, HDR_COM) == SMBmknew) {
+               oi->mknew.level = RAW_OPEN_MKNEW;
+       } else {
+               oi->mknew.level = RAW_OPEN_CREATE;
+       }
        oi->mknew.in.attrib  = SVAL(req->in.vwv, VWV(0));
        oi->mknew.in.write_time  = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1));
 
@@ -558,11 +571,12 @@ void reply_mknew(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_mknew_send;
-       req->async.private = oi;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_mknew_send;
+       req->async_states->private_data = oi;
 
        /* call the backend */
-       req->async.status = req->tcon->ntvfs_ops->open(req, oi);
+       req->async_states->status = ntvfs_openfile(req, oi);
 
        REQ_ASYNC_TAIL;
 }
@@ -572,7 +586,7 @@ void reply_mknew(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_ctemp_send(struct smbsrv_request *req)
 {
-       union smb_open *oi = req->async.private;
+       union smb_open *oi = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -582,7 +596,7 @@ static void reply_ctemp_send(struct smbsrv_request *req)
        SSVAL(req->out.vwv, VWV(0), oi->ctemp.out.fnum);
 
        /* the returned filename is relative to the directory */
-       req_push_str(req, NULL, oi->ctemp.out.name, -1, STR_TERMINATE);
+       req_push_str(req, NULL, oi->ctemp.out.name, -1, STR_TERMINATE | STR_ASCII);
 
        req_send_reply(req);
 }
@@ -611,11 +625,12 @@ void reply_ctemp(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_ctemp_send;
-       req->async.private = oi;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_ctemp_send;
+       req->async_states->private_data = oi;
 
        /* call the backend */
-       req->async.status = req->tcon->ntvfs_ops->open(req, oi);
+       req->async_states->status = ntvfs_openfile(req, oi);
 
        REQ_ASYNC_TAIL;
 }
@@ -636,10 +651,11 @@ void reply_unlink(struct smbsrv_request *req)
 
        req_pull_ascii4(req, &unl->in.pattern, req->in.data, STR_TERMINATE);
        
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->unlink(req, unl);
+       req->async_states->status = ntvfs_unlink(req, unl);
 
        REQ_ASYNC_TAIL;
 }
@@ -659,20 +675,20 @@ void reply_readbraw(struct smbsrv_request *req)
        io.readbraw.level = RAW_READ_READBRAW;
 
        /* there are two variants, one with 10 and one with 8 command words */
-       if (req->in.wct != 10) {
-               REQ_CHECK_WCT(req, 8);
+       if (req->in.wct < 8) {
+               goto failed;
        }
 
        io.readbraw.in.fnum    = req_fnum(req, req->in.vwv, VWV(0));
        io.readbraw.in.offset  = IVAL(req->in.vwv, VWV(1));
-       io.readbraw.in.mincnt  = SVAL(req->in.vwv, VWV(3));
-       io.readbraw.in.maxcnt  = SVAL(req->in.vwv, VWV(4));
+       io.readbraw.in.maxcnt  = SVAL(req->in.vwv, VWV(3));
+       io.readbraw.in.mincnt  = SVAL(req->in.vwv, VWV(4));
        io.readbraw.in.timeout = IVAL(req->in.vwv, VWV(5));
 
        /* the 64 bit variant */
        if (req->in.wct == 10) {
                uint32_t offset_high = IVAL(req->in.vwv, VWV(8));
-               io.readbraw.in.offset |= (((SMB_OFF_T)offset_high) << 32);
+               io.readbraw.in.offset |= (((off_t)offset_high) << 32);
        }
 
        /* before calling the backend we setup the raw buffer. This
@@ -688,7 +704,7 @@ void reply_readbraw(struct smbsrv_request *req)
        io.readbraw.out.data = req->out.buffer + NBT_HDR_SIZE;
 
        /* call the backend */
-       status = req->tcon->ntvfs_ops->read(req, &io);
+       status = ntvfs_read(req, &io);
 
        if (!NT_STATUS_IS_OK(status)) {
                goto failed;
@@ -696,7 +712,7 @@ void reply_readbraw(struct smbsrv_request *req)
 
        req->out.size = io.readbraw.out.nread + NBT_HDR_SIZE;
 
-       req_send_reply(req);
+       req_send_reply_nosign(req);
        return;
 
 failed:
@@ -714,7 +730,7 @@ failed:
 ****************************************************************************/
 static void reply_lockread_send(struct smbsrv_request *req)
 {
-       union smb_read *io = req->async.private;
+       union smb_read *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -758,11 +774,12 @@ void reply_lockread(struct smbsrv_request *req)
        /* tell the backend where to put the data */
        io->lockread.out.data = req->out.data + 3;
 
-       req->async.send_fn = reply_lockread_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_lockread_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->read(req, io);
+       req->async_states->status = ntvfs_read(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -774,7 +791,7 @@ void reply_lockread(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_read_send(struct smbsrv_request *req)
 {
-       union smb_read *io = req->async.private;
+       union smb_read *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -816,11 +833,12 @@ void reply_read(struct smbsrv_request *req)
        /* tell the backend where to put the data */
        io->read.out.data = req->out.data + 3;
 
-       req->async.send_fn = reply_read_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_read_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->read(req, io);
+       req->async_states->status = ntvfs_read(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -832,13 +850,19 @@ void reply_read(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_read_and_X_send(struct smbsrv_request *req)
 {
-       union smb_read *io = req->async.private;
+       union smb_read *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
        /* readx reply packets can be over-sized */
        req->control_flags |= REQ_CONTROL_LARGE;
-       req_grow_data(req, 1 + io->readx.out.nread);
+       if (io->readx.in.maxcnt != 0xFFFF &&
+           io->readx.in.mincnt != 0xFFFF) {
+               req_grow_data(req, 1 + io->readx.out.nread);
+               SCVAL(req->out.data, 0, 0); /* padding */
+       } else {
+               req_grow_data(req, io->readx.out.nread);
+       }
 
        /* construct reply */
        SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE);
@@ -848,7 +872,6 @@ static void reply_read_and_X_send(struct smbsrv_request *req)
        REQ_VWV_RESERVED(4, 1);
        SSVAL(req->out.vwv, VWV(5), io->readx.out.nread);
        SSVAL(req->out.vwv, VWV(6), PTR_DIFF(io->readx.out.data, req->out.hdr));
-       SCVAL(req->out.data, 0, 0); /* padding */
        REQ_VWV_RESERVED(7, 5);
 
        chain_reply(req);
@@ -874,6 +897,13 @@ void reply_read_and_X(struct smbsrv_request *req)
        io->readx.in.maxcnt        = SVAL(req->in.vwv, VWV(5));
        io->readx.in.mincnt        = SVAL(req->in.vwv, VWV(6));
        io->readx.in.remaining     = SVAL(req->in.vwv, VWV(9));
+
+       if (req->smb_conn->negotiate.client_caps & CAP_LARGE_READX) {
+               uint32_t high_part = IVAL(req->in.vwv, VWV(7));
+               if (high_part == 1) {
+                       io->readx.in.maxcnt |= high_part << 16;
+               }
+       }
        
        /* the 64 bit variant */
        if (req->in.wct == 12) {
@@ -885,13 +915,19 @@ void reply_read_and_X(struct smbsrv_request *req)
        req_setup_reply(req, 12, 1 + io->readx.in.maxcnt);
 
        /* tell the backend where to put the data. Notice the pad byte. */
-       io->readx.out.data = req->out.data + 1;
+       if (io->readx.in.maxcnt != 0xFFFF &&
+           io->readx.in.mincnt != 0xFFFF) {
+               io->readx.out.data = req->out.data + 1;
+       } else {
+               io->readx.out.data = req->out.data;
+       }
 
-       req->async.send_fn = reply_read_and_X_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_read_and_X_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->read(req, io);
+       req->async_states->status = ntvfs_read(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -912,7 +948,7 @@ void reply_writebraw(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_writeunlock_send(struct smbsrv_request *req)
 {
-       union smb_write *io = req->async.private;
+       union smb_write *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -953,11 +989,12 @@ void reply_writeunlock(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_writeunlock_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_writeunlock_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->write(req, io);
+       req->async_states->status = ntvfs_write(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -969,7 +1006,7 @@ void reply_writeunlock(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_write_send(struct smbsrv_request *req)
 {
-       union smb_write *io = req->async.private;
+       union smb_write *io = req->async_states->private_data;
        
        CHECK_ASYNC_STATUS;
 
@@ -1010,11 +1047,12 @@ void reply_write(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_write_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_write_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->write(req, io);
+       req->async_states->status = ntvfs_write(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1025,7 +1063,7 @@ void reply_write(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_write_and_X_send(struct smbsrv_request *req)
 {
-       union smb_write *io = req->async.private;
+       union smb_write *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -1076,11 +1114,12 @@ void reply_write_and_X(struct smbsrv_request *req)
                return;
        } 
 
-       req->async.send_fn = reply_write_and_X_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_write_and_X_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->write(req, io);
+       req->async_states->status = ntvfs_write(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1091,7 +1130,7 @@ void reply_write_and_X(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_lseek_send(struct smbsrv_request *req)
 {
-       struct smb_seek *io = req->async.private;
+       struct smb_seek *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -1117,11 +1156,12 @@ void reply_lseek(struct smbsrv_request *req)
        io->in.mode   = SVAL(req->in.vwv,  VWV(1));
        io->in.offset = IVALS(req->in.vwv, VWV(2));
 
-       req->async.send_fn = reply_lseek_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_lseek_send;
+       req->async_states->private_data = io;
        
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->seek(req, io);
+       req->async_states->status = ntvfs_seek(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1139,10 +1179,11 @@ void reply_flush(struct smbsrv_request *req)
 
        io->in.fnum   = req_fnum(req, req->in.vwv,  VWV(0));
        
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->flush(req, io);
+       req->async_states->status = ntvfs_flush(req, io);
        
        REQ_ASYNC_TAIL;
 }
@@ -1159,7 +1200,7 @@ void reply_exit(struct smbsrv_request *req)
 
        for (tcon=req->smb_conn->tree.tcons;tcon;tcon=tcon->next) {
                req->tcon = tcon;
-               status = tcon->ntvfs_ops->exit(req);
+               status = ntvfs_exit(req);
                req->tcon = NULL;
                if (!NT_STATUS_IS_OK(status)) {
                        req_reply_error(req, status);
@@ -1189,10 +1230,11 @@ void reply_close(struct smbsrv_request *req)
        io->close.in.fnum  = req_fnum(req, req->in.vwv,  VWV(0));
        io->close.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1));
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->close(req, io);
+       req->async_states->status = ntvfs_close(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1204,7 +1246,7 @@ void reply_close(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_writeclose_send(struct smbsrv_request *req)
 {
-       union smb_write *io = req->async.private;
+       union smb_write *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -1243,11 +1285,12 @@ void reply_writeclose(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_writeclose_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_writeclose_send;
+       req->async_states->private_data = io;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->write(req, io);
+       req->async_states->status = ntvfs_write(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1268,10 +1311,11 @@ void reply_lock(struct smbsrv_request *req)
        lck->lock.in.count  = IVAL(req->in.vwv, VWV(1));
        lck->lock.in.offset = IVAL(req->in.vwv, VWV(3));
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->lock(req, lck);
+       req->async_states->status = ntvfs_lock(req, lck);
 
        REQ_ASYNC_TAIL;
 }
@@ -1293,10 +1337,11 @@ void reply_unlock(struct smbsrv_request *req)
        lck->unlock.in.count  = IVAL(req->in.vwv, VWV(1));
        lck->unlock.in.offset = IVAL(req->in.vwv, VWV(3));
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->lock(req, lck);
+       req->async_states->status = ntvfs_lock(req, lck);
 
        REQ_ASYNC_TAIL;
 }
@@ -1336,12 +1381,16 @@ void reply_echo(struct smbsrv_request *req)
        memcpy(req->out.data, req->in.data, req->in.data_size);
 
        for (i=1; i <= count;i++) {
+               struct smbsrv_request *this_req;
+               
                if (i != count) {
-                       talloc_increase_ref_count(req);
+                       this_req = req_setup_secondary(req);
+               } else {
+                       this_req = req;
                }
 
-               SSVAL(req->out.vwv, VWV(0), i);
-               req_send_reply(req);
+               SSVAL(this_req->out.vwv, VWV(0), i);
+               req_send_reply(this_req);
        }
 }
 
@@ -1352,14 +1401,14 @@ void reply_echo(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_printopen_send(struct smbsrv_request *req)
 {
-       union smb_open *oi = req->async.private;
+       union smb_open *oi = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
        /* construct reply */
        req_setup_reply(req, 1, 0);
 
-       SSVAL(req->out.vwv, VWV(0), oi->open.out.fnum);
+       SSVAL(req->out.vwv, VWV(0), oi->openold.out.fnum);
 
        req_send_reply(req);
 }
@@ -1381,11 +1430,12 @@ void reply_printopen(struct smbsrv_request *req)
 
        req_pull_ascii4(req, &oi->splopen.in.ident, req->in.data, STR_TERMINATE);
 
-       req->async.send_fn = reply_printopen_send;
-       req->async.private = oi;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_printopen_send;
+       req->async_states->private_data = oi;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->open(req, oi);
+       req->async_states->status = ntvfs_openfile(req, oi);
 
        REQ_ASYNC_TAIL;
 }
@@ -1404,10 +1454,11 @@ void reply_printclose(struct smbsrv_request *req)
        io->splclose.level = RAW_CLOSE_SPLCLOSE;
        io->splclose.in.fnum = req_fnum(req, req->in.vwv,  VWV(0));
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->close(req, io);
+       req->async_states->status = ntvfs_close(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1417,7 +1468,7 @@ void reply_printclose(struct smbsrv_request *req)
 ****************************************************************************/
 void reply_printqueue_send(struct smbsrv_request *req)
 {
-       union smb_lpq *lpq = req->async.private;
+       union smb_lpq *lpq = req->async_states->private_data;
        int i, maxcount;
        const uint_t el_size = 28;      
 
@@ -1472,11 +1523,12 @@ void reply_printqueue(struct smbsrv_request *req)
        lpq->retq.in.maxcount = SVAL(req->in.vwv,  VWV(0));
        lpq->retq.in.startidx = SVAL(req->in.vwv,  VWV(1));
 
-       req->async.send_fn = reply_printqueue_send;
-       req->async.private = lpq;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_printqueue_send;
+       req->async_states->private_data = lpq;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->lpq(req, lpq);
+       req->async_states->status = ntvfs_lpq(req, lpq);
 
        REQ_ASYNC_TAIL;
 }
@@ -1510,10 +1562,11 @@ void reply_printwrite(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->write(req, io);
+       req->async_states->status = ntvfs_write(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1533,10 +1586,11 @@ void reply_mkdir(struct smbsrv_request *req)
        io->generic.level = RAW_MKDIR_MKDIR;
        req_pull_ascii4(req, &io->mkdir.in.path, req->in.data, STR_TERMINATE);
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->mkdir(req, io);
+       req->async_states->status = ntvfs_mkdir(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1555,10 +1609,11 @@ void reply_rmdir(struct smbsrv_request *req)
 
        req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE);
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->rmdir(req, io);
+       req->async_states->status = ntvfs_rmdir(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1570,7 +1625,7 @@ void reply_rmdir(struct smbsrv_request *req)
 void reply_mv(struct smbsrv_request *req)
 {
        union smb_rename *io;
-       char *p;
+       uint8_t *p;
  
        /* parse the request */
        REQ_CHECK_WCT(req, 1);
@@ -1588,10 +1643,11 @@ void reply_mv(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->rename(req, io);
+       req->async_states->status = ntvfs_rename(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1603,7 +1659,7 @@ void reply_mv(struct smbsrv_request *req)
 void reply_ntrename(struct smbsrv_request *req)
 {
        union smb_rename *io;
-       char *p;
+       uint8_t *p;
  
        /* parse the request */
        REQ_CHECK_WCT(req, 4);
@@ -1623,10 +1679,11 @@ void reply_ntrename(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->rename(req, io);
+       req->async_states->status = ntvfs_rename(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -1636,7 +1693,7 @@ void reply_ntrename(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_copy_send(struct smbsrv_request *req)
 {
-       struct smb_copy *cp = req->async.private;
+       struct smb_copy *cp = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -1654,7 +1711,7 @@ static void reply_copy_send(struct smbsrv_request *req)
 void reply_copy(struct smbsrv_request *req)
 {
        struct smb_copy *cp;
-       char *p;
+       uint8_t *p;
 
        /* parse request */
        REQ_CHECK_WCT(req, 3);
@@ -1673,11 +1730,12 @@ void reply_copy(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_copy_send;
-       req->async.private = cp;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_copy_send;
+       req->async_states->private_data = cp;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->copy(req, cp);
+       req->async_states->status = ntvfs_copy(req, cp);
 
        REQ_ASYNC_TAIL;
 }
@@ -1687,7 +1745,7 @@ void reply_copy(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_lockingX_send(struct smbsrv_request *req)
 {
-       union smb_lock *lck = req->async.private;
+       union smb_lock *lck = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -1716,7 +1774,7 @@ void reply_lockingX(struct smbsrv_request *req)
        union smb_lock *lck;
        uint_t total_locks, i;
        uint_t lck_size;
-       char *p;
+       uint8_t *p;
 
        /* parse request */
        REQ_CHECK_WCT(req, 8);
@@ -1773,11 +1831,12 @@ void reply_lockingX(struct smbsrv_request *req)
                p += lck_size;
        }
 
-       req->async.send_fn = reply_lockingX_send;
-       req->async.private = lck;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_lockingX_send;
+       req->async_states->private_data = lck;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->lock(req, lck);
+       req->async_states->status = ntvfs_lock(req, lck);
 
        REQ_ASYNC_TAIL;
 }
@@ -1809,10 +1868,11 @@ void reply_setattrE(struct smbsrv_request *req)
        info->setattre.in.access_time = srv_pull_dos_date2(req->smb_conn, req->in.vwv + VWV(3));
        info->setattre.in.write_time  = srv_pull_dos_date2(req->smb_conn, req->in.vwv + VWV(5));
 
-       req->async.send_fn = reply_simple_send;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_simple_send;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->setfileinfo(req, info);
+       req->async_states->status = ntvfs_setfileinfo(req, info);
 
        REQ_ASYNC_TAIL;
 }
@@ -1823,8 +1883,7 @@ void reply_setattrE(struct smbsrv_request *req)
 ****************************************************************************/
 void reply_writebmpx(struct smbsrv_request *req)
 {
-       /* we will need to implement this one for OS/2, but right now I can't be bothered */
-       req_reply_error(req, NT_STATUS_FOOBAR);
+       req_reply_dos_error(req, ERRSRV, ERRuseSTD);
 }
 
 
@@ -1833,8 +1892,7 @@ void reply_writebmpx(struct smbsrv_request *req)
 ****************************************************************************/
 void reply_writebs(struct smbsrv_request *req)
 {
-       /* see reply_writebmpx */
-       req_reply_error(req, NT_STATUS_FOOBAR);
+       req_reply_dos_error(req, ERRSRV, ERRuseSTD);
 }
 
 
@@ -1844,7 +1902,7 @@ void reply_writebs(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_getattrE_send(struct smbsrv_request *req)
 {
-       union smb_fileinfo *info = req->async.private;
+       union smb_fileinfo *info = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -1875,11 +1933,12 @@ void reply_getattrE(struct smbsrv_request *req)
        info->getattr.level = RAW_FILEINFO_GETATTRE;
        info->getattr.in.fnum = req_fnum(req, req->in.vwv, VWV(0));
 
-       req->async.send_fn = reply_getattrE_send;
-       req->async.private = info;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_getattrE_send;
+       req->async_states->private_data = info;
 
        /* call backend */
-       req->async.status = req->tcon->ntvfs_ops->qfileinfo(req, info);
+       req->async_states->status = ntvfs_qfileinfo(req, info);
 
        REQ_ASYNC_TAIL;
 }
@@ -1892,7 +1951,7 @@ static void reply_sesssetup_old(struct smbsrv_request *req)
 {
        NTSTATUS status;
        union smb_sesssetup sess;
-       char *p;
+       uint8_t *p;
        uint16_t passlen;
 
        sess.old.level = RAW_SESSSETUP_OLD;
@@ -1950,7 +2009,7 @@ static void reply_sesssetup_nt1(struct smbsrv_request *req)
 {
        NTSTATUS status;
        union smb_sesssetup sess;
-       char *p;
+       uint8_t *p;
        uint16_t passlen1, passlen2;
 
        sess.nt1.level = RAW_SESSSETUP_NT1;
@@ -2020,7 +2079,7 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req)
 {
        NTSTATUS status;
        union smb_sesssetup sess;
-       char *p;
+       uint8_t *p;
        uint16_t blob_len;
 
        sess.spnego.level = RAW_SESSSETUP_SPNEGO;
@@ -2116,7 +2175,7 @@ void reply_ulogoffX(struct smbsrv_request *req)
        if ((vuid != 0) && (lp_security() != SEC_SHARE)) {
                for (tcon=req->smb_conn->tree.tcons;tcon;tcon=tcon->next) {
                        req->tcon = tcon;
-                       status = tcon->ntvfs_ops->logoff(req);
+                       status = ntvfs_logoff(req);
                        req->tcon = NULL;
                        if (!NT_STATUS_IS_OK(status)) {
                                req_reply_error(req, status);
@@ -2152,7 +2211,7 @@ void reply_findclose(struct smbsrv_request *req)
        io.findclose.in.handle  = SVAL(req->in.vwv, VWV(0));
        
        /* call backend */
-       status = req->tcon->ntvfs_ops->search_close(req, &io);
+       status = ntvfs_search_close(req, &io);
 
        if (!NT_STATUS_IS_OK(status)) {
                req_reply_error(req, status);
@@ -2179,7 +2238,7 @@ void reply_findnclose(struct smbsrv_request *req)
 ****************************************************************************/
 static void reply_ntcreate_and_X_send(struct smbsrv_request *req)
 {
-       union smb_open *io = req->async.private;
+       union smb_open *io = req->async_states->private_data;
 
        CHECK_ASYNC_STATUS;
 
@@ -2233,6 +2292,8 @@ void reply_ntcreate_and_X(struct smbsrv_request *req)
        io->ntcreatex.in.create_options =   IVAL(req->in.vwv, 39);
        io->ntcreatex.in.impersonation =    IVAL(req->in.vwv, 43);
        io->ntcreatex.in.security_flags =   CVAL(req->in.vwv, 47);
+       io->ntcreatex.in.ea_list          = NULL;
+       io->ntcreatex.in.sec_desc         = NULL;
 
        /* we need a neater way to handle this alignment */
        if ((req->flags2 & FLAGS2_UNICODE_STRINGS) && 
@@ -2246,11 +2307,12 @@ void reply_ntcreate_and_X(struct smbsrv_request *req)
                return;
        }
 
-       req->async.send_fn = reply_ntcreate_and_X_send;
-       req->async.private = io;
+       req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+       req->async_states->send_fn = reply_ntcreate_and_X_send;
+       req->async_states->private_data = io;
 
        /* call the backend */
-       req->async.status = req->tcon->ntvfs_ops->open(req, io);
+       req->async_states->status = ntvfs_openfile(req, io);
 
        REQ_ASYNC_TAIL;
 }
@@ -2261,7 +2323,10 @@ void reply_ntcreate_and_X(struct smbsrv_request *req)
 ****************************************************************************/
 void reply_ntcancel(struct smbsrv_request *req)
 {
-       req_reply_error(req, NT_STATUS_FOOBAR);
+       /* NOTE: this request does not generate a reply */
+       req_signing_no_reply(req);
+       ntvfs_cancel(req);
+       req_destroy(req);
 }
 
 /****************************************************************************
@@ -2304,7 +2369,7 @@ void reply_sendtxt(struct smbsrv_request *req)
 void reply_special(struct smbsrv_request *req)
 {
        uint8_t msg_type;
-       char buf[4];
+       uint8_t *buf = talloc_zero_array_p(req, uint8_t, 4);
        
        msg_type = CVAL(req->in.buffer,0);
 
Samba Shared Repository