From 6d34ab056f70d85c3207696fac4fbb9e7f437b14 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 18 Nov 2005 13:30:18 +0000 Subject: r11786: move all SMB protocol specific stuff to smb_server/smb/ metze (This used to be commit 5fea278cb65076cea71bb6c921e51c4feffc37d7) --- source4/smb_server/smb/reply.c | 2461 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2461 insertions(+) create mode 100644 source4/smb_server/smb/reply.c (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c new file mode 100644 index 0000000000..eb7b5a1082 --- /dev/null +++ b/source4/smb_server/smb/reply.c @@ -0,0 +1,2461 @@ +/* + Unix SMB/CIFS implementation. + Main SMB reply routines + Copyright (C) Andrew Tridgell 1992-2003 + Copyright (C) James J Myers 2003 + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. +*/ +/* + This file handles most of the reply_ calls that the server + makes to handle specific protocols +*/ + +#include "includes.h" +#include "smb_server/smb_server.h" +#include "libcli/nbt/libnbt.h" + + +/* useful way of catching wct errors with file and line number */ +#define REQ_CHECK_WCT(req, wcount) do { \ + if ((req)->in.wct != (wcount)) { \ + DEBUG(1,("Unexpected WCT %d at %s(%d) - expected %d\n", \ + (req)->in.wct, __FILE__, __LINE__, wcount)); \ + req_reply_dos_error(req, ERRSRV, ERRerror); \ + return; \ + }} while (0) + +/* 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_states->status)) { \ + req_reply_error(req, req->async_states->status); \ + return; \ + }} while (0) + +/* useful wrapper for talloc with NO_MEMORY reply */ +#define REQ_TALLOC(ptr, size) do { \ + ptr = talloc_size(req, size); \ + if (!ptr) { \ + req_reply_error(req, NT_STATUS_NO_MEMORY); \ + return; \ + }} while (0) + +/* + check if the backend wants to handle the request asynchronously. + if it wants it handled synchronously then call the send function + immediately +*/ +#define REQ_ASYNC_TAIL do { \ + 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 */ +#define REQ_VWV_RESERVED(start, count) memset(req->out.vwv + VWV(start), 0, (count)*2) + +/**************************************************************************** + Reply to a simple request (async send) +****************************************************************************/ +static void reply_simple_send(struct smbsrv_request *req) +{ + CHECK_ASYNC_STATUS; + + req_setup_reply(req, 0, 0); + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a tcon. +****************************************************************************/ +void reply_tcon(struct smbsrv_request *req) +{ + union smb_tcon con; + NTSTATUS status; + uint8_t *p; + + /* parse request */ + REQ_CHECK_WCT(req, 0); + + con.tcon.level = RAW_TCON_TCON; + + p = req->in.data; + p += req_pull_ascii4(req, &con.tcon.in.service, p, STR_TERMINATE); + p += req_pull_ascii4(req, &con.tcon.in.password, p, STR_TERMINATE); + p += req_pull_ascii4(req, &con.tcon.in.dev, p, STR_TERMINATE); + + if (!con.tcon.in.service || !con.tcon.in.password || !con.tcon.in.dev) { + req_reply_error(req, NT_STATUS_INVALID_PARAMETER); + return; + } + + /* call backend */ + status = tcon_backend(req, &con); + + if (!NT_STATUS_IS_OK(status)) { + req_reply_error(req, status); + return; + } + + /* construct reply */ + req_setup_reply(req, 2, 0); + + SSVAL(req->out.vwv, VWV(0), con.tcon.out.max_xmit); + SSVAL(req->out.vwv, VWV(1), con.tcon.out.tid); + SSVAL(req->out.hdr, HDR_TID, req->tcon->tid); + + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a tcon and X. +****************************************************************************/ +void reply_tcon_and_X(struct smbsrv_request *req) +{ + NTSTATUS status; + union smb_tcon con; + uint8_t *p; + uint16_t passlen; + + con.tconx.level = RAW_TCON_TCONX; + + /* parse request */ + REQ_CHECK_WCT(req, 4); + + con.tconx.in.flags = SVAL(req->in.vwv, VWV(2)); + passlen = SVAL(req->in.vwv, VWV(3)); + + p = req->in.data; + + if (!req_pull_blob(req, p, passlen, &con.tconx.in.password)) { + req_reply_error(req, NT_STATUS_ILL_FORMED_PASSWORD); + return; + } + p += passlen; + + p += req_pull_string(req, &con.tconx.in.path, p, -1, STR_TERMINATE); + p += req_pull_string(req, &con.tconx.in.device, p, -1, STR_ASCII); + + if (!con.tconx.in.path || !con.tconx.in.device) { + req_reply_error(req, NT_STATUS_BAD_DEVICE_TYPE); + return; + } + + /* call backend */ + status = tcon_backend(req, &con); + + if (!NT_STATUS_IS_OK(status)) { + req_reply_error(req, status); + return; + } + + /* construct reply - two variants */ + if (req->smb_conn->negotiate.protocol < PROTOCOL_NT1) { + req_setup_reply(req, 2, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + + req_push_str(req, NULL, con.tconx.out.dev_type, -1, STR_TERMINATE|STR_ASCII); + } else { + req_setup_reply(req, 3, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), con.tconx.out.options); + + req_push_str(req, NULL, con.tconx.out.dev_type, -1, STR_TERMINATE|STR_ASCII); + req_push_str(req, NULL, con.tconx.out.fs_type, -1, STR_TERMINATE); + } + + /* set the incoming and outgoing tid to the just created one */ + SSVAL(req->in.hdr, HDR_TID, con.tconx.out.tid); + SSVAL(req->out.hdr,HDR_TID, con.tconx.out.tid); + + chain_reply(req); +} + + +/**************************************************************************** + Reply to an unknown request +****************************************************************************/ +void reply_unknown(struct smbsrv_request *req) +{ + int type; + + type = CVAL(req->in.hdr, HDR_COM); + + DEBUG(0,("unknown command type %d (0x%X)\n", type, type)); + + req_reply_dos_error(req, ERRSRV, ERRunknownsmb); +} + + +/**************************************************************************** + Reply to an ioctl (async reply) +****************************************************************************/ +static void reply_ioctl_send(struct smbsrv_request *req) +{ + union smb_ioctl *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* the +1 is for nicer alignment */ + req_setup_reply(req, 8, io->ioctl.out.blob.length+1); + SSVAL(req->out.vwv, VWV(1), io->ioctl.out.blob.length); + SSVAL(req->out.vwv, VWV(5), io->ioctl.out.blob.length); + SSVAL(req->out.vwv, VWV(6), PTR_DIFF(req->out.data, req->out.hdr) + 1); + + memcpy(req->out.data+1, io->ioctl.out.blob.data, io->ioctl.out.blob.length); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to an ioctl. +****************************************************************************/ +void reply_ioctl(struct smbsrv_request *req) +{ + union smb_ioctl *io; + + /* parse request */ + REQ_CHECK_WCT(req, 3); + REQ_TALLOC(io, sizeof(*io)); + + io->ioctl.level = RAW_IOCTL_IOCTL; + io->ioctl.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->ioctl.in.request = IVAL(req->in.vwv, VWV(1)); + + 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_states->status = ntvfs_ioctl(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a chkpth. +****************************************************************************/ +void reply_chkpth(struct smbsrv_request *req) +{ + struct smb_chkpath *io; + + REQ_TALLOC(io, sizeof(*io)); + + req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + req->async_states->status = ntvfs_chkpath(req, io); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a getatr (async reply) +****************************************************************************/ +static void reply_getatr_send(struct smbsrv_request *req) +{ + union smb_fileinfo *st = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 10, 0); + + SSVAL(req->out.vwv, VWV(0), st->getattr.out.attrib); + srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(1), st->getattr.out.write_time); + SIVAL(req->out.vwv, VWV(3), st->getattr.out.size); + + REQ_VWV_RESERVED(5, 5); + + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a getatr. +****************************************************************************/ +void reply_getatr(struct smbsrv_request *req) +{ + union smb_fileinfo *st; + + REQ_TALLOC(st, sizeof(*st)); + + st->getattr.level = RAW_FILEINFO_GETATTR; + + /* parse request */ + req_pull_ascii4(req, &st->getattr.in.fname, req->in.data, STR_TERMINATE); + if (!st->getattr.in.fname) { + req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + return; + } + + 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_states->status = ntvfs_qpathinfo(req, st); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a setatr. +****************************************************************************/ +void reply_setatr(struct smbsrv_request *req) +{ + union smb_setfileinfo *st; + + /* parse request */ + REQ_CHECK_WCT(req, 8); + REQ_TALLOC(st, sizeof(*st)); + + st->setattr.level = RAW_SFILEINFO_SETATTR; + st->setattr.in.attrib = SVAL(req->in.vwv, VWV(0)); + st->setattr.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1)); + + req_pull_ascii4(req, &st->setattr.file.fname, req->in.data, STR_TERMINATE); + + if (!st->setattr.file.fname) { + req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + return; + } + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_setpathinfo(req, st); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a dskattr (async reply) +****************************************************************************/ +static void reply_dskattr_send(struct smbsrv_request *req) +{ + union smb_fsinfo *fs = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 5, 0); + + SSVAL(req->out.vwv, VWV(0), fs->dskattr.out.units_total); + SSVAL(req->out.vwv, VWV(1), fs->dskattr.out.blocks_per_unit); + SSVAL(req->out.vwv, VWV(2), fs->dskattr.out.block_size); + SSVAL(req->out.vwv, VWV(3), fs->dskattr.out.units_free); + + REQ_VWV_RESERVED(4, 1); + + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a dskattr. +****************************************************************************/ +void reply_dskattr(struct smbsrv_request *req) +{ + union smb_fsinfo *fs; + + REQ_TALLOC(fs, sizeof(*fs)); + + fs->dskattr.level = RAW_QFS_DSKATTR; + + 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_states->status = ntvfs_fsinfo(req, fs); + + REQ_ASYNC_TAIL; +} + + + +/**************************************************************************** + Reply to an open (async reply) +****************************************************************************/ +static void reply_open_send(struct smbsrv_request *req) +{ + 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->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); +} + +/**************************************************************************** + Reply to an open. +****************************************************************************/ +void reply_open(struct smbsrv_request *req) +{ + union smb_open *oi; + + /* parse request */ + REQ_CHECK_WCT(req, 2); + REQ_TALLOC(oi, sizeof(*oi)); + + oi->openold.level = RAW_OPEN_OPEN; + oi->openold.in.open_mode = SVAL(req->in.vwv, VWV(0)); + oi->openold.in.search_attrs = SVAL(req->in.vwv, VWV(1)); + + req_pull_ascii4(req, &oi->openold.in.fname, req->in.data, STR_TERMINATE); + + if (!oi->openold.in.fname) { + req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + return; + } + + 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_states->status = ntvfs_openfile(req, oi); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to an open and X (async reply) +****************************************************************************/ +static void reply_open_and_X_send(struct smbsrv_request *req) +{ + union smb_open *oi = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* build the reply */ + if (oi->openx.in.flags & OPENX_FLAGS_EXTENDED_RETURN) { + req_setup_reply(req, 19, 0); + } else { + req_setup_reply(req, 15, 0); + } + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), oi->openx.out.fnum); + SSVAL(req->out.vwv, VWV(3), oi->openx.out.attrib); + srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(4), oi->openx.out.write_time); + SIVAL(req->out.vwv, VWV(6), oi->openx.out.size); + SSVAL(req->out.vwv, VWV(8), oi->openx.out.access); + SSVAL(req->out.vwv, VWV(9), oi->openx.out.ftype); + SSVAL(req->out.vwv, VWV(10),oi->openx.out.devstate); + SSVAL(req->out.vwv, VWV(11),oi->openx.out.action); + SIVAL(req->out.vwv, VWV(12),oi->openx.out.unique_fid); + SSVAL(req->out.vwv, VWV(14),0); /* reserved */ + if (oi->openx.in.flags & OPENX_FLAGS_EXTENDED_RETURN) { + SIVAL(req->out.vwv, VWV(15),oi->openx.out.access_mask); + REQ_VWV_RESERVED(17, 2); + } + + req->chained_fnum = oi->openx.out.fnum; + + chain_reply(req); +} + + +/**************************************************************************** + Reply to an open and X. +****************************************************************************/ +void reply_open_and_X(struct smbsrv_request *req) +{ + union smb_open *oi; + + /* parse the request */ + REQ_CHECK_WCT(req, 15); + REQ_TALLOC(oi, sizeof(*oi)); + + oi->openx.level = RAW_OPEN_OPENX; + oi->openx.in.flags = SVAL(req->in.vwv, VWV(2)); + oi->openx.in.open_mode = SVAL(req->in.vwv, VWV(3)); + oi->openx.in.search_attrs = SVAL(req->in.vwv, VWV(4)); + oi->openx.in.file_attrs = SVAL(req->in.vwv, VWV(5)); + oi->openx.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(6)); + oi->openx.in.open_func = SVAL(req->in.vwv, VWV(8)); + oi->openx.in.size = IVAL(req->in.vwv, VWV(9)); + oi->openx.in.timeout = IVAL(req->in.vwv, VWV(11)); + + req_pull_ascii4(req, &oi->openx.in.fname, req->in.data, STR_TERMINATE); + + if (!oi->openx.in.fname) { + req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + return; + } + + 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_states->status = ntvfs_openfile(req, oi); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a mknew or a create. +****************************************************************************/ +static void reply_mknew_send(struct smbsrv_request *req) +{ + union smb_open *oi = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* build the reply */ + req_setup_reply(req, 1, 0); + + SSVAL(req->out.vwv, VWV(0), oi->mknew.out.fnum); + + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a mknew or a create. +****************************************************************************/ +void reply_mknew(struct smbsrv_request *req) +{ + union smb_open *oi; + + /* parse the request */ + REQ_CHECK_WCT(req, 3); + REQ_TALLOC(oi, sizeof(*oi)); + + 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)); + + req_pull_ascii4(req, &oi->mknew.in.fname, req->in.data, STR_TERMINATE); + + if (!oi->mknew.in.fname) { + req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + return; + } + + 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_states->status = ntvfs_openfile(req, oi); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a create temporary file (async reply) +****************************************************************************/ +static void reply_ctemp_send(struct smbsrv_request *req) +{ + union smb_open *oi = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* build the reply */ + req_setup_reply(req, 1, 0); + + 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 | STR_ASCII); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a create temporary file. +****************************************************************************/ +void reply_ctemp(struct smbsrv_request *req) +{ + union smb_open *oi; + + /* parse the request */ + REQ_CHECK_WCT(req, 3); + REQ_TALLOC(oi, sizeof(*oi)); + + oi->ctemp.level = RAW_OPEN_CTEMP; + oi->ctemp.in.attrib = SVAL(req->in.vwv, VWV(0)); + oi->ctemp.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1)); + + /* the filename is actually a directory name, the server provides a filename + in that directory */ + req_pull_ascii4(req, &oi->ctemp.in.directory, req->in.data, STR_TERMINATE); + + if (!oi->ctemp.in.directory) { + req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + return; + } + + 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_states->status = ntvfs_openfile(req, oi); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a unlink +****************************************************************************/ +void reply_unlink(struct smbsrv_request *req) +{ + struct smb_unlink *unl; + + /* parse the request */ + REQ_CHECK_WCT(req, 1); + REQ_TALLOC(unl, sizeof(*unl)); + + unl->in.attrib = SVAL(req->in.vwv, VWV(0)); + + req_pull_ascii4(req, &unl->in.pattern, req->in.data, STR_TERMINATE); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_unlink(req, unl); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a readbraw (core+ protocol). + this is a strange packet because it doesn't use a standard SMB header in the reply, + only the 4 byte NBT header + This command must be replied to synchronously +****************************************************************************/ +void reply_readbraw(struct smbsrv_request *req) +{ + NTSTATUS status; + union smb_read io; + + io.readbraw.level = RAW_READ_READBRAW; + + /* there are two variants, one with 10 and one with 8 command words */ + 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.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 |= (((off_t)offset_high) << 32); + } + + /* before calling the backend we setup the raw buffer. This + * saves a copy later */ + req->out.size = io.readbraw.in.maxcnt + NBT_HDR_SIZE; + req->out.buffer = talloc_size(req, req->out.size); + if (req->out.buffer == NULL) { + goto failed; + } + SIVAL(req->out.buffer, 0, 0); /* init NBT header */ + + /* tell the backend where to put the data */ + io.readbraw.out.data = req->out.buffer + NBT_HDR_SIZE; + + /* call the backend */ + status = ntvfs_read(req, &io); + + if (!NT_STATUS_IS_OK(status)) { + goto failed; + } + + req->out.size = io.readbraw.out.nread + NBT_HDR_SIZE; + + req_send_reply_nosign(req); + return; + +failed: + /* any failure in readbraw is equivalent to reading zero bytes */ + req->out.size = 4; + req->out.buffer = talloc_size(req, req->out.size); + SIVAL(req->out.buffer, 0, 0); /* init NBT header */ + + req_send_reply_nosign(req); +} + + +/**************************************************************************** + Reply to a lockread (async reply) +****************************************************************************/ +static void reply_lockread_send(struct smbsrv_request *req) +{ + union smb_read *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* trim packet */ + io->lockread.out.nread = MIN(io->lockread.out.nread, + req_max_data(req) - 3); + req_grow_data(req, 3 + io->lockread.out.nread); + + /* construct reply */ + SSVAL(req->out.vwv, VWV(0), io->lockread.out.nread); + REQ_VWV_RESERVED(1, 4); + + SCVAL(req->out.data, 0, SMB_DATA_BLOCK); + SSVAL(req->out.data, 1, io->lockread.out.nread); + + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a lockread (core+ protocol). + note that the lock is a write lock, not a read lock! +****************************************************************************/ +void reply_lockread(struct smbsrv_request *req) +{ + union smb_read *io; + + /* parse request */ + REQ_CHECK_WCT(req, 5); + REQ_TALLOC(io, sizeof(*io)); + + io->lockread.level = RAW_READ_LOCKREAD; + io->lockread.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->lockread.in.count = SVAL(req->in.vwv, VWV(1)); + io->lockread.in.offset = IVAL(req->in.vwv, VWV(2)); + io->lockread.in.remaining = SVAL(req->in.vwv, VWV(4)); + + /* setup the reply packet assuming the maximum possible read */ + req_setup_reply(req, 5, 3 + io->lockread.in.count); + + /* tell the backend where to put the data */ + io->lockread.out.data = req->out.data + 3; + + 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_states->status = ntvfs_read(req, io); + + REQ_ASYNC_TAIL; +} + + + +/**************************************************************************** + Reply to a read (async reply) +****************************************************************************/ +static void reply_read_send(struct smbsrv_request *req) +{ + union smb_read *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* trim packet */ + io->read.out.nread = MIN(io->read.out.nread, + req_max_data(req) - 3); + req_grow_data(req, 3 + io->read.out.nread); + + /* construct reply */ + SSVAL(req->out.vwv, VWV(0), io->read.out.nread); + REQ_VWV_RESERVED(1, 4); + + SCVAL(req->out.data, 0, SMB_DATA_BLOCK); + SSVAL(req->out.data, 1, io->read.out.nread); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a read. +****************************************************************************/ +void reply_read(struct smbsrv_request *req) +{ + union smb_read *io; + + /* parse request */ + REQ_CHECK_WCT(req, 5); + REQ_TALLOC(io, sizeof(*io)); + + io->read.level = RAW_READ_READ; + io->read.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->read.in.count = SVAL(req->in.vwv, VWV(1)); + io->read.in.offset = IVAL(req->in.vwv, VWV(2)); + io->read.in.remaining = SVAL(req->in.vwv, VWV(4)); + + /* setup the reply packet assuming the maximum possible read */ + req_setup_reply(req, 5, 3 + io->read.in.count); + + /* tell the backend where to put the data */ + io->read.out.data = req->out.data + 3; + + 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_states->status = ntvfs_read(req, io); + + REQ_ASYNC_TAIL; +} + + + +/**************************************************************************** + Reply to a read and X (async reply) +****************************************************************************/ +static void reply_read_and_X_send(struct smbsrv_request *req) +{ + 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; + 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); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), io->readx.out.remaining); + SSVAL(req->out.vwv, VWV(3), io->readx.out.compaction_mode); + 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)); + REQ_VWV_RESERVED(7, 5); + + chain_reply(req); +} + +/**************************************************************************** + Reply to a read and X. +****************************************************************************/ +void reply_read_and_X(struct smbsrv_request *req) +{ + union smb_read *io; + + /* parse request */ + if (req->in.wct != 12) { + REQ_CHECK_WCT(req, 10); + } + + REQ_TALLOC(io, sizeof(*io)); + + io->readx.level = RAW_READ_READX; + io->readx.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->readx.in.offset = IVAL(req->in.vwv, VWV(3)); + 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) { + uint32_t offset_high = IVAL(req->in.vwv, VWV(10)); + io->readx.in.offset |= (((uint64_t)offset_high) << 32); + } + + /* setup the reply packet assuming the maximum possible read */ + req_setup_reply(req, 12, 1 + io->readx.in.maxcnt); + + /* tell the backend where to put the data. Notice the pad byte. */ + 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_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_states->status = ntvfs_read(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a writebraw (core+ or LANMAN1.0 protocol). +****************************************************************************/ +void reply_writebraw(struct smbsrv_request *req) +{ + req_reply_dos_error(req, ERRSRV, ERRuseSTD); +} + + +/**************************************************************************** + Reply to a writeunlock (async reply) +****************************************************************************/ +static void reply_writeunlock_send(struct smbsrv_request *req) +{ + union smb_write *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 1, 0); + + SSVAL(req->out.vwv, VWV(0), io->writeunlock.out.nwritten); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a writeunlock (core+). +****************************************************************************/ +void reply_writeunlock(struct smbsrv_request *req) +{ + union smb_write *io; + + REQ_CHECK_WCT(req, 5); + REQ_TALLOC(io, sizeof(*io)); + + io->writeunlock.level = RAW_WRITE_WRITEUNLOCK; + io->writeunlock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->writeunlock.in.count = SVAL(req->in.vwv, VWV(1)); + io->writeunlock.in.offset = IVAL(req->in.vwv, VWV(2)); + io->writeunlock.in.remaining = SVAL(req->in.vwv, VWV(4)); + io->writeunlock.in.data = req->in.data + 3; + + /* make sure they gave us the data they promised */ + if (io->writeunlock.in.count+3 > req->in.data_size) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + /* make sure the data block is big enough */ + if (SVAL(req->in.data, 1) < io->writeunlock.in.count) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + 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_states->status = ntvfs_write(req, io); + + REQ_ASYNC_TAIL; +} + + + +/**************************************************************************** + Reply to a write (async reply) +****************************************************************************/ +static void reply_write_send(struct smbsrv_request *req) +{ + union smb_write *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 1, 0); + + SSVAL(req->out.vwv, VWV(0), io->write.out.nwritten); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a write +****************************************************************************/ +void reply_write(struct smbsrv_request *req) +{ + union smb_write *io; + + REQ_CHECK_WCT(req, 5); + REQ_TALLOC(io, sizeof(*io)); + + io->write.level = RAW_WRITE_WRITE; + io->write.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->write.in.count = SVAL(req->in.vwv, VWV(1)); + io->write.in.offset = IVAL(req->in.vwv, VWV(2)); + io->write.in.remaining = SVAL(req->in.vwv, VWV(4)); + io->write.in.data = req->in.data + 3; + + /* make sure they gave us the data they promised */ + if (req_data_oob(req, io->write.in.data, io->write.in.count)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + /* make sure the data block is big enough */ + if (SVAL(req->in.data, 1) < io->write.in.count) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + 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_states->status = ntvfs_write(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a write and X (async reply) +****************************************************************************/ +static void reply_write_and_X_send(struct smbsrv_request *req) +{ + union smb_write *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 6, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), io->writex.out.nwritten & 0xFFFF); + SSVAL(req->out.vwv, VWV(3), io->writex.out.remaining); + SSVAL(req->out.vwv, VWV(4), io->writex.out.nwritten >> 16); + REQ_VWV_RESERVED(5, 1); + + chain_reply(req); +} + +/**************************************************************************** + Reply to a write and X. +****************************************************************************/ +void reply_write_and_X(struct smbsrv_request *req) +{ + union smb_write *io; + + if (req->in.wct != 14) { + REQ_CHECK_WCT(req, 12); + } + + REQ_TALLOC(io, sizeof(*io)); + + io->writex.level = RAW_WRITE_WRITEX; + io->writex.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->writex.in.offset = IVAL(req->in.vwv, VWV(3)); + io->writex.in.wmode = SVAL(req->in.vwv, VWV(7)); + io->writex.in.remaining = SVAL(req->in.vwv, VWV(8)); + io->writex.in.count = SVAL(req->in.vwv, VWV(10)); + io->writex.in.data = req->in.hdr + SVAL(req->in.vwv, VWV(11)); + + if (req->in.wct == 14) { + uint32_t offset_high = IVAL(req->in.vwv, VWV(12)); + uint16_t count_high = SVAL(req->in.vwv, VWV(9)); + io->writex.in.offset |= (((uint64_t)offset_high) << 32); + io->writex.in.count |= ((uint32_t)count_high) << 16; + } + + /* make sure the data is in bounds */ + if (req_data_oob(req, io->writex.in.data, io->writex.in.count)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + 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_states->status = ntvfs_write(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a lseek (async reply) +****************************************************************************/ +static void reply_lseek_send(struct smbsrv_request *req) +{ + struct smb_seek *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 2, 0); + + SIVALS(req->out.vwv, VWV(0), io->out.offset); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a lseek. +****************************************************************************/ +void reply_lseek(struct smbsrv_request *req) +{ + struct smb_seek *io; + + REQ_CHECK_WCT(req, 4); + REQ_TALLOC(io, sizeof(*io)); + + io->in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->in.mode = SVAL(req->in.vwv, VWV(1)); + io->in.offset = IVALS(req->in.vwv, VWV(2)); + + 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_states->status = ntvfs_seek(req, io); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a flush. +****************************************************************************/ +void reply_flush(struct smbsrv_request *req) +{ + struct smb_flush *io; + + /* parse request */ + REQ_CHECK_WCT(req, 1); + REQ_TALLOC(io, sizeof(*io)); + + io->in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_flush(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a exit. This closes all files open by a smbpid +****************************************************************************/ +void reply_exit(struct smbsrv_request *req) +{ + NTSTATUS status; + struct smbsrv_tcon *tcon; + REQ_CHECK_WCT(req, 0); + + for (tcon=req->smb_conn->tcons.list;tcon;tcon=tcon->next) { + req->tcon = tcon; + status = ntvfs_exit(req); + req->tcon = NULL; + if (!NT_STATUS_IS_OK(status)) { + req_reply_error(req, status); + return; + } + } + + req_setup_reply(req, 0, 0); + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a close + + Note that this has to deal with closing a directory opened by NT SMB's. +****************************************************************************/ +void reply_close(struct smbsrv_request *req) +{ + union smb_close *io; + + /* parse request */ + REQ_CHECK_WCT(req, 3); + REQ_TALLOC(io, sizeof(*io)); + + io->close.level = RAW_CLOSE_CLOSE; + 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_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_close(req, io); + + REQ_ASYNC_TAIL; +} + + + +/**************************************************************************** + Reply to a writeclose (async reply) +****************************************************************************/ +static void reply_writeclose_send(struct smbsrv_request *req) +{ + union smb_write *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 1, 0); + + SSVAL(req->out.vwv, VWV(0), io->write.out.nwritten); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a writeclose (Core+ protocol). +****************************************************************************/ +void reply_writeclose(struct smbsrv_request *req) +{ + union smb_write *io; + + /* this one is pretty weird - the wct can be 6 or 12 */ + if (req->in.wct != 12) { + REQ_CHECK_WCT(req, 6); + } + + REQ_TALLOC(io, sizeof(*io)); + + io->writeclose.level = RAW_WRITE_WRITECLOSE; + io->writeclose.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->writeclose.in.count = SVAL(req->in.vwv, VWV(1)); + io->writeclose.in.offset = IVAL(req->in.vwv, VWV(2)); + io->writeclose.in.mtime = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(4)); + io->writeclose.in.data = req->in.data + 1; + + /* make sure they gave us the data they promised */ + if (req_data_oob(req, io->writeclose.in.data, io->writeclose.in.count)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + 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_states->status = ntvfs_write(req, io); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a lock. +****************************************************************************/ +void reply_lock(struct smbsrv_request *req) +{ + union smb_lock *lck; + + /* parse request */ + REQ_CHECK_WCT(req, 5); + REQ_TALLOC(lck, sizeof(*lck)); + + lck->lock.level = RAW_LOCK_LOCK; + lck->lock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->lock.in.count = IVAL(req->in.vwv, VWV(1)); + lck->lock.in.offset = IVAL(req->in.vwv, VWV(3)); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_lock(req, lck); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a unlock. +****************************************************************************/ +void reply_unlock(struct smbsrv_request *req) +{ + union smb_lock *lck; + + /* parse request */ + REQ_CHECK_WCT(req, 5); + REQ_TALLOC(lck, sizeof(*lck)); + + lck->unlock.level = RAW_LOCK_UNLOCK; + lck->unlock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->unlock.in.count = IVAL(req->in.vwv, VWV(1)); + lck->unlock.in.offset = IVAL(req->in.vwv, VWV(3)); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_lock(req, lck); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a tdis. +****************************************************************************/ +void reply_tdis(struct smbsrv_request *req) +{ + REQ_CHECK_WCT(req, 0); + + if (req->tcon == NULL) { + req_reply_error(req, NT_STATUS_INVALID_HANDLE); + return; + } + + talloc_free(req->tcon); + + /* construct reply */ + req_setup_reply(req, 0, 0); + + req_send_reply(req); +} + + +/**************************************************************************** + Reply to a echo. This is one of the few calls that is handled directly (the + backends don't see it at all) +****************************************************************************/ +void reply_echo(struct smbsrv_request *req) +{ + uint16_t count; + int i; + + REQ_CHECK_WCT(req, 0); + + count = SVAL(req->in.vwv, VWV(0)); + + req_setup_reply(req, 1, req->in.data_size); + + 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) { + this_req = req_setup_secondary(req); + } else { + this_req = req; + } + + SSVAL(this_req->out.vwv, VWV(0), i); + req_send_reply(this_req); + } +} + + + +/**************************************************************************** + Reply to a printopen (async reply) +****************************************************************************/ +static void reply_printopen_send(struct smbsrv_request *req) +{ + 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->openold.out.fnum); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a printopen. +****************************************************************************/ +void reply_printopen(struct smbsrv_request *req) +{ + union smb_open *oi; + + /* parse request */ + REQ_CHECK_WCT(req, 2); + REQ_TALLOC(oi, sizeof(*oi)); + + oi->splopen.level = RAW_OPEN_SPLOPEN; + oi->splopen.in.setup_length = SVAL(req->in.vwv, VWV(0)); + oi->splopen.in.mode = SVAL(req->in.vwv, VWV(1)); + + req_pull_ascii4(req, &oi->splopen.in.ident, req->in.data, STR_TERMINATE); + + 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_states->status = ntvfs_openfile(req, oi); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a printclose. +****************************************************************************/ +void reply_printclose(struct smbsrv_request *req) +{ + union smb_close *io; + + /* parse request */ + REQ_CHECK_WCT(req, 3); + REQ_TALLOC(io, sizeof(*io)); + + io->splclose.level = RAW_CLOSE_SPLCLOSE; + io->splclose.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_close(req, io); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a printqueue. +****************************************************************************/ +void reply_printqueue_send(struct smbsrv_request *req) +{ + union smb_lpq *lpq = req->async_states->private_data; + int i, maxcount; + const uint_t el_size = 28; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 2, 0); + + /* truncate the returned list to fit in the negotiated buffer size */ + maxcount = (req_max_data(req) - 3) / el_size; + if (maxcount < lpq->retq.out.count) { + lpq->retq.out.count = maxcount; + } + + /* setup enough space in the reply */ + req_grow_data(req, 3 + el_size*lpq->retq.out.count); + + /* and fill it in */ + SSVAL(req->out.vwv, VWV(0), lpq->retq.out.count); + SSVAL(req->out.vwv, VWV(1), lpq->retq.out.restart_idx); + + SCVAL(req->out.data, 0, SMB_DATA_BLOCK); + SSVAL(req->out.data, 1, el_size*lpq->retq.out.count); + + req->out.ptr = req->out.data + 3; + + for (i=0;iretq.out.count;i++) { + srv_push_dos_date2(req->smb_conn, req->out.ptr, 0 , lpq->retq.out.queue[i].time); + SCVAL(req->out.ptr, 4, lpq->retq.out.queue[i].status); + SSVAL(req->out.ptr, 5, lpq->retq.out.queue[i].job); + SIVAL(req->out.ptr, 7, lpq->retq.out.queue[i].size); + SCVAL(req->out.ptr, 11, 0); /* reserved */ + req_push_str(req, req->out.ptr+12, lpq->retq.out.queue[i].user, 16, STR_ASCII); + req->out.ptr += el_size; + } + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a printqueue. +****************************************************************************/ +void reply_printqueue(struct smbsrv_request *req) +{ + union smb_lpq *lpq; + + /* parse request */ + REQ_CHECK_WCT(req, 2); + REQ_TALLOC(lpq, sizeof(*lpq)); + + lpq->retq.level = RAW_LPQ_RETQ; + lpq->retq.in.maxcount = SVAL(req->in.vwv, VWV(0)); + lpq->retq.in.startidx = SVAL(req->in.vwv, VWV(1)); + + 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_states->status = ntvfs_lpq(req, lpq); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a printwrite. +****************************************************************************/ +void reply_printwrite(struct smbsrv_request *req) +{ + union smb_write *io; + + /* parse request */ + REQ_CHECK_WCT(req, 1); + REQ_TALLOC(io, sizeof(*io)); + + io->splwrite.level = RAW_WRITE_SPLWRITE; + + if (req->in.data_size < 3) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + io->splwrite.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->splwrite.in.count = SVAL(req->in.data, 1); + io->splwrite.in.data = req->in.data + 3; + + /* make sure they gave us the data they promised */ + if (req_data_oob(req, io->splwrite.in.data, io->splwrite.in.count)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_write(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a mkdir. +****************************************************************************/ +void reply_mkdir(struct smbsrv_request *req) +{ + union smb_mkdir *io; + + /* parse the request */ + REQ_CHECK_WCT(req, 0); + REQ_TALLOC(io, sizeof(*io)); + + io->generic.level = RAW_MKDIR_MKDIR; + req_pull_ascii4(req, &io->mkdir.in.path, req->in.data, STR_TERMINATE); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_mkdir(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a rmdir. +****************************************************************************/ +void reply_rmdir(struct smbsrv_request *req) +{ + struct smb_rmdir *io; + + /* parse the request */ + REQ_CHECK_WCT(req, 0); + REQ_TALLOC(io, sizeof(*io)); + + req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE); + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_rmdir(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a mv. +****************************************************************************/ +void reply_mv(struct smbsrv_request *req) +{ + union smb_rename *io; + uint8_t *p; + + /* parse the request */ + REQ_CHECK_WCT(req, 1); + REQ_TALLOC(io, sizeof(*io)); + + io->generic.level = RAW_RENAME_RENAME; + io->rename.in.attrib = SVAL(req->in.vwv, VWV(0)); + + p = req->in.data; + p += req_pull_ascii4(req, &io->rename.in.pattern1, p, STR_TERMINATE); + p += req_pull_ascii4(req, &io->rename.in.pattern2, p, STR_TERMINATE); + + if (!io->rename.in.pattern1 || !io->rename.in.pattern2) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_rename(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to an NT rename. +****************************************************************************/ +void reply_ntrename(struct smbsrv_request *req) +{ + union smb_rename *io; + uint8_t *p; + + /* parse the request */ + REQ_CHECK_WCT(req, 4); + REQ_TALLOC(io, sizeof(*io)); + + io->generic.level = RAW_RENAME_NTRENAME; + io->ntrename.in.attrib = SVAL(req->in.vwv, VWV(0)); + io->ntrename.in.flags = SVAL(req->in.vwv, VWV(1)); + io->ntrename.in.cluster_size = IVAL(req->in.vwv, VWV(2)); + + p = req->in.data; + p += req_pull_ascii4(req, &io->ntrename.in.old_name, p, STR_TERMINATE); + p += req_pull_ascii4(req, &io->ntrename.in.new_name, p, STR_TERMINATE); + + if (!io->ntrename.in.old_name || !io->ntrename.in.new_name) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_rename(req, io); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a file copy (async reply) +****************************************************************************/ +static void reply_copy_send(struct smbsrv_request *req) +{ + struct smb_copy *cp = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* build the reply */ + req_setup_reply(req, 1, 0); + + SSVAL(req->out.vwv, VWV(0), cp->out.count); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a file copy. +****************************************************************************/ +void reply_copy(struct smbsrv_request *req) +{ + struct smb_copy *cp; + uint8_t *p; + + /* parse request */ + REQ_CHECK_WCT(req, 3); + REQ_TALLOC(cp, sizeof(*cp)); + + cp->in.tid2 = SVAL(req->in.vwv, VWV(0)); + cp->in.ofun = SVAL(req->in.vwv, VWV(1)); + cp->in.flags = SVAL(req->in.vwv, VWV(2)); + + p = req->in.data; + p += req_pull_ascii4(req, &cp->in.path1, p, STR_TERMINATE); + p += req_pull_ascii4(req, &cp->in.path2, p, STR_TERMINATE); + + if (!cp->in.path1 || !cp->in.path2) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + 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_states->status = ntvfs_copy(req, cp); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a lockingX request (async send) +****************************************************************************/ +static void reply_lockingX_send(struct smbsrv_request *req) +{ + union smb_lock *lck = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* if it was an oplock break ack then we only send a reply if + there was an error */ + if (lck->lockx.in.ulock_cnt + lck->lockx.in.lock_cnt == 0) { + req_destroy(req); + return; + } + + /* construct reply */ + req_setup_reply(req, 2, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + + chain_reply(req); +} + + +/**************************************************************************** + Reply to a lockingX request. +****************************************************************************/ +void reply_lockingX(struct smbsrv_request *req) +{ + union smb_lock *lck; + uint_t total_locks, i; + uint_t lck_size; + uint8_t *p; + + /* parse request */ + REQ_CHECK_WCT(req, 8); + REQ_TALLOC(lck, sizeof(*lck)); + + lck->lockx.level = RAW_LOCK_LOCKX; + lck->lockx.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); + lck->lockx.in.mode = SVAL(req->in.vwv, VWV(3)); + lck->lockx.in.timeout = IVAL(req->in.vwv, VWV(4)); + lck->lockx.in.ulock_cnt = SVAL(req->in.vwv, VWV(6)); + lck->lockx.in.lock_cnt = SVAL(req->in.vwv, VWV(7)); + + total_locks = lck->lockx.in.ulock_cnt + lck->lockx.in.lock_cnt; + + /* there are two variants, one with 64 bit offsets and counts */ + if (lck->lockx.in.mode & LOCKING_ANDX_LARGE_FILES) { + lck_size = 20; + } else { + lck_size = 10; + } + + /* make sure we got the promised data */ + if (req_data_oob(req, req->in.data, total_locks * lck_size)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + /* allocate the locks array */ + if (total_locks) { + REQ_TALLOC(lck->lockx.in.locks, total_locks * sizeof(lck->lockx.in.locks[0])); + } + + p = req->in.data; + + /* construct the locks array */ + for (i=0;ilockx.in.locks[i].pid = SVAL(p, 0); + + if (lck->lockx.in.mode & LOCKING_ANDX_LARGE_FILES) { + ofs_high = IVAL(p, 4); + lck->lockx.in.locks[i].offset = IVAL(p, 8); + count_high = IVAL(p, 12); + lck->lockx.in.locks[i].count = IVAL(p, 16); + } else { + lck->lockx.in.locks[i].offset = IVAL(p, 2); + lck->lockx.in.locks[i].count = IVAL(p, 6); + } + if (ofs_high != 0 || count_high != 0) { + lck->lockx.in.locks[i].count |= ((uint64_t)count_high) << 32; + lck->lockx.in.locks[i].offset |= ((uint64_t)ofs_high) << 32; + } + p += lck_size; + } + + 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_states->status = ntvfs_lock(req, lck); + + REQ_ASYNC_TAIL; +} + +/**************************************************************************** + Reply to a SMBreadbmpx (read block multiplex) request. +****************************************************************************/ +void reply_readbmpx(struct smbsrv_request *req) +{ + /* tell the client to not use a multiplexed read - its too broken to use */ + req_reply_dos_error(req, ERRSRV, ERRuseSTD); +} + + +/**************************************************************************** + Reply to a SMBsetattrE. +****************************************************************************/ +void reply_setattrE(struct smbsrv_request *req) +{ + union smb_setfileinfo *info; + + /* parse request */ + REQ_CHECK_WCT(req, 7); + REQ_TALLOC(info, sizeof(*info)); + + info->setattre.level = RAW_SFILEINFO_SETATTRE; + info->setattre.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + info->setattre.in.create_time = srv_pull_dos_date2(req->smb_conn, req->in.vwv + VWV(1)); + 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_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; + req->async_states->send_fn = reply_simple_send; + + /* call backend */ + req->async_states->status = ntvfs_setfileinfo(req, info); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to a SMBwritebmpx (write block multiplex primary) request. +****************************************************************************/ +void reply_writebmpx(struct smbsrv_request *req) +{ + req_reply_dos_error(req, ERRSRV, ERRuseSTD); +} + + +/**************************************************************************** + Reply to a SMBwritebs (write block multiplex secondary) request. +****************************************************************************/ +void reply_writebs(struct smbsrv_request *req) +{ + req_reply_dos_error(req, ERRSRV, ERRuseSTD); +} + + + +/**************************************************************************** + Reply to a SMBgetattrE (async reply) +****************************************************************************/ +static void reply_getattrE_send(struct smbsrv_request *req) +{ + union smb_fileinfo *info = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* setup reply */ + req_setup_reply(req, 11, 0); + + srv_push_dos_date2(req->smb_conn, req->out.vwv, VWV(0), info->getattre.out.create_time); + srv_push_dos_date2(req->smb_conn, req->out.vwv, VWV(2), info->getattre.out.access_time); + srv_push_dos_date2(req->smb_conn, req->out.vwv, VWV(4), info->getattre.out.write_time); + SIVAL(req->out.vwv, VWV(6), info->getattre.out.size); + SIVAL(req->out.vwv, VWV(8), info->getattre.out.alloc_size); + SSVAL(req->out.vwv, VWV(10), info->getattre.out.attrib); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to a SMBgetattrE. +****************************************************************************/ +void reply_getattrE(struct smbsrv_request *req) +{ + union smb_fileinfo *info; + + /* parse request */ + REQ_CHECK_WCT(req, 1); + REQ_TALLOC(info, sizeof(*info)); + + info->getattr.level = RAW_FILEINFO_GETATTRE; + info->getattr.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + + 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_states->status = ntvfs_qfileinfo(req, info); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** +reply to an old style session setup command +****************************************************************************/ +static void reply_sesssetup_old(struct smbsrv_request *req) +{ + NTSTATUS status; + union smb_sesssetup sess; + uint8_t *p; + uint16_t passlen; + + sess.old.level = RAW_SESSSETUP_OLD; + + /* parse request */ + sess.old.in.bufsize = SVAL(req->in.vwv, VWV(2)); + sess.old.in.mpx_max = SVAL(req->in.vwv, VWV(3)); + sess.old.in.vc_num = SVAL(req->in.vwv, VWV(4)); + sess.old.in.sesskey = IVAL(req->in.vwv, VWV(5)); + passlen = SVAL(req->in.vwv, VWV(7)); + + /* check the request isn't malformed */ + if (req_data_oob(req, req->in.data, passlen)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + p = req->in.data; + if (!req_pull_blob(req, p, passlen, &sess.old.in.password)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + p += passlen; + + p += req_pull_string(req, &sess.old.in.user, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.old.in.domain, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.old.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.old.in.lanman, p, -1, STR_TERMINATE); + + /* call the generic handler */ + status = sesssetup_backend(req, &sess); + + if (!NT_STATUS_IS_OK(status)) { + req_reply_error(req, status); + return; + } + + /* construct reply */ + req_setup_reply(req, 3, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), sess.old.out.action); + + SSVAL(req->out.hdr, HDR_UID, sess.old.out.vuid); + + chain_reply(req); +} + + +/**************************************************************************** +reply to an NT1 style session setup command +****************************************************************************/ +static void reply_sesssetup_nt1(struct smbsrv_request *req) +{ + NTSTATUS status; + union smb_sesssetup sess; + uint8_t *p; + uint16_t passlen1, passlen2; + + sess.nt1.level = RAW_SESSSETUP_NT1; + + /* parse request */ + sess.nt1.in.bufsize = SVAL(req->in.vwv, VWV(2)); + sess.nt1.in.mpx_max = SVAL(req->in.vwv, VWV(3)); + sess.nt1.in.vc_num = SVAL(req->in.vwv, VWV(4)); + sess.nt1.in.sesskey = IVAL(req->in.vwv, VWV(5)); + passlen1 = SVAL(req->in.vwv, VWV(7)); + passlen2 = SVAL(req->in.vwv, VWV(8)); + sess.nt1.in.capabilities = IVAL(req->in.vwv, VWV(11)); + + /* check the request isn't malformed */ + if (req_data_oob(req, req->in.data, passlen1) || + req_data_oob(req, req->in.data + passlen1, passlen2)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + p = req->in.data; + if (!req_pull_blob(req, p, passlen1, &sess.nt1.in.password1)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + p += passlen1; + if (!req_pull_blob(req, p, passlen2, &sess.nt1.in.password2)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + p += passlen2; + + p += req_pull_string(req, &sess.nt1.in.user, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.nt1.in.domain, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.nt1.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.nt1.in.lanman, p, -1, STR_TERMINATE); + + /* call the generic handler */ + status = sesssetup_backend(req, &sess); + + if (!NT_STATUS_IS_OK(status)) { + req_reply_error(req, status); + return; + } + + /* construct reply */ + req_setup_reply(req, 3, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), sess.nt1.out.action); + + SSVAL(req->out.hdr, HDR_UID, sess.nt1.out.vuid); + + req_push_str(req, NULL, sess.nt1.out.os, -1, STR_TERMINATE); + req_push_str(req, NULL, sess.nt1.out.lanman, -1, STR_TERMINATE); + req_push_str(req, NULL, sess.nt1.out.domain, -1, STR_TERMINATE); + + chain_reply(req); +} + + +/**************************************************************************** +reply to an SPNEGO style session setup command +****************************************************************************/ +static void reply_sesssetup_spnego(struct smbsrv_request *req) +{ + NTSTATUS status; + union smb_sesssetup sess; + uint8_t *p; + uint16_t blob_len; + + sess.spnego.level = RAW_SESSSETUP_SPNEGO; + + /* parse request */ + sess.spnego.in.bufsize = SVAL(req->in.vwv, VWV(2)); + sess.spnego.in.mpx_max = SVAL(req->in.vwv, VWV(3)); + sess.spnego.in.vc_num = SVAL(req->in.vwv, VWV(4)); + sess.spnego.in.sesskey = IVAL(req->in.vwv, VWV(5)); + blob_len = SVAL(req->in.vwv, VWV(7)); + sess.spnego.in.capabilities = IVAL(req->in.vwv, VWV(10)); + + p = req->in.data; + if (!req_pull_blob(req, p, blob_len, &sess.spnego.in.secblob)) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + p += blob_len; + + p += req_pull_string(req, &sess.spnego.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.spnego.in.lanman, p, -1, STR_TERMINATE); + p += req_pull_string(req, &sess.spnego.in.workgroup, p, -1, STR_TERMINATE); + + /* call the generic handler */ + status = sesssetup_backend(req, &sess); + + if (!NT_STATUS_IS_OK(status) && + !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + req_reply_error(req, status); + return; + } + + /* construct reply */ + req_setup_reply(req, 4, sess.spnego.out.secblob.length); + + if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + req_setup_error(req, status); + } + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), sess.spnego.out.action); + SSVAL(req->out.vwv, VWV(3), sess.spnego.out.secblob.length); + + SSVAL(req->out.hdr, HDR_UID, sess.spnego.out.vuid); + + memcpy(req->out.data, sess.spnego.out.secblob.data, sess.spnego.out.secblob.length); + req_push_str(req, NULL, sess.spnego.out.os, -1, STR_TERMINATE); + req_push_str(req, NULL, sess.spnego.out.lanman, -1, STR_TERMINATE); + req_push_str(req, NULL, sess.spnego.out.workgroup, -1, STR_TERMINATE); + + chain_reply(req); +} + + +/**************************************************************************** +reply to a session setup command +****************************************************************************/ +void reply_sesssetup(struct smbsrv_request *req) +{ + switch (req->in.wct) { + case 10: + /* a pre-NT1 call */ + reply_sesssetup_old(req); + return; + case 13: + /* a NT1 call */ + reply_sesssetup_nt1(req); + return; + case 12: + /* a SPNEGO call */ + reply_sesssetup_spnego(req); + return; + } + + /* unsupported variant */ + req_reply_error(req, NT_STATUS_FOOBAR); +} + +/**************************************************************************** + Reply to a SMBulogoffX. +****************************************************************************/ +void reply_ulogoffX(struct smbsrv_request *req) +{ + struct smbsrv_tcon *tcon; + NTSTATUS status; + + if (!req->session) { + req_reply_error(req, NT_STATUS_DOS(ERRSRV, ERRbaduid)); + return; + } + + /* in user level security we are supposed to close any files + open by this user on all open tree connects */ + for (tcon=req->smb_conn->tcons.list;tcon;tcon=tcon->next) { + req->tcon = tcon; + status = ntvfs_logoff(req); + req->tcon = NULL; + if (!NT_STATUS_IS_OK(status)) { + req_reply_error(req, status); + return; + } + } + + talloc_free(req->session); + req->session = NULL; /* it is now invalid, don't use on + any chained packets */ + + req_setup_reply(req, 2, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + + chain_reply(req); +} + + +/**************************************************************************** + Reply to an SMBfindclose request +****************************************************************************/ +void reply_findclose(struct smbsrv_request *req) +{ + NTSTATUS status; + union smb_search_close io; + + io.findclose.level = RAW_FINDCLOSE_FINDCLOSE; + + /* parse request */ + REQ_CHECK_WCT(req, 1); + + io.findclose.in.handle = SVAL(req->in.vwv, VWV(0)); + + /* call backend */ + status = ntvfs_search_close(req, &io); + + if (!NT_STATUS_IS_OK(status)) { + req_reply_error(req, status); + return; + } + + /* construct reply */ + req_setup_reply(req, 0, 0); + + req_send_reply(req); +} + +/**************************************************************************** + Reply to an SMBfindnclose request +****************************************************************************/ +void reply_findnclose(struct smbsrv_request *req) +{ + req_reply_error(req, NT_STATUS_FOOBAR); +} + + +/**************************************************************************** + Reply to an SMBntcreateX request (async send) +****************************************************************************/ +static void reply_ntcreate_and_X_send(struct smbsrv_request *req) +{ + union smb_open *io = req->async_states->private_data; + + CHECK_ASYNC_STATUS; + + /* construct reply */ + req_setup_reply(req, 34, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SCVAL(req->out.vwv, VWV(2), io->ntcreatex.out.oplock_level); + + /* the rest of the parameters are not aligned! */ + SSVAL(req->out.vwv, 5, io->ntcreatex.out.fnum); + SIVAL(req->out.vwv, 7, io->ntcreatex.out.create_action); + push_nttime(req->out.vwv, 11, io->ntcreatex.out.create_time); + push_nttime(req->out.vwv, 19, io->ntcreatex.out.access_time); + push_nttime(req->out.vwv, 27, io->ntcreatex.out.write_time); + push_nttime(req->out.vwv, 35, io->ntcreatex.out.change_time); + SIVAL(req->out.vwv, 43, io->ntcreatex.out.attrib); + SBVAL(req->out.vwv, 47, io->ntcreatex.out.alloc_size); + SBVAL(req->out.vwv, 55, io->ntcreatex.out.size); + SSVAL(req->out.vwv, 63, io->ntcreatex.out.file_type); + SSVAL(req->out.vwv, 65, io->ntcreatex.out.ipc_state); + SCVAL(req->out.vwv, 67, io->ntcreatex.out.is_directory); + + req->chained_fnum = io->ntcreatex.out.fnum; + + chain_reply(req); +} + +/**************************************************************************** + Reply to an SMBntcreateX request +****************************************************************************/ +void reply_ntcreate_and_X(struct smbsrv_request *req) +{ + union smb_open *io; + uint16_t fname_len; + + /* parse the request */ + REQ_CHECK_WCT(req, 24); + REQ_TALLOC(io, sizeof(*io)); + + io->ntcreatex.level = RAW_OPEN_NTCREATEX; + + /* notice that the word parameters are not word aligned, so we don't use VWV() */ + fname_len = SVAL(req->in.vwv, 5); + io->ntcreatex.in.flags = IVAL(req->in.vwv, 7); + io->ntcreatex.in.root_fid = IVAL(req->in.vwv, 11); + io->ntcreatex.in.access_mask = IVAL(req->in.vwv, 15); + io->ntcreatex.in.alloc_size = BVAL(req->in.vwv, 19); + io->ntcreatex.in.file_attr = IVAL(req->in.vwv, 27); + io->ntcreatex.in.share_access = IVAL(req->in.vwv, 31); + io->ntcreatex.in.open_disposition = IVAL(req->in.vwv, 35); + 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) && + ucs2_align(req->in.buffer, req->in.data, STR_TERMINATE|STR_UNICODE)) { + fname_len++; + } + + req_pull_string(req, &io->ntcreatex.in.fname, req->in.data, fname_len, STR_TERMINATE); + if (!io->ntcreatex.in.fname) { + req_reply_error(req, NT_STATUS_FOOBAR); + return; + } + + 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_states->status = ntvfs_openfile(req, io); + + REQ_ASYNC_TAIL; +} + + +/**************************************************************************** + Reply to an SMBntcancel request +****************************************************************************/ +void reply_ntcancel(struct smbsrv_request *req) +{ + /* NOTE: this request does not generate a reply */ + ntvfs_cancel(req); + req_destroy(req); +} + +/**************************************************************************** + Reply to an SMBsends request +****************************************************************************/ +void reply_sends(struct smbsrv_request *req) +{ + req_reply_error(req, NT_STATUS_FOOBAR); +} + +/**************************************************************************** + Reply to an SMBsendstrt request +****************************************************************************/ +void reply_sendstrt(struct smbsrv_request *req) +{ + req_reply_error(req, NT_STATUS_FOOBAR); +} + +/**************************************************************************** + Reply to an SMBsendend request +****************************************************************************/ +void reply_sendend(struct smbsrv_request *req) +{ + req_reply_error(req, NT_STATUS_FOOBAR); +} + +/**************************************************************************** + Reply to an SMBsendtxt request +****************************************************************************/ +void reply_sendtxt(struct smbsrv_request *req) +{ + req_reply_error(req, NT_STATUS_FOOBAR); +} + + +/* + parse the called/calling names from session request +*/ +static NTSTATUS parse_session_request(struct smbsrv_request *req) +{ + DATA_BLOB blob; + NTSTATUS status; + + blob.data = req->in.buffer + 4; + blob.length = ascii_len_n((const char *)blob.data, req->in.size - PTR_DIFF(blob.data, req->in.buffer)); + if (blob.length == 0) return NT_STATUS_BAD_NETWORK_NAME; + + req->smb_conn->negotiate.called_name = talloc(req->smb_conn, struct nbt_name); + req->smb_conn->negotiate.calling_name = talloc(req->smb_conn, struct nbt_name); + if (req->smb_conn->negotiate.called_name == NULL || + req->smb_conn->negotiate.calling_name == NULL) { + return NT_STATUS_NO_MEMORY; + } + + status = nbt_name_from_blob(req->smb_conn, &blob, + req->smb_conn->negotiate.called_name); + NT_STATUS_NOT_OK_RETURN(status); + + blob.data += blob.length; + blob.length = ascii_len_n((const char *)blob.data, req->in.size - PTR_DIFF(blob.data, req->in.buffer)); + if (blob.length == 0) return NT_STATUS_BAD_NETWORK_NAME; + + status = nbt_name_from_blob(req->smb_conn, &blob, + req->smb_conn->negotiate.calling_name); + NT_STATUS_NOT_OK_RETURN(status); + + req->smb_conn->negotiate.done_nbt_session = True; + + return NT_STATUS_OK; +} + + + +/**************************************************************************** + Reply to a special message - a SMB packet with non zero NBT message type +****************************************************************************/ +void reply_special(struct smbsrv_request *req) +{ + uint8_t msg_type; + uint8_t *buf = talloc_zero_array(req, uint8_t, 4); + + msg_type = CVAL(req->in.buffer,0); + + SIVAL(buf, 0, 0); + + switch (msg_type) { + case 0x81: /* session request */ + if (req->smb_conn->negotiate.done_nbt_session) { + DEBUG(0,("Warning: ignoring secondary session request\n")); + return; + } + + SCVAL(buf,0,0x82); + SCVAL(buf,3,0); + + /* we don't check the status - samba always accepts session + requests for any name */ + parse_session_request(req); + + req->out.buffer = buf; + req->out.size = 4; + req_send_reply_nosign(req); + return; + + case 0x89: /* session keepalive request + (some old clients produce this?) */ + SCVAL(buf, 0, SMBkeepalive); + SCVAL(buf, 3, 0); + req->out.buffer = buf; + req->out.size = 4; + req_send_reply_nosign(req); + return; + + case SMBkeepalive: + /* session keepalive - swallow it */ + req_destroy(req); + return; + } + + DEBUG(0,("Unexpected NBT session packet (%d)\n", msg_type)); + req_destroy(req); +} -- cgit From 273f340376452bd072b68d0601dde3f7b43b62db Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 6 Dec 2005 17:59:20 +0000 Subject: r12102: for SMB2 we need to allocate tcons per session metze (This used to be commit 4d527ac005086c2db954578b4126ca128e436e01) --- source4/smb_server/smb/reply.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index eb7b5a1082..d780cb1a75 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1200,7 +1200,7 @@ void reply_exit(struct smbsrv_request *req) struct smbsrv_tcon *tcon; REQ_CHECK_WCT(req, 0); - for (tcon=req->smb_conn->tcons.list;tcon;tcon=tcon->next) { + for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { req->tcon = tcon; status = ntvfs_exit(req); req->tcon = NULL; @@ -2181,7 +2181,7 @@ void reply_ulogoffX(struct smbsrv_request *req) /* in user level security we are supposed to close any files open by this user on all open tree connects */ - for (tcon=req->smb_conn->tcons.list;tcon;tcon=tcon->next) { + for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { req->tcon = tcon; status = ntvfs_logoff(req); req->tcon = NULL; -- cgit From 0a3c167f6bcf08b2204ca49831ca49eef73dcbf4 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Tue, 27 Dec 2005 22:51:30 +0000 Subject: r12528: Add seperate proto headers for ntvfs, tdr, smb_server and nbt_server. (This used to be commit 87f665a1d5ba74289974bf9d8f9441c162e6f1b1) --- source4/smb_server/smb/reply.c | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index d780cb1a75..644a5dd1a4 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -26,6 +26,7 @@ #include "includes.h" #include "smb_server/smb_server.h" #include "libcli/nbt/libnbt.h" +#include "ntvfs/ntvfs.h" /* useful way of catching wct errors with file and line number */ -- cgit From d4de4c2d210d2e8c9b5aedf70695594809ad6a0b Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Fri, 30 Dec 2005 13:16:54 +0000 Subject: r12608: Remove some unused #include lines. (This used to be commit 70e7449318aa0e9d2639c76730a7d1683b2f4981) --- source4/smb_server/smb/reply.c | 1 - 1 file changed, 1 deletion(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 644a5dd1a4..08ec0e7403 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -25,7 +25,6 @@ #include "includes.h" #include "smb_server/smb_server.h" -#include "libcli/nbt/libnbt.h" #include "ntvfs/ntvfs.h" -- cgit From 5991787ce6c5e6e46328133b79fb22734e0ababb Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 6 Mar 2006 15:00:42 +0000 Subject: r13862: rename chain_reply -> smbsrv_chain_reply metze (This used to be commit 497b219c7d7ec15d1d25e174a7287b7da8d02403) --- source4/smb_server/smb/reply.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 08ec0e7403..5e1f707aad 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -185,7 +185,7 @@ void reply_tcon_and_X(struct smbsrv_request *req) SSVAL(req->in.hdr, HDR_TID, con.tconx.out.tid); SSVAL(req->out.hdr,HDR_TID, con.tconx.out.tid); - chain_reply(req); + smbsrv_chain_reply(req); } @@ -487,7 +487,7 @@ static void reply_open_and_X_send(struct smbsrv_request *req) req->chained_fnum = oi->openx.out.fnum; - chain_reply(req); + smbsrv_chain_reply(req); } @@ -877,7 +877,7 @@ static void reply_read_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(6), PTR_DIFF(io->readx.out.data, req->out.hdr)); REQ_VWV_RESERVED(7, 5); - chain_reply(req); + smbsrv_chain_reply(req); } /**************************************************************************** @@ -1079,7 +1079,7 @@ static void reply_write_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(4), io->writex.out.nwritten >> 16); REQ_VWV_RESERVED(5, 1); - chain_reply(req); + smbsrv_chain_reply(req); } /**************************************************************************** @@ -1769,7 +1769,7 @@ static void reply_lockingX_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); - chain_reply(req); + smbsrv_chain_reply(req); } @@ -2005,7 +2005,7 @@ static void reply_sesssetup_old(struct smbsrv_request *req) SSVAL(req->out.hdr, HDR_UID, sess.old.out.vuid); - chain_reply(req); + smbsrv_chain_reply(req); } @@ -2075,7 +2075,7 @@ static void reply_sesssetup_nt1(struct smbsrv_request *req) req_push_str(req, NULL, sess.nt1.out.lanman, -1, STR_TERMINATE); req_push_str(req, NULL, sess.nt1.out.domain, -1, STR_TERMINATE); - chain_reply(req); + smbsrv_chain_reply(req); } @@ -2138,7 +2138,7 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req) req_push_str(req, NULL, sess.spnego.out.lanman, -1, STR_TERMINATE); req_push_str(req, NULL, sess.spnego.out.workgroup, -1, STR_TERMINATE); - chain_reply(req); + smbsrv_chain_reply(req); } @@ -2200,7 +2200,7 @@ void reply_ulogoffX(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); - chain_reply(req); + smbsrv_chain_reply(req); } @@ -2274,7 +2274,7 @@ static void reply_ntcreate_and_X_send(struct smbsrv_request *req) req->chained_fnum = io->ntcreatex.out.fnum; - chain_reply(req); + smbsrv_chain_reply(req); } /**************************************************************************** -- cgit From b58f6e543d5c8a057831612a1a40e0b7d3919bce Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 6 Mar 2006 15:31:01 +0000 Subject: r13865: prefix functions with smbsrv_ metze (This used to be commit 2af96632757ee4bb0261b1871100008b48c5fd4d) --- source4/smb_server/smb/reply.c | 114 ++++++++++++++++++++--------------------- 1 file changed, 57 insertions(+), 57 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 5e1f707aad..cbfd3fac98 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -80,7 +80,7 @@ static void reply_simple_send(struct smbsrv_request *req) /**************************************************************************** Reply to a tcon. ****************************************************************************/ -void reply_tcon(struct smbsrv_request *req) +void smbsrv_reply_tcon(struct smbsrv_request *req) { union smb_tcon con; NTSTATUS status; @@ -123,7 +123,7 @@ void reply_tcon(struct smbsrv_request *req) /**************************************************************************** Reply to a tcon and X. ****************************************************************************/ -void reply_tcon_and_X(struct smbsrv_request *req) +void smbsrv_reply_tcon_and_X(struct smbsrv_request *req) { NTSTATUS status; union smb_tcon con; @@ -192,7 +192,7 @@ void reply_tcon_and_X(struct smbsrv_request *req) /**************************************************************************** Reply to an unknown request ****************************************************************************/ -void reply_unknown(struct smbsrv_request *req) +void smbsrv_reply_unknown(struct smbsrv_request *req) { int type; @@ -227,7 +227,7 @@ static void reply_ioctl_send(struct smbsrv_request *req) /**************************************************************************** Reply to an ioctl. ****************************************************************************/ -void reply_ioctl(struct smbsrv_request *req) +void smbsrv_reply_ioctl(struct smbsrv_request *req) { union smb_ioctl *io; @@ -253,7 +253,7 @@ void reply_ioctl(struct smbsrv_request *req) /**************************************************************************** Reply to a chkpth. ****************************************************************************/ -void reply_chkpth(struct smbsrv_request *req) +void smbsrv_reply_chkpth(struct smbsrv_request *req) { struct smb_chkpath *io; @@ -294,7 +294,7 @@ static void reply_getatr_send(struct smbsrv_request *req) /**************************************************************************** Reply to a getatr. ****************************************************************************/ -void reply_getatr(struct smbsrv_request *req) +void smbsrv_reply_getatr(struct smbsrv_request *req) { union smb_fileinfo *st; @@ -323,7 +323,7 @@ void reply_getatr(struct smbsrv_request *req) /**************************************************************************** Reply to a setatr. ****************************************************************************/ -void reply_setatr(struct smbsrv_request *req) +void smbsrv_reply_setatr(struct smbsrv_request *req) { union smb_setfileinfo *st; @@ -378,7 +378,7 @@ static void reply_dskattr_send(struct smbsrv_request *req) /**************************************************************************** Reply to a dskattr. ****************************************************************************/ -void reply_dskattr(struct smbsrv_request *req) +void smbsrv_reply_dskattr(struct smbsrv_request *req) { union smb_fsinfo *fs; @@ -422,7 +422,7 @@ static void reply_open_send(struct smbsrv_request *req) /**************************************************************************** Reply to an open. ****************************************************************************/ -void reply_open(struct smbsrv_request *req) +void smbsrv_reply_open(struct smbsrv_request *req) { union smb_open *oi; @@ -494,7 +494,7 @@ static void reply_open_and_X_send(struct smbsrv_request *req) /**************************************************************************** Reply to an open and X. ****************************************************************************/ -void reply_open_and_X(struct smbsrv_request *req) +void smbsrv_reply_open_and_X(struct smbsrv_request *req) { union smb_open *oi; @@ -551,7 +551,7 @@ static void reply_mknew_send(struct smbsrv_request *req) /**************************************************************************** Reply to a mknew or a create. ****************************************************************************/ -void reply_mknew(struct smbsrv_request *req) +void smbsrv_reply_mknew(struct smbsrv_request *req) { union smb_open *oi; @@ -607,7 +607,7 @@ static void reply_ctemp_send(struct smbsrv_request *req) /**************************************************************************** Reply to a create temporary file. ****************************************************************************/ -void reply_ctemp(struct smbsrv_request *req) +void smbsrv_reply_ctemp(struct smbsrv_request *req) { union smb_open *oi; @@ -642,7 +642,7 @@ void reply_ctemp(struct smbsrv_request *req) /**************************************************************************** Reply to a unlink ****************************************************************************/ -void reply_unlink(struct smbsrv_request *req) +void smbsrv_reply_unlink(struct smbsrv_request *req) { struct smb_unlink *unl; @@ -670,7 +670,7 @@ void reply_unlink(struct smbsrv_request *req) only the 4 byte NBT header This command must be replied to synchronously ****************************************************************************/ -void reply_readbraw(struct smbsrv_request *req) +void smbsrv_reply_readbraw(struct smbsrv_request *req) { NTSTATUS status; union smb_read io; @@ -757,7 +757,7 @@ static void reply_lockread_send(struct smbsrv_request *req) Reply to a lockread (core+ protocol). note that the lock is a write lock, not a read lock! ****************************************************************************/ -void reply_lockread(struct smbsrv_request *req) +void smbsrv_reply_lockread(struct smbsrv_request *req) { union smb_read *io; @@ -816,7 +816,7 @@ static void reply_read_send(struct smbsrv_request *req) /**************************************************************************** Reply to a read. ****************************************************************************/ -void reply_read(struct smbsrv_request *req) +void smbsrv_reply_read(struct smbsrv_request *req) { union smb_read *io; @@ -883,7 +883,7 @@ static void reply_read_and_X_send(struct smbsrv_request *req) /**************************************************************************** Reply to a read and X. ****************************************************************************/ -void reply_read_and_X(struct smbsrv_request *req) +void smbsrv_reply_read_and_X(struct smbsrv_request *req) { union smb_read *io; @@ -939,7 +939,7 @@ void reply_read_and_X(struct smbsrv_request *req) /**************************************************************************** Reply to a writebraw (core+ or LANMAN1.0 protocol). ****************************************************************************/ -void reply_writebraw(struct smbsrv_request *req) +void smbsrv_reply_writebraw(struct smbsrv_request *req) { req_reply_dos_error(req, ERRSRV, ERRuseSTD); } @@ -965,7 +965,7 @@ static void reply_writeunlock_send(struct smbsrv_request *req) /**************************************************************************** Reply to a writeunlock (core+). ****************************************************************************/ -void reply_writeunlock(struct smbsrv_request *req) +void smbsrv_reply_writeunlock(struct smbsrv_request *req) { union smb_write *io; @@ -1023,7 +1023,7 @@ static void reply_write_send(struct smbsrv_request *req) /**************************************************************************** Reply to a write ****************************************************************************/ -void reply_write(struct smbsrv_request *req) +void smbsrv_reply_write(struct smbsrv_request *req) { union smb_write *io; @@ -1085,7 +1085,7 @@ static void reply_write_and_X_send(struct smbsrv_request *req) /**************************************************************************** Reply to a write and X. ****************************************************************************/ -void reply_write_and_X(struct smbsrv_request *req) +void smbsrv_reply_write_and_X(struct smbsrv_request *req) { union smb_write *io; @@ -1147,7 +1147,7 @@ static void reply_lseek_send(struct smbsrv_request *req) /**************************************************************************** Reply to a lseek. ****************************************************************************/ -void reply_lseek(struct smbsrv_request *req) +void smbsrv_reply_lseek(struct smbsrv_request *req) { struct smb_seek *io; @@ -1171,7 +1171,7 @@ void reply_lseek(struct smbsrv_request *req) /**************************************************************************** Reply to a flush. ****************************************************************************/ -void reply_flush(struct smbsrv_request *req) +void smbsrv_reply_flush(struct smbsrv_request *req) { struct smb_flush *io; @@ -1194,7 +1194,7 @@ void reply_flush(struct smbsrv_request *req) /**************************************************************************** Reply to a exit. This closes all files open by a smbpid ****************************************************************************/ -void reply_exit(struct smbsrv_request *req) +void smbsrv_reply_exit(struct smbsrv_request *req) { NTSTATUS status; struct smbsrv_tcon *tcon; @@ -1220,7 +1220,7 @@ void reply_exit(struct smbsrv_request *req) Note that this has to deal with closing a directory opened by NT SMB's. ****************************************************************************/ -void reply_close(struct smbsrv_request *req) +void smbsrv_reply_close(struct smbsrv_request *req) { union smb_close *io; @@ -1263,7 +1263,7 @@ static void reply_writeclose_send(struct smbsrv_request *req) /**************************************************************************** Reply to a writeclose (Core+ protocol). ****************************************************************************/ -void reply_writeclose(struct smbsrv_request *req) +void smbsrv_reply_writeclose(struct smbsrv_request *req) { union smb_write *io; @@ -1300,7 +1300,7 @@ void reply_writeclose(struct smbsrv_request *req) /**************************************************************************** Reply to a lock. ****************************************************************************/ -void reply_lock(struct smbsrv_request *req) +void smbsrv_reply_lock(struct smbsrv_request *req) { union smb_lock *lck; @@ -1326,7 +1326,7 @@ void reply_lock(struct smbsrv_request *req) /**************************************************************************** Reply to a unlock. ****************************************************************************/ -void reply_unlock(struct smbsrv_request *req) +void smbsrv_reply_unlock(struct smbsrv_request *req) { union smb_lock *lck; @@ -1352,7 +1352,7 @@ void reply_unlock(struct smbsrv_request *req) /**************************************************************************** Reply to a tdis. ****************************************************************************/ -void reply_tdis(struct smbsrv_request *req) +void smbsrv_reply_tdis(struct smbsrv_request *req) { REQ_CHECK_WCT(req, 0); @@ -1374,7 +1374,7 @@ void reply_tdis(struct smbsrv_request *req) Reply to a echo. This is one of the few calls that is handled directly (the backends don't see it at all) ****************************************************************************/ -void reply_echo(struct smbsrv_request *req) +void smbsrv_reply_echo(struct smbsrv_request *req) { uint16_t count; int i; @@ -1423,7 +1423,7 @@ static void reply_printopen_send(struct smbsrv_request *req) /**************************************************************************** Reply to a printopen. ****************************************************************************/ -void reply_printopen(struct smbsrv_request *req) +void smbsrv_reply_printopen(struct smbsrv_request *req) { union smb_open *oi; @@ -1450,7 +1450,7 @@ void reply_printopen(struct smbsrv_request *req) /**************************************************************************** Reply to a printclose. ****************************************************************************/ -void reply_printclose(struct smbsrv_request *req) +void smbsrv_reply_printclose(struct smbsrv_request *req) { union smb_close *io; @@ -1473,7 +1473,7 @@ void reply_printclose(struct smbsrv_request *req) /**************************************************************************** Reply to a printqueue. ****************************************************************************/ -void reply_printqueue_send(struct smbsrv_request *req) +static void reply_printqueue_send(struct smbsrv_request *req) { union smb_lpq *lpq = req->async_states->private_data; int i, maxcount; @@ -1518,7 +1518,7 @@ void reply_printqueue_send(struct smbsrv_request *req) /**************************************************************************** Reply to a printqueue. ****************************************************************************/ -void reply_printqueue(struct smbsrv_request *req) +void smbsrv_reply_printqueue(struct smbsrv_request *req) { union smb_lpq *lpq; @@ -1544,7 +1544,7 @@ void reply_printqueue(struct smbsrv_request *req) /**************************************************************************** Reply to a printwrite. ****************************************************************************/ -void reply_printwrite(struct smbsrv_request *req) +void smbsrv_reply_printwrite(struct smbsrv_request *req) { union smb_write *io; @@ -1582,7 +1582,7 @@ void reply_printwrite(struct smbsrv_request *req) /**************************************************************************** Reply to a mkdir. ****************************************************************************/ -void reply_mkdir(struct smbsrv_request *req) +void smbsrv_reply_mkdir(struct smbsrv_request *req) { union smb_mkdir *io; @@ -1606,7 +1606,7 @@ void reply_mkdir(struct smbsrv_request *req) /**************************************************************************** Reply to a rmdir. ****************************************************************************/ -void reply_rmdir(struct smbsrv_request *req) +void smbsrv_reply_rmdir(struct smbsrv_request *req) { struct smb_rmdir *io; @@ -1629,7 +1629,7 @@ void reply_rmdir(struct smbsrv_request *req) /**************************************************************************** Reply to a mv. ****************************************************************************/ -void reply_mv(struct smbsrv_request *req) +void smbsrv_reply_mv(struct smbsrv_request *req) { union smb_rename *io; uint8_t *p; @@ -1663,7 +1663,7 @@ void reply_mv(struct smbsrv_request *req) /**************************************************************************** Reply to an NT rename. ****************************************************************************/ -void reply_ntrename(struct smbsrv_request *req) +void smbsrv_reply_ntrename(struct smbsrv_request *req) { union smb_rename *io; uint8_t *p; @@ -1715,7 +1715,7 @@ static void reply_copy_send(struct smbsrv_request *req) /**************************************************************************** Reply to a file copy. ****************************************************************************/ -void reply_copy(struct smbsrv_request *req) +void smbsrv_reply_copy(struct smbsrv_request *req) { struct smb_copy *cp; uint8_t *p; @@ -1776,7 +1776,7 @@ static void reply_lockingX_send(struct smbsrv_request *req) /**************************************************************************** Reply to a lockingX request. ****************************************************************************/ -void reply_lockingX(struct smbsrv_request *req) +void smbsrv_reply_lockingX(struct smbsrv_request *req) { union smb_lock *lck; uint_t total_locks, i; @@ -1851,7 +1851,7 @@ void reply_lockingX(struct smbsrv_request *req) /**************************************************************************** Reply to a SMBreadbmpx (read block multiplex) request. ****************************************************************************/ -void reply_readbmpx(struct smbsrv_request *req) +void smbsrv_reply_readbmpx(struct smbsrv_request *req) { /* tell the client to not use a multiplexed read - its too broken to use */ req_reply_dos_error(req, ERRSRV, ERRuseSTD); @@ -1861,7 +1861,7 @@ void reply_readbmpx(struct smbsrv_request *req) /**************************************************************************** Reply to a SMBsetattrE. ****************************************************************************/ -void reply_setattrE(struct smbsrv_request *req) +void smbsrv_reply_setattrE(struct smbsrv_request *req) { union smb_setfileinfo *info; @@ -1888,7 +1888,7 @@ void reply_setattrE(struct smbsrv_request *req) /**************************************************************************** Reply to a SMBwritebmpx (write block multiplex primary) request. ****************************************************************************/ -void reply_writebmpx(struct smbsrv_request *req) +void smbsrv_reply_writebmpx(struct smbsrv_request *req) { req_reply_dos_error(req, ERRSRV, ERRuseSTD); } @@ -1897,7 +1897,7 @@ void reply_writebmpx(struct smbsrv_request *req) /**************************************************************************** Reply to a SMBwritebs (write block multiplex secondary) request. ****************************************************************************/ -void reply_writebs(struct smbsrv_request *req) +void smbsrv_reply_writebs(struct smbsrv_request *req) { req_reply_dos_error(req, ERRSRV, ERRuseSTD); } @@ -1929,7 +1929,7 @@ static void reply_getattrE_send(struct smbsrv_request *req) /**************************************************************************** Reply to a SMBgetattrE. ****************************************************************************/ -void reply_getattrE(struct smbsrv_request *req) +void smbsrv_reply_getattrE(struct smbsrv_request *req) { union smb_fileinfo *info; @@ -2145,7 +2145,7 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req) /**************************************************************************** reply to a session setup command ****************************************************************************/ -void reply_sesssetup(struct smbsrv_request *req) +void smbsrv_reply_sesssetup(struct smbsrv_request *req) { switch (req->in.wct) { case 10: @@ -2169,7 +2169,7 @@ void reply_sesssetup(struct smbsrv_request *req) /**************************************************************************** Reply to a SMBulogoffX. ****************************************************************************/ -void reply_ulogoffX(struct smbsrv_request *req) +void smbsrv_reply_ulogoffX(struct smbsrv_request *req) { struct smbsrv_tcon *tcon; NTSTATUS status; @@ -2207,7 +2207,7 @@ void reply_ulogoffX(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBfindclose request ****************************************************************************/ -void reply_findclose(struct smbsrv_request *req) +void smbsrv_reply_findclose(struct smbsrv_request *req) { NTSTATUS status; union smb_search_close io; @@ -2236,7 +2236,7 @@ void reply_findclose(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBfindnclose request ****************************************************************************/ -void reply_findnclose(struct smbsrv_request *req) +void smbsrv_reply_findnclose(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2280,7 +2280,7 @@ static void reply_ntcreate_and_X_send(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBntcreateX request ****************************************************************************/ -void reply_ntcreate_and_X(struct smbsrv_request *req) +void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) { union smb_open *io; uint16_t fname_len; @@ -2332,7 +2332,7 @@ void reply_ntcreate_and_X(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBntcancel request ****************************************************************************/ -void reply_ntcancel(struct smbsrv_request *req) +void smbsrv_reply_ntcancel(struct smbsrv_request *req) { /* NOTE: this request does not generate a reply */ ntvfs_cancel(req); @@ -2342,7 +2342,7 @@ void reply_ntcancel(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBsends request ****************************************************************************/ -void reply_sends(struct smbsrv_request *req) +void smbsrv_reply_sends(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2350,7 +2350,7 @@ void reply_sends(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBsendstrt request ****************************************************************************/ -void reply_sendstrt(struct smbsrv_request *req) +void smbsrv_reply_sendstrt(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2358,7 +2358,7 @@ void reply_sendstrt(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBsendend request ****************************************************************************/ -void reply_sendend(struct smbsrv_request *req) +void smbsrv_reply_sendend(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2366,7 +2366,7 @@ void reply_sendend(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBsendtxt request ****************************************************************************/ -void reply_sendtxt(struct smbsrv_request *req) +void smbsrv_reply_sendtxt(struct smbsrv_request *req) { req_reply_error(req, NT_STATUS_FOOBAR); } @@ -2413,7 +2413,7 @@ static NTSTATUS parse_session_request(struct smbsrv_request *req) /**************************************************************************** Reply to a special message - a SMB packet with non zero NBT message type ****************************************************************************/ -void reply_special(struct smbsrv_request *req) +void smbsrv_reply_special(struct smbsrv_request *req) { uint8_t msg_type; uint8_t *buf = talloc_zero_array(req, uint8_t, 4); -- cgit From 354a61fc915da99a16732337b62920909a591b58 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 6 Mar 2006 15:33:25 +0000 Subject: r13866: prefix more functions with smbsrv_ metze (This used to be commit bb083f17c961964dd99185ae4194596ccaafd4a8) --- source4/smb_server/smb/reply.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index cbfd3fac98..a5665d3525 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -102,7 +102,7 @@ void smbsrv_reply_tcon(struct smbsrv_request *req) } /* call backend */ - status = tcon_backend(req, &con); + status = smbsrv_tcon_backend(req, &con); if (!NT_STATUS_IS_OK(status)) { req_reply_error(req, status); @@ -155,7 +155,7 @@ void smbsrv_reply_tcon_and_X(struct smbsrv_request *req) } /* call backend */ - status = tcon_backend(req, &con); + status = smbsrv_tcon_backend(req, &con); if (!NT_STATUS_IS_OK(status)) { req_reply_error(req, status); @@ -1989,7 +1989,7 @@ static void reply_sesssetup_old(struct smbsrv_request *req) p += req_pull_string(req, &sess.old.in.lanman, p, -1, STR_TERMINATE); /* call the generic handler */ - status = sesssetup_backend(req, &sess); + status = smbsrv_sesssetup_backend(req, &sess); if (!NT_STATUS_IS_OK(status)) { req_reply_error(req, status); @@ -2055,7 +2055,7 @@ static void reply_sesssetup_nt1(struct smbsrv_request *req) p += req_pull_string(req, &sess.nt1.in.lanman, p, -1, STR_TERMINATE); /* call the generic handler */ - status = sesssetup_backend(req, &sess); + status = smbsrv_sesssetup_backend(req, &sess); if (!NT_STATUS_IS_OK(status)) { req_reply_error(req, status); @@ -2111,7 +2111,7 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req) p += req_pull_string(req, &sess.spnego.in.workgroup, p, -1, STR_TERMINATE); /* call the generic handler */ - status = sesssetup_backend(req, &sess); + status = smbsrv_sesssetup_backend(req, &sess); if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { -- cgit From 0533fed85adefc9aa74b6d5ae6b4293fb9c11d6a Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 6 Mar 2006 15:38:07 +0000 Subject: r13868: remove useless talloc_free() wrapper metze (This used to be commit bd3162e6a7f154630c2d88be70ce19e8dd977133) --- source4/smb_server/smb/reply.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index a5665d3525..3c92c6f6a5 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1759,7 +1759,7 @@ static void reply_lockingX_send(struct smbsrv_request *req) /* if it was an oplock break ack then we only send a reply if there was an error */ if (lck->lockx.in.ulock_cnt + lck->lockx.in.lock_cnt == 0) { - req_destroy(req); + talloc_free(req); return; } @@ -2336,7 +2336,7 @@ void smbsrv_reply_ntcancel(struct smbsrv_request *req) { /* NOTE: this request does not generate a reply */ ntvfs_cancel(req); - req_destroy(req); + talloc_free(req); } /**************************************************************************** @@ -2452,10 +2452,10 @@ void smbsrv_reply_special(struct smbsrv_request *req) case SMBkeepalive: /* session keepalive - swallow it */ - req_destroy(req); + talloc_free(req); return; } DEBUG(0,("Unexpected NBT session packet (%d)\n", msg_type)); - req_destroy(req); + talloc_free(req); } -- cgit From a0e66eac7d8ff337b77e078038d0b23a25b22ee7 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 6 Mar 2006 16:19:27 +0000 Subject: r13870: prefix more functions with smbsrv_ metze (This used to be commit e6275db7b926d3660ad4a0f40041a5129001427a) --- source4/smb_server/smb/reply.c | 228 ++++++++++++++++++++--------------------- 1 file changed, 114 insertions(+), 114 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 3c92c6f6a5..b608959556 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -33,14 +33,14 @@ if ((req)->in.wct != (wcount)) { \ DEBUG(1,("Unexpected WCT %d at %s(%d) - expected %d\n", \ (req)->in.wct, __FILE__, __LINE__, wcount)); \ - req_reply_dos_error(req, ERRSRV, ERRerror); \ + smbsrv_send_dos_error(req, ERRSRV, ERRerror); \ return; \ }} while (0) /* 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_states->status)) { \ - req_reply_error(req, req->async_states->status); \ + smbsrv_send_error(req, req->async_states->status); \ return; \ }} while (0) @@ -48,7 +48,7 @@ #define REQ_TALLOC(ptr, size) do { \ ptr = talloc_size(req, size); \ if (!ptr) { \ - req_reply_error(req, NT_STATUS_NO_MEMORY); \ + smbsrv_send_error(req, NT_STATUS_NO_MEMORY); \ return; \ }} while (0) @@ -72,8 +72,8 @@ static void reply_simple_send(struct smbsrv_request *req) { CHECK_ASYNC_STATUS; - req_setup_reply(req, 0, 0); - req_send_reply(req); + smbsrv_setup_reply(req, 0, 0); + smbsrv_send_reply(req); } @@ -97,7 +97,7 @@ void smbsrv_reply_tcon(struct smbsrv_request *req) p += req_pull_ascii4(req, &con.tcon.in.dev, p, STR_TERMINATE); if (!con.tcon.in.service || !con.tcon.in.password || !con.tcon.in.dev) { - req_reply_error(req, NT_STATUS_INVALID_PARAMETER); + smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER); return; } @@ -105,18 +105,18 @@ void smbsrv_reply_tcon(struct smbsrv_request *req) status = smbsrv_tcon_backend(req, &con); if (!NT_STATUS_IS_OK(status)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } /* construct reply */ - req_setup_reply(req, 2, 0); + smbsrv_setup_reply(req, 2, 0); SSVAL(req->out.vwv, VWV(0), con.tcon.out.max_xmit); SSVAL(req->out.vwv, VWV(1), con.tcon.out.tid); SSVAL(req->out.hdr, HDR_TID, req->tcon->tid); - req_send_reply(req); + smbsrv_send_reply(req); } @@ -141,7 +141,7 @@ void smbsrv_reply_tcon_and_X(struct smbsrv_request *req) p = req->in.data; if (!req_pull_blob(req, p, passlen, &con.tconx.in.password)) { - req_reply_error(req, NT_STATUS_ILL_FORMED_PASSWORD); + smbsrv_send_error(req, NT_STATUS_ILL_FORMED_PASSWORD); return; } p += passlen; @@ -150,7 +150,7 @@ void smbsrv_reply_tcon_and_X(struct smbsrv_request *req) p += req_pull_string(req, &con.tconx.in.device, p, -1, STR_ASCII); if (!con.tconx.in.path || !con.tconx.in.device) { - req_reply_error(req, NT_STATUS_BAD_DEVICE_TYPE); + smbsrv_send_error(req, NT_STATUS_BAD_DEVICE_TYPE); return; } @@ -158,20 +158,20 @@ void smbsrv_reply_tcon_and_X(struct smbsrv_request *req) status = smbsrv_tcon_backend(req, &con); if (!NT_STATUS_IS_OK(status)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } /* construct reply - two variants */ if (req->smb_conn->negotiate.protocol < PROTOCOL_NT1) { - req_setup_reply(req, 2, 0); + smbsrv_setup_reply(req, 2, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); req_push_str(req, NULL, con.tconx.out.dev_type, -1, STR_TERMINATE|STR_ASCII); } else { - req_setup_reply(req, 3, 0); + smbsrv_setup_reply(req, 3, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); @@ -200,7 +200,7 @@ void smbsrv_reply_unknown(struct smbsrv_request *req) DEBUG(0,("unknown command type %d (0x%X)\n", type, type)); - req_reply_dos_error(req, ERRSRV, ERRunknownsmb); + smbsrv_send_dos_error(req, ERRSRV, ERRunknownsmb); } @@ -214,14 +214,14 @@ static void reply_ioctl_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* the +1 is for nicer alignment */ - req_setup_reply(req, 8, io->ioctl.out.blob.length+1); + smbsrv_setup_reply(req, 8, io->ioctl.out.blob.length+1); SSVAL(req->out.vwv, VWV(1), io->ioctl.out.blob.length); SSVAL(req->out.vwv, VWV(5), io->ioctl.out.blob.length); SSVAL(req->out.vwv, VWV(6), PTR_DIFF(req->out.data, req->out.hdr) + 1); memcpy(req->out.data+1, io->ioctl.out.blob.data, io->ioctl.out.blob.length); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -279,7 +279,7 @@ static void reply_getatr_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 10, 0); + smbsrv_setup_reply(req, 10, 0); SSVAL(req->out.vwv, VWV(0), st->getattr.out.attrib); srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(1), st->getattr.out.write_time); @@ -287,7 +287,7 @@ static void reply_getatr_send(struct smbsrv_request *req) REQ_VWV_RESERVED(5, 5); - req_send_reply(req); + smbsrv_send_reply(req); } @@ -305,7 +305,7 @@ void smbsrv_reply_getatr(struct smbsrv_request *req) /* parse request */ req_pull_ascii4(req, &st->getattr.in.fname, req->in.data, STR_TERMINATE); if (!st->getattr.in.fname) { - req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -338,7 +338,7 @@ void smbsrv_reply_setatr(struct smbsrv_request *req) req_pull_ascii4(req, &st->setattr.file.fname, req->in.data, STR_TERMINATE); if (!st->setattr.file.fname) { - req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -362,7 +362,7 @@ static void reply_dskattr_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 5, 0); + smbsrv_setup_reply(req, 5, 0); SSVAL(req->out.vwv, VWV(0), fs->dskattr.out.units_total); SSVAL(req->out.vwv, VWV(1), fs->dskattr.out.blocks_per_unit); @@ -371,7 +371,7 @@ static void reply_dskattr_send(struct smbsrv_request *req) REQ_VWV_RESERVED(4, 1); - req_send_reply(req); + smbsrv_send_reply(req); } @@ -408,7 +408,7 @@ static void reply_open_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 7, 0); + smbsrv_setup_reply(req, 7, 0); SSVAL(req->out.vwv, VWV(0), oi->openold.out.fnum); SSVAL(req->out.vwv, VWV(1), oi->openold.out.attrib); @@ -416,7 +416,7 @@ static void reply_open_send(struct smbsrv_request *req) SIVAL(req->out.vwv, VWV(4), oi->openold.out.size); SSVAL(req->out.vwv, VWV(6), oi->openold.out.rmode); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -437,7 +437,7 @@ void smbsrv_reply_open(struct smbsrv_request *req) req_pull_ascii4(req, &oi->openold.in.fname, req->in.data, STR_TERMINATE); if (!oi->openold.in.fname) { - req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -463,9 +463,9 @@ static void reply_open_and_X_send(struct smbsrv_request *req) /* build the reply */ if (oi->openx.in.flags & OPENX_FLAGS_EXTENDED_RETURN) { - req_setup_reply(req, 19, 0); + smbsrv_setup_reply(req, 19, 0); } else { - req_setup_reply(req, 15, 0); + smbsrv_setup_reply(req, 15, 0); } SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); @@ -515,7 +515,7 @@ void smbsrv_reply_open_and_X(struct smbsrv_request *req) req_pull_ascii4(req, &oi->openx.in.fname, req->in.data, STR_TERMINATE); if (!oi->openx.in.fname) { - req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -540,11 +540,11 @@ static void reply_mknew_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* build the reply */ - req_setup_reply(req, 1, 0); + smbsrv_setup_reply(req, 1, 0); SSVAL(req->out.vwv, VWV(0), oi->mknew.out.fnum); - req_send_reply(req); + smbsrv_send_reply(req); } @@ -570,7 +570,7 @@ void smbsrv_reply_mknew(struct smbsrv_request *req) req_pull_ascii4(req, &oi->mknew.in.fname, req->in.data, STR_TERMINATE); if (!oi->mknew.in.fname) { - req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -594,14 +594,14 @@ static void reply_ctemp_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* build the reply */ - req_setup_reply(req, 1, 0); + smbsrv_setup_reply(req, 1, 0); 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 | STR_ASCII); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -624,7 +624,7 @@ void smbsrv_reply_ctemp(struct smbsrv_request *req) req_pull_ascii4(req, &oi->ctemp.in.directory, req->in.data, STR_TERMINATE); if (!oi->ctemp.in.directory) { - req_reply_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); + smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -715,7 +715,7 @@ void smbsrv_reply_readbraw(struct smbsrv_request *req) req->out.size = io.readbraw.out.nread + NBT_HDR_SIZE; - req_send_reply_nosign(req); + smbsrv_send_reply_nosign(req); return; failed: @@ -724,7 +724,7 @@ failed: req->out.buffer = talloc_size(req, req->out.size); SIVAL(req->out.buffer, 0, 0); /* init NBT header */ - req_send_reply_nosign(req); + smbsrv_send_reply_nosign(req); } @@ -749,7 +749,7 @@ static void reply_lockread_send(struct smbsrv_request *req) SCVAL(req->out.data, 0, SMB_DATA_BLOCK); SSVAL(req->out.data, 1, io->lockread.out.nread); - req_send_reply(req); + smbsrv_send_reply(req); } @@ -772,7 +772,7 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) io->lockread.in.remaining = SVAL(req->in.vwv, VWV(4)); /* setup the reply packet assuming the maximum possible read */ - req_setup_reply(req, 5, 3 + io->lockread.in.count); + smbsrv_setup_reply(req, 5, 3 + io->lockread.in.count); /* tell the backend where to put the data */ io->lockread.out.data = req->out.data + 3; @@ -810,7 +810,7 @@ static void reply_read_send(struct smbsrv_request *req) SCVAL(req->out.data, 0, SMB_DATA_BLOCK); SSVAL(req->out.data, 1, io->read.out.nread); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -831,7 +831,7 @@ void smbsrv_reply_read(struct smbsrv_request *req) io->read.in.remaining = SVAL(req->in.vwv, VWV(4)); /* setup the reply packet assuming the maximum possible read */ - req_setup_reply(req, 5, 3 + io->read.in.count); + smbsrv_setup_reply(req, 5, 3 + io->read.in.count); /* tell the backend where to put the data */ io->read.out.data = req->out.data + 3; @@ -915,7 +915,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) } /* setup the reply packet assuming the maximum possible read */ - req_setup_reply(req, 12, 1 + io->readx.in.maxcnt); + smbsrv_setup_reply(req, 12, 1 + io->readx.in.maxcnt); /* tell the backend where to put the data. Notice the pad byte. */ if (io->readx.in.maxcnt != 0xFFFF && @@ -941,7 +941,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_writebraw(struct smbsrv_request *req) { - req_reply_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); } @@ -955,11 +955,11 @@ static void reply_writeunlock_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 1, 0); + smbsrv_setup_reply(req, 1, 0); SSVAL(req->out.vwv, VWV(0), io->writeunlock.out.nwritten); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -981,13 +981,13 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) /* make sure they gave us the data they promised */ if (io->writeunlock.in.count+3 > req->in.data_size) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } /* make sure the data block is big enough */ if (SVAL(req->in.data, 1) < io->writeunlock.in.count) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1013,11 +1013,11 @@ static void reply_write_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 1, 0); + smbsrv_setup_reply(req, 1, 0); SSVAL(req->out.vwv, VWV(0), io->write.out.nwritten); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -1039,13 +1039,13 @@ void smbsrv_reply_write(struct smbsrv_request *req) /* make sure they gave us the data they promised */ if (req_data_oob(req, io->write.in.data, io->write.in.count)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } /* make sure the data block is big enough */ if (SVAL(req->in.data, 1) < io->write.in.count) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1070,7 +1070,7 @@ static void reply_write_and_X_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 6, 0); + smbsrv_setup_reply(req, 6, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); @@ -1112,7 +1112,7 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) /* make sure the data is in bounds */ if (req_data_oob(req, io->writex.in.data, io->writex.in.count)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1137,11 +1137,11 @@ static void reply_lseek_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 2, 0); + smbsrv_setup_reply(req, 2, 0); SIVALS(req->out.vwv, VWV(0), io->out.offset); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -1205,13 +1205,13 @@ void smbsrv_reply_exit(struct smbsrv_request *req) status = ntvfs_exit(req); req->tcon = NULL; if (!NT_STATUS_IS_OK(status)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } } - req_setup_reply(req, 0, 0); - req_send_reply(req); + smbsrv_setup_reply(req, 0, 0); + smbsrv_send_reply(req); } @@ -1253,11 +1253,11 @@ static void reply_writeclose_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 1, 0); + smbsrv_setup_reply(req, 1, 0); SSVAL(req->out.vwv, VWV(0), io->write.out.nwritten); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -1283,7 +1283,7 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) /* make sure they gave us the data they promised */ if (req_data_oob(req, io->writeclose.in.data, io->writeclose.in.count)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1357,16 +1357,16 @@ void smbsrv_reply_tdis(struct smbsrv_request *req) REQ_CHECK_WCT(req, 0); if (req->tcon == NULL) { - req_reply_error(req, NT_STATUS_INVALID_HANDLE); + smbsrv_send_error(req, NT_STATUS_INVALID_HANDLE); return; } talloc_free(req->tcon); /* construct reply */ - req_setup_reply(req, 0, 0); + smbsrv_setup_reply(req, 0, 0); - req_send_reply(req); + smbsrv_send_reply(req); } @@ -1383,7 +1383,7 @@ void smbsrv_reply_echo(struct smbsrv_request *req) count = SVAL(req->in.vwv, VWV(0)); - req_setup_reply(req, 1, req->in.data_size); + smbsrv_setup_reply(req, 1, req->in.data_size); memcpy(req->out.data, req->in.data, req->in.data_size); @@ -1391,13 +1391,13 @@ void smbsrv_reply_echo(struct smbsrv_request *req) struct smbsrv_request *this_req; if (i != count) { - this_req = req_setup_secondary(req); + this_req = smbsrv_setup_secondary_request(req); } else { this_req = req; } SSVAL(this_req->out.vwv, VWV(0), i); - req_send_reply(this_req); + smbsrv_send_reply(this_req); } } @@ -1413,11 +1413,11 @@ static void reply_printopen_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 1, 0); + smbsrv_setup_reply(req, 1, 0); SSVAL(req->out.vwv, VWV(0), oi->openold.out.fnum); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -1482,7 +1482,7 @@ static void reply_printqueue_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 2, 0); + smbsrv_setup_reply(req, 2, 0); /* truncate the returned list to fit in the negotiated buffer size */ maxcount = (req_max_data(req) - 3) / el_size; @@ -1512,7 +1512,7 @@ static void reply_printqueue_send(struct smbsrv_request *req) req->out.ptr += el_size; } - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -1555,7 +1555,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) io->splwrite.level = RAW_WRITE_SPLWRITE; if (req->in.data_size < 3) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1565,7 +1565,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) /* make sure they gave us the data they promised */ if (req_data_oob(req, io->splwrite.in.data, io->splwrite.in.count)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1646,7 +1646,7 @@ void smbsrv_reply_mv(struct smbsrv_request *req) p += req_pull_ascii4(req, &io->rename.in.pattern2, p, STR_TERMINATE); if (!io->rename.in.pattern1 || !io->rename.in.pattern2) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1682,7 +1682,7 @@ void smbsrv_reply_ntrename(struct smbsrv_request *req) p += req_pull_ascii4(req, &io->ntrename.in.new_name, p, STR_TERMINATE); if (!io->ntrename.in.old_name || !io->ntrename.in.new_name) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1705,11 +1705,11 @@ static void reply_copy_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* build the reply */ - req_setup_reply(req, 1, 0); + smbsrv_setup_reply(req, 1, 0); SSVAL(req->out.vwv, VWV(0), cp->out.count); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -1733,7 +1733,7 @@ void smbsrv_reply_copy(struct smbsrv_request *req) p += req_pull_ascii4(req, &cp->in.path2, p, STR_TERMINATE); if (!cp->in.path1 || !cp->in.path2) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1764,7 +1764,7 @@ static void reply_lockingX_send(struct smbsrv_request *req) } /* construct reply */ - req_setup_reply(req, 2, 0); + smbsrv_setup_reply(req, 2, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); @@ -1805,7 +1805,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) /* make sure we got the promised data */ if (req_data_oob(req, req->in.data, total_locks * lck_size)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1854,7 +1854,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) void smbsrv_reply_readbmpx(struct smbsrv_request *req) { /* tell the client to not use a multiplexed read - its too broken to use */ - req_reply_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); } @@ -1890,7 +1890,7 @@ void smbsrv_reply_setattrE(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_writebmpx(struct smbsrv_request *req) { - req_reply_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); } @@ -1899,7 +1899,7 @@ void smbsrv_reply_writebmpx(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_writebs(struct smbsrv_request *req) { - req_reply_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); } @@ -1914,7 +1914,7 @@ static void reply_getattrE_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* setup reply */ - req_setup_reply(req, 11, 0); + smbsrv_setup_reply(req, 11, 0); srv_push_dos_date2(req->smb_conn, req->out.vwv, VWV(0), info->getattre.out.create_time); srv_push_dos_date2(req->smb_conn, req->out.vwv, VWV(2), info->getattre.out.access_time); @@ -1923,7 +1923,7 @@ static void reply_getattrE_send(struct smbsrv_request *req) SIVAL(req->out.vwv, VWV(8), info->getattre.out.alloc_size); SSVAL(req->out.vwv, VWV(10), info->getattre.out.attrib); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -1972,13 +1972,13 @@ static void reply_sesssetup_old(struct smbsrv_request *req) /* check the request isn't malformed */ if (req_data_oob(req, req->in.data, passlen)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p = req->in.data; if (!req_pull_blob(req, p, passlen, &sess.old.in.password)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen; @@ -1992,12 +1992,12 @@ static void reply_sesssetup_old(struct smbsrv_request *req) status = smbsrv_sesssetup_backend(req, &sess); if (!NT_STATUS_IS_OK(status)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } /* construct reply */ - req_setup_reply(req, 3, 0); + smbsrv_setup_reply(req, 3, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); @@ -2033,18 +2033,18 @@ static void reply_sesssetup_nt1(struct smbsrv_request *req) /* check the request isn't malformed */ if (req_data_oob(req, req->in.data, passlen1) || req_data_oob(req, req->in.data + passlen1, passlen2)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p = req->in.data; if (!req_pull_blob(req, p, passlen1, &sess.nt1.in.password1)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen1; if (!req_pull_blob(req, p, passlen2, &sess.nt1.in.password2)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen2; @@ -2058,12 +2058,12 @@ static void reply_sesssetup_nt1(struct smbsrv_request *req) status = smbsrv_sesssetup_backend(req, &sess); if (!NT_STATUS_IS_OK(status)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } /* construct reply */ - req_setup_reply(req, 3, 0); + smbsrv_setup_reply(req, 3, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); @@ -2101,7 +2101,7 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req) p = req->in.data; if (!req_pull_blob(req, p, blob_len, &sess.spnego.in.secblob)) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += blob_len; @@ -2115,15 +2115,15 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req) if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } /* construct reply */ - req_setup_reply(req, 4, sess.spnego.out.secblob.length); + smbsrv_setup_reply(req, 4, sess.spnego.out.secblob.length); if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { - req_setup_error(req, status); + smbsrv_send_error(req, status); } SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); @@ -2163,7 +2163,7 @@ void smbsrv_reply_sesssetup(struct smbsrv_request *req) } /* unsupported variant */ - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); } /**************************************************************************** @@ -2175,7 +2175,7 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) NTSTATUS status; if (!req->session) { - req_reply_error(req, NT_STATUS_DOS(ERRSRV, ERRbaduid)); + smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRbaduid)); return; } @@ -2186,7 +2186,7 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) status = ntvfs_logoff(req); req->tcon = NULL; if (!NT_STATUS_IS_OK(status)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } } @@ -2195,7 +2195,7 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) req->session = NULL; /* it is now invalid, don't use on any chained packets */ - req_setup_reply(req, 2, 0); + smbsrv_setup_reply(req, 2, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); @@ -2223,14 +2223,14 @@ void smbsrv_reply_findclose(struct smbsrv_request *req) status = ntvfs_search_close(req, &io); if (!NT_STATUS_IS_OK(status)) { - req_reply_error(req, status); + smbsrv_send_error(req, status); return; } /* construct reply */ - req_setup_reply(req, 0, 0); + smbsrv_setup_reply(req, 0, 0); - req_send_reply(req); + smbsrv_send_reply(req); } /**************************************************************************** @@ -2238,7 +2238,7 @@ void smbsrv_reply_findclose(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_findnclose(struct smbsrv_request *req) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); } @@ -2252,7 +2252,7 @@ static void reply_ntcreate_and_X_send(struct smbsrv_request *req) CHECK_ASYNC_STATUS; /* construct reply */ - req_setup_reply(req, 34, 0); + smbsrv_setup_reply(req, 34, 0); SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); @@ -2314,7 +2314,7 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) req_pull_string(req, &io->ntcreatex.in.fname, req->in.data, fname_len, STR_TERMINATE); if (!io->ntcreatex.in.fname) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -2344,7 +2344,7 @@ void smbsrv_reply_ntcancel(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_sends(struct smbsrv_request *req) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); } /**************************************************************************** @@ -2352,7 +2352,7 @@ void smbsrv_reply_sends(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_sendstrt(struct smbsrv_request *req) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); } /**************************************************************************** @@ -2360,7 +2360,7 @@ void smbsrv_reply_sendstrt(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_sendend(struct smbsrv_request *req) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); } /**************************************************************************** @@ -2368,7 +2368,7 @@ void smbsrv_reply_sendend(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_sendtxt(struct smbsrv_request *req) { - req_reply_error(req, NT_STATUS_FOOBAR); + smbsrv_send_error(req, NT_STATUS_FOOBAR); } @@ -2438,7 +2438,7 @@ void smbsrv_reply_special(struct smbsrv_request *req) req->out.buffer = buf; req->out.size = 4; - req_send_reply_nosign(req); + smbsrv_send_reply_nosign(req); return; case 0x89: /* session keepalive request @@ -2447,7 +2447,7 @@ void smbsrv_reply_special(struct smbsrv_request *req) SCVAL(buf, 3, 0); req->out.buffer = buf; req->out.size = 4; - req_send_reply_nosign(req); + smbsrv_send_reply_nosign(req); return; case SMBkeepalive: -- cgit From 8d91f3dec02fd024903ac7ef748d704ef6f25228 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 6 Mar 2006 16:58:07 +0000 Subject: r13872: fix typo metze (This used to be commit f28fb440d59401fb8ba5b8eb7868f0063d151693) --- source4/smb_server/smb/reply.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index b608959556..0da61ef253 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -2123,7 +2123,7 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req) smbsrv_setup_reply(req, 4, sess.spnego.out.secblob.length); if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { - smbsrv_send_error(req, status); + smbsrv_setup_error(req, status); } SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); -- cgit From edd5b847bcd5a75770ea9de7ac1c419de8bc76ba Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Mon, 6 Mar 2006 18:29:48 +0000 Subject: r13877: remove smbsrv_send_dos_error() and use smbsrv_send_error(..,NT_STATUS_DOS()) metze (This used to be commit 60d7920527cd0e4142427fa59b9e617d99e3d984) --- source4/smb_server/smb/reply.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 0da61ef253..9aad3ef015 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -33,7 +33,7 @@ if ((req)->in.wct != (wcount)) { \ DEBUG(1,("Unexpected WCT %d at %s(%d) - expected %d\n", \ (req)->in.wct, __FILE__, __LINE__, wcount)); \ - smbsrv_send_dos_error(req, ERRSRV, ERRerror); \ + smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRerror)); \ return; \ }} while (0) @@ -200,7 +200,7 @@ void smbsrv_reply_unknown(struct smbsrv_request *req) DEBUG(0,("unknown command type %d (0x%X)\n", type, type)); - smbsrv_send_dos_error(req, ERRSRV, ERRunknownsmb); + smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRunknownsmb)); } @@ -941,7 +941,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_writebraw(struct smbsrv_request *req) { - smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRuseSTD)); } @@ -1854,7 +1854,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) void smbsrv_reply_readbmpx(struct smbsrv_request *req) { /* tell the client to not use a multiplexed read - its too broken to use */ - smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRuseSTD)); } @@ -1890,7 +1890,7 @@ void smbsrv_reply_setattrE(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_writebmpx(struct smbsrv_request *req) { - smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRuseSTD)); } @@ -1899,7 +1899,7 @@ void smbsrv_reply_writebmpx(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_writebs(struct smbsrv_request *req) { - smbsrv_send_dos_error(req, ERRSRV, ERRuseSTD); + smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRuseSTD)); } -- cgit From db45433f312fd03c58c9c9b3a924852700ef6113 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Wed, 8 Mar 2006 06:28:08 +0000 Subject: r14016: use type safe talloc when constructing operation structures in smb server (This used to be commit 78dd6b3e0cd4f048e9b0317107ceb59198fc2bee) --- source4/smb_server/smb/reply.c | 81 ++++++++++++++++++++++-------------------- 1 file changed, 43 insertions(+), 38 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 9aad3ef015..db4580bf5a 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -45,8 +45,8 @@ }} while (0) /* useful wrapper for talloc with NO_MEMORY reply */ -#define REQ_TALLOC(ptr, size) do { \ - ptr = talloc_size(req, size); \ +#define REQ_TALLOC(ptr, type) do { \ + ptr = talloc(req, type); \ if (!ptr) { \ smbsrv_send_error(req, NT_STATUS_NO_MEMORY); \ return; \ @@ -233,7 +233,7 @@ void smbsrv_reply_ioctl(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 3); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_ioctl); io->ioctl.level = RAW_IOCTL_IOCTL; io->ioctl.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -257,7 +257,7 @@ void smbsrv_reply_chkpth(struct smbsrv_request *req) { struct smb_chkpath *io; - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, struct smb_chkpath); req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE); @@ -298,7 +298,7 @@ void smbsrv_reply_getatr(struct smbsrv_request *req) { union smb_fileinfo *st; - REQ_TALLOC(st, sizeof(*st)); + REQ_TALLOC(st, union smb_fileinfo); st->getattr.level = RAW_FILEINFO_GETATTR; @@ -329,7 +329,7 @@ void smbsrv_reply_setatr(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 8); - REQ_TALLOC(st, sizeof(*st)); + REQ_TALLOC(st, union smb_setfileinfo); st->setattr.level = RAW_SFILEINFO_SETATTR; st->setattr.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -382,7 +382,7 @@ void smbsrv_reply_dskattr(struct smbsrv_request *req) { union smb_fsinfo *fs; - REQ_TALLOC(fs, sizeof(*fs)); + REQ_TALLOC(fs, union smb_fsinfo); fs->dskattr.level = RAW_QFS_DSKATTR; @@ -428,7 +428,7 @@ void smbsrv_reply_open(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 2); - REQ_TALLOC(oi, sizeof(*oi)); + REQ_TALLOC(oi, union smb_open); oi->openold.level = RAW_OPEN_OPEN; oi->openold.in.open_mode = SVAL(req->in.vwv, VWV(0)); @@ -500,7 +500,7 @@ void smbsrv_reply_open_and_X(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 15); - REQ_TALLOC(oi, sizeof(*oi)); + REQ_TALLOC(oi, union smb_open); oi->openx.level = RAW_OPEN_OPENX; oi->openx.in.flags = SVAL(req->in.vwv, VWV(2)); @@ -557,7 +557,7 @@ void smbsrv_reply_mknew(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 3); - REQ_TALLOC(oi, sizeof(*oi)); + REQ_TALLOC(oi, union smb_open); if (CVAL(req->in.hdr, HDR_COM) == SMBmknew) { oi->mknew.level = RAW_OPEN_MKNEW; @@ -613,7 +613,7 @@ void smbsrv_reply_ctemp(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 3); - REQ_TALLOC(oi, sizeof(*oi)); + REQ_TALLOC(oi, union smb_open); oi->ctemp.level = RAW_OPEN_CTEMP; oi->ctemp.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -648,7 +648,7 @@ void smbsrv_reply_unlink(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 1); - REQ_TALLOC(unl, sizeof(*unl)); + REQ_TALLOC(unl, struct smb_unlink); unl->in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -763,7 +763,7 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_read); io->lockread.level = RAW_READ_LOCKREAD; io->lockread.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -822,7 +822,7 @@ void smbsrv_reply_read(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_read); io->read.level = RAW_READ_READ; io->read.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -892,7 +892,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) REQ_CHECK_WCT(req, 10); } - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_read); io->readx.level = RAW_READ_READX; io->readx.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); @@ -970,7 +970,7 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) union smb_write *io; REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_write); io->writeunlock.level = RAW_WRITE_WRITEUNLOCK; io->writeunlock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1028,7 +1028,7 @@ void smbsrv_reply_write(struct smbsrv_request *req) union smb_write *io; REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_write); io->write.level = RAW_WRITE_WRITE; io->write.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1093,7 +1093,7 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) REQ_CHECK_WCT(req, 12); } - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_write); io->writex.level = RAW_WRITE_WRITEX; io->writex.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); @@ -1152,7 +1152,7 @@ void smbsrv_reply_lseek(struct smbsrv_request *req) struct smb_seek *io; REQ_CHECK_WCT(req, 4); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, struct smb_seek); io->in.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->in.mode = SVAL(req->in.vwv, VWV(1)); @@ -1177,7 +1177,7 @@ void smbsrv_reply_flush(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 1); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, struct smb_flush); io->in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1226,7 +1226,7 @@ void smbsrv_reply_close(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 3); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_close); io->close.level = RAW_CLOSE_CLOSE; io->close.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1272,7 +1272,7 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) REQ_CHECK_WCT(req, 6); } - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_write); io->writeclose.level = RAW_WRITE_WRITECLOSE; io->writeclose.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1306,7 +1306,7 @@ void smbsrv_reply_lock(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 5); - REQ_TALLOC(lck, sizeof(*lck)); + REQ_TALLOC(lck, union smb_lock); lck->lock.level = RAW_LOCK_LOCK; lck->lock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1332,7 +1332,7 @@ void smbsrv_reply_unlock(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 5); - REQ_TALLOC(lck, sizeof(*lck)); + REQ_TALLOC(lck, union smb_lock); lck->unlock.level = RAW_LOCK_UNLOCK; lck->unlock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1429,7 +1429,7 @@ void smbsrv_reply_printopen(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 2); - REQ_TALLOC(oi, sizeof(*oi)); + REQ_TALLOC(oi, union smb_open); oi->splopen.level = RAW_OPEN_SPLOPEN; oi->splopen.in.setup_length = SVAL(req->in.vwv, VWV(0)); @@ -1456,7 +1456,7 @@ void smbsrv_reply_printclose(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 3); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_close); io->splclose.level = RAW_CLOSE_SPLCLOSE; io->splclose.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1524,7 +1524,7 @@ void smbsrv_reply_printqueue(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 2); - REQ_TALLOC(lpq, sizeof(*lpq)); + REQ_TALLOC(lpq, union smb_lpq); lpq->retq.level = RAW_LPQ_RETQ; lpq->retq.in.maxcount = SVAL(req->in.vwv, VWV(0)); @@ -1550,7 +1550,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 1); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_write); io->splwrite.level = RAW_WRITE_SPLWRITE; @@ -1588,7 +1588,7 @@ void smbsrv_reply_mkdir(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 0); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_mkdir); io->generic.level = RAW_MKDIR_MKDIR; req_pull_ascii4(req, &io->mkdir.in.path, req->in.data, STR_TERMINATE); @@ -1612,7 +1612,7 @@ void smbsrv_reply_rmdir(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 0); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, struct smb_rmdir); req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE); @@ -1636,7 +1636,7 @@ void smbsrv_reply_mv(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 1); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_rename); io->generic.level = RAW_RENAME_RENAME; io->rename.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -1670,7 +1670,7 @@ void smbsrv_reply_ntrename(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 4); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_rename); io->generic.level = RAW_RENAME_NTRENAME; io->ntrename.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -1722,7 +1722,7 @@ void smbsrv_reply_copy(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 3); - REQ_TALLOC(cp, sizeof(*cp)); + REQ_TALLOC(cp, struct smb_copy); cp->in.tid2 = SVAL(req->in.vwv, VWV(0)); cp->in.ofun = SVAL(req->in.vwv, VWV(1)); @@ -1785,7 +1785,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 8); - REQ_TALLOC(lck, sizeof(*lck)); + REQ_TALLOC(lck, union smb_lock); lck->lockx.level = RAW_LOCK_LOCKX; lck->lockx.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); @@ -1811,7 +1811,12 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) /* allocate the locks array */ if (total_locks) { - REQ_TALLOC(lck->lockx.in.locks, total_locks * sizeof(lck->lockx.in.locks[0])); + lck->lockx.in.locks = talloc_array(req, struct smb_lock_entry, + total_locks); + if (lck->lockx.in.locks == NULL) { + smbsrv_send_error(req, NT_STATUS_NO_MEMORY); + return; + } } p = req->in.data; @@ -1867,7 +1872,7 @@ void smbsrv_reply_setattrE(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 7); - REQ_TALLOC(info, sizeof(*info)); + REQ_TALLOC(info, union smb_setfileinfo); info->setattre.level = RAW_SFILEINFO_SETATTRE; info->setattre.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1935,7 +1940,7 @@ void smbsrv_reply_getattrE(struct smbsrv_request *req) /* parse request */ REQ_CHECK_WCT(req, 1); - REQ_TALLOC(info, sizeof(*info)); + REQ_TALLOC(info, union smb_fileinfo); info->getattr.level = RAW_FILEINFO_GETATTRE; info->getattr.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -2287,7 +2292,7 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) /* parse the request */ REQ_CHECK_WCT(req, 24); - REQ_TALLOC(io, sizeof(*io)); + REQ_TALLOC(io, union smb_open); io->ntcreatex.level = RAW_OPEN_NTCREATEX; -- cgit From 86497db6113c4ec3210d671c3fcf957d1026098c Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 10 Mar 2006 14:31:17 +0000 Subject: r14157: - pass a struct ntvfs_request to the ntvfs layer (for now we just do #define ntvfs_request smbsrv_request, but it's the first step...) - rename ntvfs_openfile() -> ntvfs_open() - fix the talloc hierachie in some places in the ntvfs_map_*() code metze (This used to be commit ed9ed1f48f602354810937c0b0de850b44322191) --- source4/smb_server/smb/reply.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index db4580bf5a..93697afd4a 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -446,7 +446,7 @@ void smbsrv_reply_open(struct smbsrv_request *req) req->async_states->private_data = oi; /* call backend */ - req->async_states->status = ntvfs_openfile(req, oi); + req->async_states->status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -524,7 +524,7 @@ void smbsrv_reply_open_and_X(struct smbsrv_request *req) req->async_states->private_data = oi; /* call the backend */ - req->async_states->status = ntvfs_openfile(req, oi); + req->async_states->status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -579,7 +579,7 @@ void smbsrv_reply_mknew(struct smbsrv_request *req) req->async_states->private_data = oi; /* call the backend */ - req->async_states->status = ntvfs_openfile(req, oi); + req->async_states->status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -633,7 +633,7 @@ void smbsrv_reply_ctemp(struct smbsrv_request *req) req->async_states->private_data = oi; /* call the backend */ - req->async_states->status = ntvfs_openfile(req, oi); + req->async_states->status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -1442,7 +1442,7 @@ void smbsrv_reply_printopen(struct smbsrv_request *req) req->async_states->private_data = oi; /* call backend */ - req->async_states->status = ntvfs_openfile(req, oi); + req->async_states->status = ntvfs_open(req, oi); REQ_ASYNC_TAIL; } @@ -2328,7 +2328,7 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) req->async_states->private_data = io; /* call the backend */ - req->async_states->status = ntvfs_openfile(req, io); + req->async_states->status = ntvfs_open(req, io); REQ_ASYNC_TAIL; } -- cgit From 307e43bb5628e8b53a930c2928279af994281ba5 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 10 Mar 2006 20:49:20 +0000 Subject: r14173: change smb interface structures to always use a union smb_file, to abtract - const char *path fot qpathinfo and setpathinfo - uint16_t fnum for SMB - smb2_handle handle for SMB2 the idea is to later add a struct ntvfs_handle *ntvfs so that the ntvfs subsystem don't need to know the difference between SMB and SMB2 metze (This used to be commit 2ef3f5970901b5accdb50f0d0115b5d46b0c788f) --- source4/smb_server/smb/reply.c | 94 +++++++++++++++++++++--------------------- 1 file changed, 47 insertions(+), 47 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 93697afd4a..d4c98ab416 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -236,7 +236,7 @@ void smbsrv_reply_ioctl(struct smbsrv_request *req) REQ_TALLOC(io, union smb_ioctl); io->ioctl.level = RAW_IOCTL_IOCTL; - io->ioctl.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->ioctl.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->ioctl.in.request = IVAL(req->in.vwv, VWV(1)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; @@ -255,11 +255,11 @@ void smbsrv_reply_ioctl(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_chkpth(struct smbsrv_request *req) { - struct smb_chkpath *io; + union smb_chkpath *io; - REQ_TALLOC(io, struct smb_chkpath); + REQ_TALLOC(io, union smb_chkpath); - req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE); + req_pull_ascii4(req, &io->chkpath.in.path, req->in.data, STR_TERMINATE); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -303,8 +303,8 @@ void smbsrv_reply_getatr(struct smbsrv_request *req) st->getattr.level = RAW_FILEINFO_GETATTR; /* parse request */ - req_pull_ascii4(req, &st->getattr.in.fname, req->in.data, STR_TERMINATE); - if (!st->getattr.in.fname) { + req_pull_ascii4(req, &st->getattr.file.path, req->in.data, STR_TERMINATE); + if (!st->getattr.file.path) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -335,9 +335,9 @@ void smbsrv_reply_setatr(struct smbsrv_request *req) st->setattr.in.attrib = SVAL(req->in.vwv, VWV(0)); st->setattr.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1)); - req_pull_ascii4(req, &st->setattr.file.fname, req->in.data, STR_TERMINATE); + req_pull_ascii4(req, &st->setattr.file.path, req->in.data, STR_TERMINATE); - if (!st->setattr.file.fname) { + if (!st->setattr.file.path) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -410,7 +410,7 @@ static void reply_open_send(struct smbsrv_request *req) /* construct reply */ smbsrv_setup_reply(req, 7, 0); - SSVAL(req->out.vwv, VWV(0), oi->openold.out.fnum); + SSVAL(req->out.vwv, VWV(0), oi->openold.file.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); @@ -470,7 +470,7 @@ static void reply_open_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); - SSVAL(req->out.vwv, VWV(2), oi->openx.out.fnum); + SSVAL(req->out.vwv, VWV(2), oi->openx.file.fnum); SSVAL(req->out.vwv, VWV(3), oi->openx.out.attrib); srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(4), oi->openx.out.write_time); SIVAL(req->out.vwv, VWV(6), oi->openx.out.size); @@ -485,7 +485,7 @@ static void reply_open_and_X_send(struct smbsrv_request *req) REQ_VWV_RESERVED(17, 2); } - req->chained_fnum = oi->openx.out.fnum; + req->chained_fnum = oi->openx.file.fnum; smbsrv_chain_reply(req); } @@ -542,7 +542,7 @@ static void reply_mknew_send(struct smbsrv_request *req) /* build the reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->mknew.out.fnum); + SSVAL(req->out.vwv, VWV(0), oi->mknew.file.fnum); smbsrv_send_reply(req); } @@ -596,7 +596,7 @@ static void reply_ctemp_send(struct smbsrv_request *req) /* build the reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->ctemp.out.fnum); + SSVAL(req->out.vwv, VWV(0), oi->ctemp.file.fnum); /* the returned filename is relative to the directory */ req_push_str(req, NULL, oi->ctemp.out.name, -1, STR_TERMINATE | STR_ASCII); @@ -644,15 +644,15 @@ void smbsrv_reply_ctemp(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_unlink(struct smbsrv_request *req) { - struct smb_unlink *unl; + union smb_unlink *unl; /* parse the request */ REQ_CHECK_WCT(req, 1); - REQ_TALLOC(unl, struct smb_unlink); + REQ_TALLOC(unl, union smb_unlink); - unl->in.attrib = SVAL(req->in.vwv, VWV(0)); + unl->unlink.in.attrib = SVAL(req->in.vwv, VWV(0)); - req_pull_ascii4(req, &unl->in.pattern, req->in.data, STR_TERMINATE); + req_pull_ascii4(req, &unl->unlink.in.pattern, req->in.data, STR_TERMINATE); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -682,7 +682,7 @@ void smbsrv_reply_readbraw(struct smbsrv_request *req) goto failed; } - io.readbraw.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io.readbraw.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io.readbraw.in.offset = IVAL(req->in.vwv, VWV(1)); io.readbraw.in.maxcnt = SVAL(req->in.vwv, VWV(3)); io.readbraw.in.mincnt = SVAL(req->in.vwv, VWV(4)); @@ -766,7 +766,7 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) REQ_TALLOC(io, union smb_read); io->lockread.level = RAW_READ_LOCKREAD; - io->lockread.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->lockread.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->lockread.in.count = SVAL(req->in.vwv, VWV(1)); io->lockread.in.offset = IVAL(req->in.vwv, VWV(2)); io->lockread.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -825,7 +825,7 @@ void smbsrv_reply_read(struct smbsrv_request *req) REQ_TALLOC(io, union smb_read); io->read.level = RAW_READ_READ; - io->read.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->read.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->read.in.count = SVAL(req->in.vwv, VWV(1)); io->read.in.offset = IVAL(req->in.vwv, VWV(2)); io->read.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -895,7 +895,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) REQ_TALLOC(io, union smb_read); io->readx.level = RAW_READ_READX; - io->readx.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->readx.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); io->readx.in.offset = IVAL(req->in.vwv, VWV(3)); io->readx.in.maxcnt = SVAL(req->in.vwv, VWV(5)); io->readx.in.mincnt = SVAL(req->in.vwv, VWV(6)); @@ -973,7 +973,7 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->writeunlock.level = RAW_WRITE_WRITEUNLOCK; - io->writeunlock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->writeunlock.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->writeunlock.in.count = SVAL(req->in.vwv, VWV(1)); io->writeunlock.in.offset = IVAL(req->in.vwv, VWV(2)); io->writeunlock.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -1031,7 +1031,7 @@ void smbsrv_reply_write(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->write.level = RAW_WRITE_WRITE; - io->write.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->write.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->write.in.count = SVAL(req->in.vwv, VWV(1)); io->write.in.offset = IVAL(req->in.vwv, VWV(2)); io->write.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -1096,7 +1096,7 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->writex.level = RAW_WRITE_WRITEX; - io->writex.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->writex.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); io->writex.in.offset = IVAL(req->in.vwv, VWV(3)); io->writex.in.wmode = SVAL(req->in.vwv, VWV(7)); io->writex.in.remaining = SVAL(req->in.vwv, VWV(8)); @@ -1132,14 +1132,14 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) ****************************************************************************/ static void reply_lseek_send(struct smbsrv_request *req) { - struct smb_seek *io = req->async_states->private_data; + union smb_seek *io = req->async_states->private_data; CHECK_ASYNC_STATUS; /* construct reply */ smbsrv_setup_reply(req, 2, 0); - SIVALS(req->out.vwv, VWV(0), io->out.offset); + SIVALS(req->out.vwv, VWV(0), io->lseek.out.offset); smbsrv_send_reply(req); } @@ -1149,14 +1149,14 @@ static void reply_lseek_send(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_lseek(struct smbsrv_request *req) { - struct smb_seek *io; + union smb_seek *io; REQ_CHECK_WCT(req, 4); - REQ_TALLOC(io, struct smb_seek); + REQ_TALLOC(io, union smb_seek); - io->in.fnum = req_fnum(req, req->in.vwv, VWV(0)); - io->in.mode = SVAL(req->in.vwv, VWV(1)); - io->in.offset = IVALS(req->in.vwv, VWV(2)); + io->lseek.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->lseek.in.mode = SVAL(req->in.vwv, VWV(1)); + io->lseek.in.offset = IVALS(req->in.vwv, VWV(2)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_lseek_send; @@ -1173,14 +1173,14 @@ void smbsrv_reply_lseek(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_flush(struct smbsrv_request *req) { - struct smb_flush *io; + union smb_flush *io; /* parse request */ REQ_CHECK_WCT(req, 1); - REQ_TALLOC(io, struct smb_flush); + REQ_TALLOC(io, union smb_flush); + + io->flush.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - io->in.fnum = req_fnum(req, req->in.vwv, VWV(0)); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -1229,7 +1229,7 @@ void smbsrv_reply_close(struct smbsrv_request *req) REQ_TALLOC(io, union smb_close); io->close.level = RAW_CLOSE_CLOSE; - io->close.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->close.file.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_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; @@ -1275,7 +1275,7 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->writeclose.level = RAW_WRITE_WRITECLOSE; - io->writeclose.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->writeclose.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->writeclose.in.count = SVAL(req->in.vwv, VWV(1)); io->writeclose.in.offset = IVAL(req->in.vwv, VWV(2)); io->writeclose.in.mtime = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(4)); @@ -1309,7 +1309,7 @@ void smbsrv_reply_lock(struct smbsrv_request *req) REQ_TALLOC(lck, union smb_lock); lck->lock.level = RAW_LOCK_LOCK; - lck->lock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->lock.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); lck->lock.in.count = IVAL(req->in.vwv, VWV(1)); lck->lock.in.offset = IVAL(req->in.vwv, VWV(3)); @@ -1335,7 +1335,7 @@ void smbsrv_reply_unlock(struct smbsrv_request *req) REQ_TALLOC(lck, union smb_lock); lck->unlock.level = RAW_LOCK_UNLOCK; - lck->unlock.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->unlock.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); lck->unlock.in.count = IVAL(req->in.vwv, VWV(1)); lck->unlock.in.offset = IVAL(req->in.vwv, VWV(3)); @@ -1415,7 +1415,7 @@ static void reply_printopen_send(struct smbsrv_request *req) /* construct reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->openold.out.fnum); + SSVAL(req->out.vwv, VWV(0), oi->openold.file.fnum); smbsrv_send_reply(req); } @@ -1459,7 +1459,7 @@ void smbsrv_reply_printclose(struct smbsrv_request *req) REQ_TALLOC(io, union smb_close); io->splclose.level = RAW_CLOSE_SPLCLOSE; - io->splclose.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->splclose.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -1559,7 +1559,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) return; } - io->splwrite.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->splwrite.file.fnum= req_fnum(req, req->in.vwv, VWV(0)); io->splwrite.in.count = SVAL(req->in.data, 1); io->splwrite.in.data = req->in.data + 3; @@ -1788,7 +1788,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) REQ_TALLOC(lck, union smb_lock); lck->lockx.level = RAW_LOCK_LOCKX; - lck->lockx.in.fnum = req_fnum(req, req->in.vwv, VWV(2)); + lck->lockx.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); lck->lockx.in.mode = SVAL(req->in.vwv, VWV(3)); lck->lockx.in.timeout = IVAL(req->in.vwv, VWV(4)); lck->lockx.in.ulock_cnt = SVAL(req->in.vwv, VWV(6)); @@ -1875,7 +1875,7 @@ void smbsrv_reply_setattrE(struct smbsrv_request *req) REQ_TALLOC(info, union smb_setfileinfo); info->setattre.level = RAW_SFILEINFO_SETATTRE; - info->setattre.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + info->setattre.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); info->setattre.in.create_time = srv_pull_dos_date2(req->smb_conn, req->in.vwv + VWV(1)); 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)); @@ -1943,7 +1943,7 @@ void smbsrv_reply_getattrE(struct smbsrv_request *req) REQ_TALLOC(info, union smb_fileinfo); info->getattr.level = RAW_FILEINFO_GETATTRE; - info->getattr.in.fnum = req_fnum(req, req->in.vwv, VWV(0)); + info->getattr.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_getattrE_send; @@ -2264,7 +2264,7 @@ static void reply_ntcreate_and_X_send(struct smbsrv_request *req) SCVAL(req->out.vwv, VWV(2), io->ntcreatex.out.oplock_level); /* the rest of the parameters are not aligned! */ - SSVAL(req->out.vwv, 5, io->ntcreatex.out.fnum); + SSVAL(req->out.vwv, 5, io->ntcreatex.file.fnum); SIVAL(req->out.vwv, 7, io->ntcreatex.out.create_action); push_nttime(req->out.vwv, 11, io->ntcreatex.out.create_time); push_nttime(req->out.vwv, 19, io->ntcreatex.out.access_time); @@ -2277,7 +2277,7 @@ static void reply_ntcreate_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, 65, io->ntcreatex.out.ipc_state); SCVAL(req->out.vwv, 67, io->ntcreatex.out.is_directory); - req->chained_fnum = io->ntcreatex.out.fnum; + req->chained_fnum = io->ntcreatex.file.fnum; smbsrv_chain_reply(req); } -- cgit From 7f0c7702f6b9db216fcd6c29165b2a11ea1f24a9 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Sat, 11 Mar 2006 12:58:36 +0000 Subject: r14208: removed use of req->flags2 inside the ntvfs layer. This should help metze on his quest to unify the ntvfs strucures for the smb and smb2 servers. The only place we needed flags2 inside ntvfs was for the FLAGS2_READ_PERMIT_EXECUTE bit, which only affects readx, so I added a readx.in.read_for_execute flag instead. (This used to be commit b78abbbce60ab0009da19a72dd769800c44298a2) --- source4/smb_server/smb/reply.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index d4c98ab416..8b6dedb81a 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -900,6 +900,11 @@ void smbsrv_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->flags2 & FLAGS2_READ_PERMIT_EXECUTE) { + io->readx.in.read_for_execute = True; + } else { + io->readx.in.read_for_execute = False; + } if (req->smb_conn->negotiate.client_caps & CAP_LARGE_READX) { uint32_t high_part = IVAL(req->in.vwv, VWV(7)); -- cgit From a1b295ed4823ce8d06f830b8db9a5d965c934b54 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sun, 12 Mar 2006 22:48:25 +0000 Subject: r14256: - rename smb_file -> smb_handle - move it into the in/out substructs again - allow file.path only on smb_fileinfo/smb_setfileinfo metze (This used to be commit be6d5298a2cdb7e7c61d70471bad445645af5963) --- source4/smb_server/smb/reply.c | 82 +++++++++++++++++++++--------------------- 1 file changed, 41 insertions(+), 41 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 8b6dedb81a..ac0ab1a166 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -235,9 +235,9 @@ void smbsrv_reply_ioctl(struct smbsrv_request *req) REQ_CHECK_WCT(req, 3); REQ_TALLOC(io, union smb_ioctl); - io->ioctl.level = RAW_IOCTL_IOCTL; - io->ioctl.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - io->ioctl.in.request = IVAL(req->in.vwv, VWV(1)); + io->ioctl.level = RAW_IOCTL_IOCTL; + io->ioctl.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->ioctl.in.request = IVAL(req->in.vwv, VWV(1)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_ioctl_send; @@ -303,8 +303,8 @@ void smbsrv_reply_getatr(struct smbsrv_request *req) st->getattr.level = RAW_FILEINFO_GETATTR; /* parse request */ - req_pull_ascii4(req, &st->getattr.file.path, req->in.data, STR_TERMINATE); - if (!st->getattr.file.path) { + req_pull_ascii4(req, &st->getattr.in.file.path, req->in.data, STR_TERMINATE); + if (!st->getattr.in.file.path) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -335,9 +335,9 @@ void smbsrv_reply_setatr(struct smbsrv_request *req) st->setattr.in.attrib = SVAL(req->in.vwv, VWV(0)); st->setattr.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1)); - req_pull_ascii4(req, &st->setattr.file.path, req->in.data, STR_TERMINATE); + req_pull_ascii4(req, &st->setattr.in.file.path, req->in.data, STR_TERMINATE); - if (!st->setattr.file.path) { + if (!st->setattr.in.file.path) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; } @@ -410,7 +410,7 @@ static void reply_open_send(struct smbsrv_request *req) /* construct reply */ smbsrv_setup_reply(req, 7, 0); - SSVAL(req->out.vwv, VWV(0), oi->openold.file.fnum); + SSVAL(req->out.vwv, VWV(0), oi->openold.out.file.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); @@ -470,7 +470,7 @@ static void reply_open_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); - SSVAL(req->out.vwv, VWV(2), oi->openx.file.fnum); + SSVAL(req->out.vwv, VWV(2), oi->openx.out.file.fnum); SSVAL(req->out.vwv, VWV(3), oi->openx.out.attrib); srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(4), oi->openx.out.write_time); SIVAL(req->out.vwv, VWV(6), oi->openx.out.size); @@ -485,7 +485,7 @@ static void reply_open_and_X_send(struct smbsrv_request *req) REQ_VWV_RESERVED(17, 2); } - req->chained_fnum = oi->openx.file.fnum; + req->chained_fnum = oi->openx.out.file.fnum; smbsrv_chain_reply(req); } @@ -542,7 +542,7 @@ static void reply_mknew_send(struct smbsrv_request *req) /* build the reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->mknew.file.fnum); + SSVAL(req->out.vwv, VWV(0), oi->mknew.out.file.fnum); smbsrv_send_reply(req); } @@ -596,7 +596,7 @@ static void reply_ctemp_send(struct smbsrv_request *req) /* build the reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->ctemp.file.fnum); + SSVAL(req->out.vwv, VWV(0), oi->ctemp.out.file.fnum); /* the returned filename is relative to the directory */ req_push_str(req, NULL, oi->ctemp.out.name, -1, STR_TERMINATE | STR_ASCII); @@ -682,7 +682,7 @@ void smbsrv_reply_readbraw(struct smbsrv_request *req) goto failed; } - io.readbraw.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io.readbraw.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io.readbraw.in.offset = IVAL(req->in.vwv, VWV(1)); io.readbraw.in.maxcnt = SVAL(req->in.vwv, VWV(3)); io.readbraw.in.mincnt = SVAL(req->in.vwv, VWV(4)); @@ -766,7 +766,7 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) REQ_TALLOC(io, union smb_read); io->lockread.level = RAW_READ_LOCKREAD; - io->lockread.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->lockread.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->lockread.in.count = SVAL(req->in.vwv, VWV(1)); io->lockread.in.offset = IVAL(req->in.vwv, VWV(2)); io->lockread.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -825,7 +825,7 @@ void smbsrv_reply_read(struct smbsrv_request *req) REQ_TALLOC(io, union smb_read); io->read.level = RAW_READ_READ; - io->read.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->read.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->read.in.count = SVAL(req->in.vwv, VWV(1)); io->read.in.offset = IVAL(req->in.vwv, VWV(2)); io->read.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -895,7 +895,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) REQ_TALLOC(io, union smb_read); io->readx.level = RAW_READ_READX; - io->readx.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->readx.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); io->readx.in.offset = IVAL(req->in.vwv, VWV(3)); io->readx.in.maxcnt = SVAL(req->in.vwv, VWV(5)); io->readx.in.mincnt = SVAL(req->in.vwv, VWV(6)); @@ -978,7 +978,7 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->writeunlock.level = RAW_WRITE_WRITEUNLOCK; - io->writeunlock.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->writeunlock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->writeunlock.in.count = SVAL(req->in.vwv, VWV(1)); io->writeunlock.in.offset = IVAL(req->in.vwv, VWV(2)); io->writeunlock.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -1036,7 +1036,7 @@ void smbsrv_reply_write(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->write.level = RAW_WRITE_WRITE; - io->write.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->write.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->write.in.count = SVAL(req->in.vwv, VWV(1)); io->write.in.offset = IVAL(req->in.vwv, VWV(2)); io->write.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -1101,7 +1101,7 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->writex.level = RAW_WRITE_WRITEX; - io->writex.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->writex.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); io->writex.in.offset = IVAL(req->in.vwv, VWV(3)); io->writex.in.wmode = SVAL(req->in.vwv, VWV(7)); io->writex.in.remaining = SVAL(req->in.vwv, VWV(8)); @@ -1159,9 +1159,9 @@ void smbsrv_reply_lseek(struct smbsrv_request *req) REQ_CHECK_WCT(req, 4); REQ_TALLOC(io, union smb_seek); - io->lseek.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - io->lseek.in.mode = SVAL(req->in.vwv, VWV(1)); - io->lseek.in.offset = IVALS(req->in.vwv, VWV(2)); + io->lseek.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->lseek.in.mode = SVAL(req->in.vwv, VWV(1)); + io->lseek.in.offset = IVALS(req->in.vwv, VWV(2)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_lseek_send; @@ -1184,7 +1184,7 @@ void smbsrv_reply_flush(struct smbsrv_request *req) REQ_CHECK_WCT(req, 1); REQ_TALLOC(io, union smb_flush); - io->flush.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->flush.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -1234,7 +1234,7 @@ void smbsrv_reply_close(struct smbsrv_request *req) REQ_TALLOC(io, union smb_close); io->close.level = RAW_CLOSE_CLOSE; - io->close.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->close.in.file.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_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; @@ -1280,7 +1280,7 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) REQ_TALLOC(io, union smb_write); io->writeclose.level = RAW_WRITE_WRITECLOSE; - io->writeclose.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->writeclose.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->writeclose.in.count = SVAL(req->in.vwv, VWV(1)); io->writeclose.in.offset = IVAL(req->in.vwv, VWV(2)); io->writeclose.in.mtime = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(4)); @@ -1313,10 +1313,10 @@ void smbsrv_reply_lock(struct smbsrv_request *req) REQ_CHECK_WCT(req, 5); REQ_TALLOC(lck, union smb_lock); - lck->lock.level = RAW_LOCK_LOCK; - lck->lock.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - lck->lock.in.count = IVAL(req->in.vwv, VWV(1)); - lck->lock.in.offset = IVAL(req->in.vwv, VWV(3)); + lck->lock.level = RAW_LOCK_LOCK; + lck->lock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->lock.in.count = IVAL(req->in.vwv, VWV(1)); + lck->lock.in.offset = IVAL(req->in.vwv, VWV(3)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -1339,10 +1339,10 @@ void smbsrv_reply_unlock(struct smbsrv_request *req) REQ_CHECK_WCT(req, 5); REQ_TALLOC(lck, union smb_lock); - lck->unlock.level = RAW_LOCK_UNLOCK; - lck->unlock.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - lck->unlock.in.count = IVAL(req->in.vwv, VWV(1)); - lck->unlock.in.offset = IVAL(req->in.vwv, VWV(3)); + lck->unlock.level = RAW_LOCK_UNLOCK; + lck->unlock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->unlock.in.count = IVAL(req->in.vwv, VWV(1)); + lck->unlock.in.offset = IVAL(req->in.vwv, VWV(3)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -1420,7 +1420,7 @@ static void reply_printopen_send(struct smbsrv_request *req) /* construct reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->openold.file.fnum); + SSVAL(req->out.vwv, VWV(0), oi->openold.out.file.fnum); smbsrv_send_reply(req); } @@ -1464,7 +1464,7 @@ void smbsrv_reply_printclose(struct smbsrv_request *req) REQ_TALLOC(io, union smb_close); io->splclose.level = RAW_CLOSE_SPLCLOSE; - io->splclose.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->splclose.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_simple_send; @@ -1564,7 +1564,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) return; } - io->splwrite.file.fnum= req_fnum(req, req->in.vwv, VWV(0)); + io->splwrite.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->splwrite.in.count = SVAL(req->in.data, 1); io->splwrite.in.data = req->in.data + 3; @@ -1793,7 +1793,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) REQ_TALLOC(lck, union smb_lock); lck->lockx.level = RAW_LOCK_LOCKX; - lck->lockx.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); + lck->lockx.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); lck->lockx.in.mode = SVAL(req->in.vwv, VWV(3)); lck->lockx.in.timeout = IVAL(req->in.vwv, VWV(4)); lck->lockx.in.ulock_cnt = SVAL(req->in.vwv, VWV(6)); @@ -1880,7 +1880,7 @@ void smbsrv_reply_setattrE(struct smbsrv_request *req) REQ_TALLOC(info, union smb_setfileinfo); info->setattre.level = RAW_SFILEINFO_SETATTRE; - info->setattre.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + info->setattre.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); info->setattre.in.create_time = srv_pull_dos_date2(req->smb_conn, req->in.vwv + VWV(1)); 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)); @@ -1948,7 +1948,7 @@ void smbsrv_reply_getattrE(struct smbsrv_request *req) REQ_TALLOC(info, union smb_fileinfo); info->getattr.level = RAW_FILEINFO_GETATTRE; - info->getattr.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + info->getattr.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; req->async_states->send_fn = reply_getattrE_send; @@ -2269,7 +2269,7 @@ static void reply_ntcreate_and_X_send(struct smbsrv_request *req) SCVAL(req->out.vwv, VWV(2), io->ntcreatex.out.oplock_level); /* the rest of the parameters are not aligned! */ - SSVAL(req->out.vwv, 5, io->ntcreatex.file.fnum); + SSVAL(req->out.vwv, 5, io->ntcreatex.out.file.fnum); SIVAL(req->out.vwv, 7, io->ntcreatex.out.create_action); push_nttime(req->out.vwv, 11, io->ntcreatex.out.create_time); push_nttime(req->out.vwv, 19, io->ntcreatex.out.access_time); @@ -2282,7 +2282,7 @@ static void reply_ntcreate_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, 65, io->ntcreatex.out.ipc_state); SCVAL(req->out.vwv, 67, io->ntcreatex.out.is_directory); - req->chained_fnum = io->ntcreatex.file.fnum; + req->chained_fnum = io->ntcreatex.out.file.fnum; smbsrv_chain_reply(req); } -- cgit From 8528016978b084213ef53d66e1b6e831b1a01acc Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 16 Mar 2006 00:23:11 +0000 Subject: r14464: Don't include ndr_BASENAME.h files unless strictly required, instead try to include just the BASENAME.h files (containing only structs) (This used to be commit 3dd477ca5147f28a962b8437e2611a8222d706bd) --- source4/smb_server/smb/reply.c | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index ac0ab1a166..00589ce501 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -26,6 +26,7 @@ #include "includes.h" #include "smb_server/smb_server.h" #include "ntvfs/ntvfs.h" +#include "librpc/gen_ndr/ndr_nbt.h" /* useful way of catching wct errors with file and line number */ -- cgit From 3948fcac493ed131bc40358138e8dc17a58853f7 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Mar 2006 18:26:14 +0000 Subject: r14485: mark smb commands as need session and need tcon explicit, so we only need to check in one global place and can't forget in other places... metze (This used to be commit 742be8e075651c3b7e502ec6da01286fd7a2d4ca) --- source4/smb_server/smb/reply.c | 43 ------------------------------------------ 1 file changed, 43 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 00589ce501..cc625b6d03 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1362,11 +1362,6 @@ void smbsrv_reply_tdis(struct smbsrv_request *req) { REQ_CHECK_WCT(req, 0); - if (req->tcon == NULL) { - smbsrv_send_error(req, NT_STATUS_INVALID_HANDLE); - return; - } - talloc_free(req->tcon); /* construct reply */ @@ -2185,11 +2180,6 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) struct smbsrv_tcon *tcon; NTSTATUS status; - if (!req->session) { - smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRbaduid)); - return; - } - /* in user level security we are supposed to close any files open by this user on all open tree connects */ for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { @@ -2350,39 +2340,6 @@ void smbsrv_reply_ntcancel(struct smbsrv_request *req) talloc_free(req); } -/**************************************************************************** - Reply to an SMBsends request -****************************************************************************/ -void smbsrv_reply_sends(struct smbsrv_request *req) -{ - smbsrv_send_error(req, NT_STATUS_FOOBAR); -} - -/**************************************************************************** - Reply to an SMBsendstrt request -****************************************************************************/ -void smbsrv_reply_sendstrt(struct smbsrv_request *req) -{ - smbsrv_send_error(req, NT_STATUS_FOOBAR); -} - -/**************************************************************************** - Reply to an SMBsendend request -****************************************************************************/ -void smbsrv_reply_sendend(struct smbsrv_request *req) -{ - smbsrv_send_error(req, NT_STATUS_FOOBAR); -} - -/**************************************************************************** - Reply to an SMBsendtxt request -****************************************************************************/ -void smbsrv_reply_sendtxt(struct smbsrv_request *req) -{ - smbsrv_send_error(req, NT_STATUS_FOOBAR); -} - - /* parse the called/calling names from session request */ -- cgit From d3087451c4ec25171ba956fe2cd4e1d0f64f7edc Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 16 Mar 2006 18:54:19 +0000 Subject: r14487: split smbsrv_request into two parts, one will be moved to ntvfs_request but I don't to get the commit to large, to I'll do this tomorrow... metze (This used to be commit 10e627032d7d04f1ebf6efed248c426614f5aa6f) --- source4/smb_server/smb/reply.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index cc625b6d03..7171618f8c 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1208,8 +1208,10 @@ void smbsrv_reply_exit(struct smbsrv_request *req) for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { req->tcon = tcon; +req->ctx = req->tcon->ntvfs; status = ntvfs_exit(req); req->tcon = NULL; +req->ctx = NULL; if (!NT_STATUS_IS_OK(status)) { smbsrv_send_error(req, status); return; -- cgit From bae6672ea9a06ee3772e5b7d86483b2eac291247 Mon Sep 17 00:00:00 2001 From: Andrew Bartlett Date: Fri, 17 Mar 2006 03:12:35 +0000 Subject: r14502: Supply both needed arguments for the backend logoff processing. This should fix the segfaults on the build farm. Metze: please check Andrew Bartlett (This used to be commit fb927a71173eba2bd33bbb9ea589b63f5e33b3f2) --- source4/smb_server/smb/reply.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 7171618f8c..244fd37af9 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -2186,8 +2186,10 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) open by this user on all open tree connects */ for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { req->tcon = tcon; + req->ctx = tcon->ntvfs; status = ntvfs_logoff(req); req->tcon = NULL; + req->ctx = NULL; if (!NT_STATUS_IS_OK(status)) { smbsrv_send_error(req, status); return; -- cgit From 61fa658ebcaf2856d543d376b120932ad5a082f0 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 18 Mar 2006 11:10:21 +0000 Subject: r14541: separate smbsrv_request and ntvfs_request, with this it's now possible to write a ntvfs_test programm like the vfstest in samba3 also smb2 support will be possible later metze (This used to be commit 7253153691e35cd206346fbd4e9b9f95c042f602) --- source4/smb_server/smb/reply.c | 756 +++++++++++++++-------------------------- 1 file changed, 273 insertions(+), 483 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 244fd37af9..65976fd385 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -29,49 +29,14 @@ #include "librpc/gen_ndr/ndr_nbt.h" -/* useful way of catching wct errors with file and line number */ -#define REQ_CHECK_WCT(req, wcount) do { \ - if ((req)->in.wct != (wcount)) { \ - DEBUG(1,("Unexpected WCT %d at %s(%d) - expected %d\n", \ - (req)->in.wct, __FILE__, __LINE__, wcount)); \ - smbsrv_send_error(req, NT_STATUS_DOS(ERRSRV, ERRerror)); \ - return; \ - }} while (0) - -/* 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_states->status)) { \ - smbsrv_send_error(req, req->async_states->status); \ - return; \ - }} while (0) - -/* useful wrapper for talloc with NO_MEMORY reply */ -#define REQ_TALLOC(ptr, type) do { \ - ptr = talloc(req, type); \ - if (!ptr) { \ - smbsrv_send_error(req, NT_STATUS_NO_MEMORY); \ - return; \ - }} while (0) - -/* - check if the backend wants to handle the request asynchronously. - if it wants it handled synchronously then call the send function - immediately -*/ -#define REQ_ASYNC_TAIL do { \ - 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 */ -#define REQ_VWV_RESERVED(start, count) memset(req->out.vwv + VWV(start), 0, (count)*2) - /**************************************************************************** Reply to a simple request (async send) ****************************************************************************/ -static void reply_simple_send(struct smbsrv_request *req) +static void reply_simple_send(struct ntvfs_request *ntvfs) { - CHECK_ASYNC_STATUS; + struct smbsrv_request *req; + + SMBSRV_CHECK_ASYNC_STATUS_SIMPLE; smbsrv_setup_reply(req, 0, 0); smbsrv_send_reply(req); @@ -88,7 +53,7 @@ void smbsrv_reply_tcon(struct smbsrv_request *req) uint8_t *p; /* parse request */ - REQ_CHECK_WCT(req, 0); + SMBSRV_CHECK_WCT(req, 0); con.tcon.level = RAW_TCON_TCON; @@ -134,7 +99,7 @@ void smbsrv_reply_tcon_and_X(struct smbsrv_request *req) con.tconx.level = RAW_TCON_TCONX; /* parse request */ - REQ_CHECK_WCT(req, 4); + SMBSRV_CHECK_WCT(req, 4); con.tconx.in.flags = SVAL(req->in.vwv, VWV(2)); passlen = SVAL(req->in.vwv, VWV(3)); @@ -208,11 +173,12 @@ void smbsrv_reply_unknown(struct smbsrv_request *req) /**************************************************************************** Reply to an ioctl (async reply) ****************************************************************************/ -static void reply_ioctl_send(struct smbsrv_request *req) +static void reply_ioctl_send(struct ntvfs_request *ntvfs) { - union smb_ioctl *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_ioctl *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_ioctl); /* the +1 is for nicer alignment */ smbsrv_setup_reply(req, 8, io->ioctl.out.blob.length+1); @@ -233,21 +199,16 @@ void smbsrv_reply_ioctl(struct smbsrv_request *req) union smb_ioctl *io; /* parse request */ - REQ_CHECK_WCT(req, 3); - REQ_TALLOC(io, union smb_ioctl); + SMBSRV_CHECK_WCT(req, 3); + SMBSRV_TALLOC_IO_PTR(io, union smb_ioctl); + SMBSRV_SETUP_NTVFS_REQUEST(reply_ioctl_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->ioctl.level = RAW_IOCTL_IOCTL; io->ioctl.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->ioctl.in.request = IVAL(req->in.vwv, VWV(1)); - 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_states->status = ntvfs_ioctl(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_ioctl(req->ntvfs, io)); } @@ -258,27 +219,24 @@ void smbsrv_reply_chkpth(struct smbsrv_request *req) { union smb_chkpath *io; - REQ_TALLOC(io, union smb_chkpath); + SMBSRV_TALLOC_IO_PTR(io, union smb_chkpath); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); req_pull_ascii4(req, &io->chkpath.in.path, req->in.data, STR_TERMINATE); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - req->async_states->status = ntvfs_chkpath(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_chkpath(req->ntvfs, io)); } /**************************************************************************** Reply to a getatr (async reply) ****************************************************************************/ -static void reply_getatr_send(struct smbsrv_request *req) +static void reply_getatr_send(struct ntvfs_request *ntvfs) { - union smb_fileinfo *st = req->async_states->private_data; + struct smbsrv_request *req; + union smb_fileinfo *st; + + SMBSRV_CHECK_ASYNC_STATUS(st, union smb_fileinfo); - CHECK_ASYNC_STATUS; - /* construct reply */ smbsrv_setup_reply(req, 10, 0); @@ -286,7 +244,7 @@ static void reply_getatr_send(struct smbsrv_request *req) srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(1), st->getattr.out.write_time); SIVAL(req->out.vwv, VWV(3), st->getattr.out.size); - REQ_VWV_RESERVED(5, 5); + SMBSRV_VWV_RESERVED(5, 5); smbsrv_send_reply(req); } @@ -299,7 +257,8 @@ void smbsrv_reply_getatr(struct smbsrv_request *req) { union smb_fileinfo *st; - REQ_TALLOC(st, union smb_fileinfo); + SMBSRV_TALLOC_IO_PTR(st, union smb_fileinfo); + SMBSRV_SETUP_NTVFS_REQUEST(reply_getatr_send, NTVFS_ASYNC_STATE_MAY_ASYNC); st->getattr.level = RAW_FILEINFO_GETATTR; @@ -310,14 +269,7 @@ void smbsrv_reply_getatr(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_qpathinfo(req, st); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_qpathinfo(req->ntvfs, st)); } @@ -329,8 +281,9 @@ void smbsrv_reply_setatr(struct smbsrv_request *req) union smb_setfileinfo *st; /* parse request */ - REQ_CHECK_WCT(req, 8); - REQ_TALLOC(st, union smb_setfileinfo); + SMBSRV_CHECK_WCT(req, 8); + SMBSRV_TALLOC_IO_PTR(st, union smb_setfileinfo); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); st->setattr.level = RAW_SFILEINFO_SETATTR; st->setattr.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -343,25 +296,20 @@ void smbsrv_reply_setatr(struct smbsrv_request *req) return; } - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_setpathinfo(req, st); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_setpathinfo(req->ntvfs, st)); } /**************************************************************************** Reply to a dskattr (async reply) ****************************************************************************/ -static void reply_dskattr_send(struct smbsrv_request *req) +static void reply_dskattr_send(struct ntvfs_request *ntvfs) { - union smb_fsinfo *fs = req->async_states->private_data; + struct smbsrv_request *req; + union smb_fsinfo *fs; + + SMBSRV_CHECK_ASYNC_STATUS(fs, union smb_fsinfo); - CHECK_ASYNC_STATUS; - /* construct reply */ smbsrv_setup_reply(req, 5, 0); @@ -370,7 +318,7 @@ static void reply_dskattr_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(2), fs->dskattr.out.block_size); SSVAL(req->out.vwv, VWV(3), fs->dskattr.out.units_free); - REQ_VWV_RESERVED(4, 1); + SMBSRV_VWV_RESERVED(4, 1); smbsrv_send_reply(req); } @@ -383,30 +331,24 @@ void smbsrv_reply_dskattr(struct smbsrv_request *req) { union smb_fsinfo *fs; - REQ_TALLOC(fs, union smb_fsinfo); + SMBSRV_TALLOC_IO_PTR(fs, union smb_fsinfo); + SMBSRV_SETUP_NTVFS_REQUEST(reply_dskattr_send, NTVFS_ASYNC_STATE_MAY_ASYNC); fs->dskattr.level = RAW_QFS_DSKATTR; - 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_states->status = ntvfs_fsinfo(req, fs); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_fsinfo(req->ntvfs, fs)); } - /**************************************************************************** Reply to an open (async reply) ****************************************************************************/ -static void reply_open_send(struct smbsrv_request *req) +static void reply_open_send(struct ntvfs_request *ntvfs) { - union smb_open *oi = req->async_states->private_data; + struct smbsrv_request *req; + union smb_open *oi; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(oi, union smb_open); /* construct reply */ smbsrv_setup_reply(req, 7, 0); @@ -428,8 +370,9 @@ void smbsrv_reply_open(struct smbsrv_request *req) union smb_open *oi; /* parse request */ - REQ_CHECK_WCT(req, 2); - REQ_TALLOC(oi, union smb_open); + SMBSRV_CHECK_WCT(req, 2); + SMBSRV_TALLOC_IO_PTR(oi, union smb_open); + SMBSRV_SETUP_NTVFS_REQUEST(reply_open_send, NTVFS_ASYNC_STATE_MAY_ASYNC); oi->openold.level = RAW_OPEN_OPEN; oi->openold.in.open_mode = SVAL(req->in.vwv, VWV(0)); @@ -442,25 +385,19 @@ void smbsrv_reply_open(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_open(req, oi); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, oi)); } /**************************************************************************** Reply to an open and X (async reply) ****************************************************************************/ -static void reply_open_and_X_send(struct smbsrv_request *req) +static void reply_open_and_X_send(struct ntvfs_request *ntvfs) { - union smb_open *oi = req->async_states->private_data; + struct smbsrv_request *req; + union smb_open *oi; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(oi, union smb_open); /* build the reply */ if (oi->openx.in.flags & OPENX_FLAGS_EXTENDED_RETURN) { @@ -483,7 +420,7 @@ static void reply_open_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(14),0); /* reserved */ if (oi->openx.in.flags & OPENX_FLAGS_EXTENDED_RETURN) { SIVAL(req->out.vwv, VWV(15),oi->openx.out.access_mask); - REQ_VWV_RESERVED(17, 2); + SMBSRV_VWV_RESERVED(17, 2); } req->chained_fnum = oi->openx.out.file.fnum; @@ -500,8 +437,9 @@ void smbsrv_reply_open_and_X(struct smbsrv_request *req) union smb_open *oi; /* parse the request */ - REQ_CHECK_WCT(req, 15); - REQ_TALLOC(oi, union smb_open); + SMBSRV_CHECK_WCT(req, 15); + SMBSRV_TALLOC_IO_PTR(oi, union smb_open); + SMBSRV_SETUP_NTVFS_REQUEST(reply_open_and_X_send, NTVFS_ASYNC_STATE_MAY_ASYNC); oi->openx.level = RAW_OPEN_OPENX; oi->openx.in.flags = SVAL(req->in.vwv, VWV(2)); @@ -520,25 +458,19 @@ void smbsrv_reply_open_and_X(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_open(req, oi); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, oi)); } /**************************************************************************** Reply to a mknew or a create. ****************************************************************************/ -static void reply_mknew_send(struct smbsrv_request *req) +static void reply_mknew_send(struct ntvfs_request *ntvfs) { - union smb_open *oi = req->async_states->private_data; + struct smbsrv_request *req; + union smb_open *oi; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(oi, union smb_open); /* build the reply */ smbsrv_setup_reply(req, 1, 0); @@ -557,8 +489,9 @@ void smbsrv_reply_mknew(struct smbsrv_request *req) union smb_open *oi; /* parse the request */ - REQ_CHECK_WCT(req, 3); - REQ_TALLOC(oi, union smb_open); + SMBSRV_CHECK_WCT(req, 3); + SMBSRV_TALLOC_IO_PTR(oi, union smb_open); + SMBSRV_SETUP_NTVFS_REQUEST(reply_mknew_send, NTVFS_ASYNC_STATE_MAY_ASYNC); if (CVAL(req->in.hdr, HDR_COM) == SMBmknew) { oi->mknew.level = RAW_OPEN_MKNEW; @@ -575,24 +508,18 @@ void smbsrv_reply_mknew(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_open(req, oi); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, oi)); } /**************************************************************************** Reply to a create temporary file (async reply) ****************************************************************************/ -static void reply_ctemp_send(struct smbsrv_request *req) +static void reply_ctemp_send(struct ntvfs_request *ntvfs) { - union smb_open *oi = req->async_states->private_data; + struct smbsrv_request *req; + union smb_open *oi; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(oi, union smb_open); /* build the reply */ smbsrv_setup_reply(req, 1, 0); @@ -613,8 +540,9 @@ void smbsrv_reply_ctemp(struct smbsrv_request *req) union smb_open *oi; /* parse the request */ - REQ_CHECK_WCT(req, 3); - REQ_TALLOC(oi, union smb_open); + SMBSRV_CHECK_WCT(req, 3); + SMBSRV_TALLOC_IO_PTR(oi, union smb_open); + SMBSRV_SETUP_NTVFS_REQUEST(reply_ctemp_send, NTVFS_ASYNC_STATE_MAY_ASYNC); oi->ctemp.level = RAW_OPEN_CTEMP; oi->ctemp.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -629,14 +557,7 @@ void smbsrv_reply_ctemp(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_open(req, oi); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, oi)); } @@ -648,20 +569,15 @@ void smbsrv_reply_unlink(struct smbsrv_request *req) union smb_unlink *unl; /* parse the request */ - REQ_CHECK_WCT(req, 1); - REQ_TALLOC(unl, union smb_unlink); + SMBSRV_CHECK_WCT(req, 1); + SMBSRV_TALLOC_IO_PTR(unl, union smb_unlink); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); unl->unlink.in.attrib = SVAL(req->in.vwv, VWV(0)); req_pull_ascii4(req, &unl->unlink.in.pattern, req->in.data, STR_TERMINATE); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_unlink(req, unl); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_unlink(req->ntvfs, unl)); } @@ -707,9 +623,19 @@ void smbsrv_reply_readbraw(struct smbsrv_request *req) /* tell the backend where to put the data */ io.readbraw.out.data = req->out.buffer + NBT_HDR_SIZE; - /* call the backend */ - status = ntvfs_read(req, &io); + /* prepare the ntvfs request */ + req->ntvfs = ntvfs_request_create(req->tcon->ntvfs, req, + req->session->session_info, + SVAL(req->in.hdr,HDR_PID), + SVAL(req->in.hdr,HDR_MID), + req->request_time, + req, NULL, 0); + if (!req->ntvfs) { + goto failed; + } + /* call the backend */ + status = ntvfs_read(req->ntvfs, &io); if (!NT_STATUS_IS_OK(status)) { goto failed; } @@ -732,11 +658,12 @@ failed: /**************************************************************************** Reply to a lockread (async reply) ****************************************************************************/ -static void reply_lockread_send(struct smbsrv_request *req) +static void reply_lockread_send(struct ntvfs_request *ntvfs) { - union smb_read *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_read *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_read); /* trim packet */ io->lockread.out.nread = MIN(io->lockread.out.nread, @@ -745,7 +672,7 @@ static void reply_lockread_send(struct smbsrv_request *req) /* construct reply */ SSVAL(req->out.vwv, VWV(0), io->lockread.out.nread); - REQ_VWV_RESERVED(1, 4); + SMBSRV_VWV_RESERVED(1, 4); SCVAL(req->out.data, 0, SMB_DATA_BLOCK); SSVAL(req->out.data, 1, io->lockread.out.nread); @@ -763,8 +690,9 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) union smb_read *io; /* parse request */ - REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, union smb_read); + SMBSRV_CHECK_WCT(req, 5); + SMBSRV_TALLOC_IO_PTR(io, union smb_read); + SMBSRV_SETUP_NTVFS_REQUEST(reply_lockread_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->lockread.level = RAW_READ_LOCKREAD; io->lockread.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -778,14 +706,7 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) /* tell the backend where to put the data */ io->lockread.out.data = req->out.data + 3; - 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_states->status = ntvfs_read(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io)); } @@ -793,11 +714,12 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) /**************************************************************************** Reply to a read (async reply) ****************************************************************************/ -static void reply_read_send(struct smbsrv_request *req) +static void reply_read_send(struct ntvfs_request *ntvfs) { - union smb_read *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_read *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_read); /* trim packet */ io->read.out.nread = MIN(io->read.out.nread, @@ -806,7 +728,7 @@ static void reply_read_send(struct smbsrv_request *req) /* construct reply */ SSVAL(req->out.vwv, VWV(0), io->read.out.nread); - REQ_VWV_RESERVED(1, 4); + SMBSRV_VWV_RESERVED(1, 4); SCVAL(req->out.data, 0, SMB_DATA_BLOCK); SSVAL(req->out.data, 1, io->read.out.nread); @@ -822,9 +744,10 @@ void smbsrv_reply_read(struct smbsrv_request *req) union smb_read *io; /* parse request */ - REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, union smb_read); - + SMBSRV_CHECK_WCT(req, 5); + SMBSRV_TALLOC_IO_PTR(io, union smb_read); + SMBSRV_SETUP_NTVFS_REQUEST(reply_read_send, NTVFS_ASYNC_STATE_MAY_ASYNC); + io->read.level = RAW_READ_READ; io->read.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->read.in.count = SVAL(req->in.vwv, VWV(1)); @@ -837,29 +760,21 @@ void smbsrv_reply_read(struct smbsrv_request *req) /* tell the backend where to put the data */ io->read.out.data = req->out.data + 3; - 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_states->status = ntvfs_read(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io)); } - - /**************************************************************************** Reply to a read and X (async reply) ****************************************************************************/ -static void reply_read_and_X_send(struct smbsrv_request *req) +static void reply_read_and_X_send(struct ntvfs_request *ntvfs) { - union smb_read *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_read *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_read); /* readx reply packets can be over-sized */ - req->control_flags |= REQ_CONTROL_LARGE; + req->control_flags |= SMBSRV_REQ_CONTROL_LARGE; if (io->readx.in.maxcnt != 0xFFFF && io->readx.in.mincnt != 0xFFFF) { req_grow_data(req, 1 + io->readx.out.nread); @@ -873,10 +788,10 @@ static void reply_read_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(1), 0); SSVAL(req->out.vwv, VWV(2), io->readx.out.remaining); SSVAL(req->out.vwv, VWV(3), io->readx.out.compaction_mode); - REQ_VWV_RESERVED(4, 1); + SMBSRV_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)); - REQ_VWV_RESERVED(7, 5); + SMBSRV_VWV_RESERVED(7, 5); smbsrv_chain_reply(req); } @@ -890,10 +805,11 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) /* parse request */ if (req->in.wct != 12) { - REQ_CHECK_WCT(req, 10); + SMBSRV_CHECK_WCT(req, 10); } - REQ_TALLOC(io, union smb_read); + SMBSRV_TALLOC_IO_PTR(io, union smb_read); + SMBSRV_SETUP_NTVFS_REQUEST(reply_read_and_X_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->readx.level = RAW_READ_READX; io->readx.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); @@ -931,14 +847,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) io->readx.out.data = req->out.data; } - 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_states->status = ntvfs_read(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io)); } @@ -954,11 +863,12 @@ void smbsrv_reply_writebraw(struct smbsrv_request *req) /**************************************************************************** Reply to a writeunlock (async reply) ****************************************************************************/ -static void reply_writeunlock_send(struct smbsrv_request *req) +static void reply_writeunlock_send(struct ntvfs_request *ntvfs) { - union smb_write *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_write *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_write); /* construct reply */ smbsrv_setup_reply(req, 1, 0); @@ -975,8 +885,9 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) { union smb_write *io; - REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, union smb_write); + SMBSRV_CHECK_WCT(req, 5); + SMBSRV_TALLOC_IO_PTR(io, union smb_write); + SMBSRV_SETUP_NTVFS_REQUEST(reply_writeunlock_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->writeunlock.level = RAW_WRITE_WRITEUNLOCK; io->writeunlock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -997,14 +908,7 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_write(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } @@ -1012,11 +916,12 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) /**************************************************************************** Reply to a write (async reply) ****************************************************************************/ -static void reply_write_send(struct smbsrv_request *req) +static void reply_write_send(struct ntvfs_request *ntvfs) { - union smb_write *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_write *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_write); /* construct reply */ smbsrv_setup_reply(req, 1, 0); @@ -1033,8 +938,9 @@ void smbsrv_reply_write(struct smbsrv_request *req) { union smb_write *io; - REQ_CHECK_WCT(req, 5); - REQ_TALLOC(io, union smb_write); + SMBSRV_CHECK_WCT(req, 5); + SMBSRV_TALLOC_IO_PTR(io, union smb_write); + SMBSRV_SETUP_NTVFS_REQUEST(reply_write_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->write.level = RAW_WRITE_WRITE; io->write.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1055,25 +961,19 @@ void smbsrv_reply_write(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_write(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } /**************************************************************************** Reply to a write and X (async reply) ****************************************************************************/ -static void reply_write_and_X_send(struct smbsrv_request *req) +static void reply_write_and_X_send(struct ntvfs_request *ntvfs) { - union smb_write *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_write *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_write); /* construct reply */ smbsrv_setup_reply(req, 6, 0); @@ -1083,7 +983,7 @@ static void reply_write_and_X_send(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(2), io->writex.out.nwritten & 0xFFFF); SSVAL(req->out.vwv, VWV(3), io->writex.out.remaining); SSVAL(req->out.vwv, VWV(4), io->writex.out.nwritten >> 16); - REQ_VWV_RESERVED(5, 1); + SMBSRV_VWV_RESERVED(5, 1); smbsrv_chain_reply(req); } @@ -1096,10 +996,11 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) union smb_write *io; if (req->in.wct != 14) { - REQ_CHECK_WCT(req, 12); + SMBSRV_CHECK_WCT(req, 12); } - REQ_TALLOC(io, union smb_write); + SMBSRV_TALLOC_IO_PTR(io, union smb_write); + SMBSRV_SETUP_NTVFS_REQUEST(reply_write_and_X_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->writex.level = RAW_WRITE_WRITEX; io->writex.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); @@ -1122,25 +1023,19 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_write(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } /**************************************************************************** Reply to a lseek (async reply) ****************************************************************************/ -static void reply_lseek_send(struct smbsrv_request *req) +static void reply_lseek_send(struct ntvfs_request *ntvfs) { - union smb_seek *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_seek *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_seek); /* construct reply */ smbsrv_setup_reply(req, 2, 0); @@ -1157,21 +1052,15 @@ void smbsrv_reply_lseek(struct smbsrv_request *req) { union smb_seek *io; - REQ_CHECK_WCT(req, 4); - REQ_TALLOC(io, union smb_seek); + SMBSRV_CHECK_WCT(req, 4); + SMBSRV_TALLOC_IO_PTR(io, union smb_seek); + SMBSRV_SETUP_NTVFS_REQUEST(reply_lseek_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->lseek.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); io->lseek.in.mode = SVAL(req->in.vwv, VWV(1)); io->lseek.in.offset = IVALS(req->in.vwv, VWV(2)); - 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_states->status = ntvfs_seek(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_seek(req->ntvfs, io)); } /**************************************************************************** @@ -1182,18 +1071,13 @@ void smbsrv_reply_flush(struct smbsrv_request *req) union smb_flush *io; /* parse request */ - REQ_CHECK_WCT(req, 1); - REQ_TALLOC(io, union smb_flush); + SMBSRV_CHECK_WCT(req, 1); + SMBSRV_TALLOC_IO_PTR(io, union smb_flush); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->flush.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_flush(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_flush(req->ntvfs, io)); } @@ -1204,14 +1088,15 @@ void smbsrv_reply_exit(struct smbsrv_request *req) { NTSTATUS status; struct smbsrv_tcon *tcon; - REQ_CHECK_WCT(req, 0); + SMBSRV_CHECK_WCT(req, 0); for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { req->tcon = tcon; -req->ctx = req->tcon->ntvfs; - status = ntvfs_exit(req); + SMBSRV_SETUP_NTVFS_REQUEST(NULL,0); + status = ntvfs_exit(req->ntvfs); + talloc_free(req->ntvfs); + req->ntvfs = NULL; req->tcon = NULL; -req->ctx = NULL; if (!NT_STATUS_IS_OK(status)) { smbsrv_send_error(req, status); return; @@ -1233,32 +1118,27 @@ void smbsrv_reply_close(struct smbsrv_request *req) union smb_close *io; /* parse request */ - REQ_CHECK_WCT(req, 3); - REQ_TALLOC(io, union smb_close); + SMBSRV_CHECK_WCT(req, 3); + SMBSRV_TALLOC_IO_PTR(io, union smb_close); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->close.level = RAW_CLOSE_CLOSE; io->close.in.file.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_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_close(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_close(req->ntvfs, io)); } - /**************************************************************************** Reply to a writeclose (async reply) ****************************************************************************/ -static void reply_writeclose_send(struct smbsrv_request *req) +static void reply_writeclose_send(struct ntvfs_request *ntvfs) { - union smb_write *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_write *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_write); /* construct reply */ smbsrv_setup_reply(req, 1, 0); @@ -1277,10 +1157,11 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) /* this one is pretty weird - the wct can be 6 or 12 */ if (req->in.wct != 12) { - REQ_CHECK_WCT(req, 6); + SMBSRV_CHECK_WCT(req, 6); } - REQ_TALLOC(io, union smb_write); + SMBSRV_TALLOC_IO_PTR(io, union smb_write); + SMBSRV_SETUP_NTVFS_REQUEST(reply_writeclose_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->writeclose.level = RAW_WRITE_WRITECLOSE; io->writeclose.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1295,14 +1176,7 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_write(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } /**************************************************************************** @@ -1313,21 +1187,16 @@ void smbsrv_reply_lock(struct smbsrv_request *req) union smb_lock *lck; /* parse request */ - REQ_CHECK_WCT(req, 5); - REQ_TALLOC(lck, union smb_lock); + SMBSRV_CHECK_WCT(req, 5); + SMBSRV_TALLOC_IO_PTR(lck, union smb_lock); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); lck->lock.level = RAW_LOCK_LOCK; lck->lock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); lck->lock.in.count = IVAL(req->in.vwv, VWV(1)); lck->lock.in.offset = IVAL(req->in.vwv, VWV(3)); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_lock(req, lck); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, lck)); } @@ -1339,21 +1208,16 @@ void smbsrv_reply_unlock(struct smbsrv_request *req) union smb_lock *lck; /* parse request */ - REQ_CHECK_WCT(req, 5); - REQ_TALLOC(lck, union smb_lock); + SMBSRV_CHECK_WCT(req, 5); + SMBSRV_TALLOC_IO_PTR(lck, union smb_lock); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); lck->unlock.level = RAW_LOCK_UNLOCK; lck->unlock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); lck->unlock.in.count = IVAL(req->in.vwv, VWV(1)); lck->unlock.in.offset = IVAL(req->in.vwv, VWV(3)); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_lock(req, lck); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, lck)); } @@ -1362,9 +1226,10 @@ void smbsrv_reply_unlock(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_tdis(struct smbsrv_request *req) { - REQ_CHECK_WCT(req, 0); + SMBSRV_CHECK_WCT(req, 0); talloc_free(req->tcon); + req->tcon = NULL; /* construct reply */ smbsrv_setup_reply(req, 0, 0); @@ -1382,7 +1247,7 @@ void smbsrv_reply_echo(struct smbsrv_request *req) uint16_t count; int i; - REQ_CHECK_WCT(req, 0); + SMBSRV_CHECK_WCT(req, 0); count = SVAL(req->in.vwv, VWV(0)); @@ -1409,11 +1274,12 @@ void smbsrv_reply_echo(struct smbsrv_request *req) /**************************************************************************** Reply to a printopen (async reply) ****************************************************************************/ -static void reply_printopen_send(struct smbsrv_request *req) +static void reply_printopen_send(struct ntvfs_request *ntvfs) { - union smb_open *oi = req->async_states->private_data; + struct smbsrv_request *req; + union smb_open *oi; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(oi, union smb_open); /* construct reply */ smbsrv_setup_reply(req, 1, 0); @@ -1431,8 +1297,9 @@ void smbsrv_reply_printopen(struct smbsrv_request *req) union smb_open *oi; /* parse request */ - REQ_CHECK_WCT(req, 2); - REQ_TALLOC(oi, union smb_open); + SMBSRV_CHECK_WCT(req, 2); + SMBSRV_TALLOC_IO_PTR(oi, union smb_open); + SMBSRV_SETUP_NTVFS_REQUEST(reply_printopen_send, NTVFS_ASYNC_STATE_MAY_ASYNC); oi->splopen.level = RAW_OPEN_SPLOPEN; oi->splopen.in.setup_length = SVAL(req->in.vwv, VWV(0)); @@ -1440,14 +1307,7 @@ void smbsrv_reply_printopen(struct smbsrv_request *req) req_pull_ascii4(req, &oi->splopen.in.ident, req->in.data, STR_TERMINATE); - 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_states->status = ntvfs_open(req, oi); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, oi)); } /**************************************************************************** @@ -1458,31 +1318,27 @@ void smbsrv_reply_printclose(struct smbsrv_request *req) union smb_close *io; /* parse request */ - REQ_CHECK_WCT(req, 3); - REQ_TALLOC(io, union smb_close); + SMBSRV_CHECK_WCT(req, 3); + SMBSRV_TALLOC_IO_PTR(io, union smb_close); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->splclose.level = RAW_CLOSE_SPLCLOSE; io->splclose.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_close(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_close(req->ntvfs, io)); } /**************************************************************************** Reply to a printqueue. ****************************************************************************/ -static void reply_printqueue_send(struct smbsrv_request *req) +static void reply_printqueue_send(struct ntvfs_request *ntvfs) { - union smb_lpq *lpq = req->async_states->private_data; + struct smbsrv_request *req; + union smb_lpq *lpq; int i, maxcount; - const uint_t el_size = 28; + const uint_t el_size = 28; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(lpq,union smb_lpq); /* construct reply */ smbsrv_setup_reply(req, 2, 0); @@ -1526,21 +1382,15 @@ void smbsrv_reply_printqueue(struct smbsrv_request *req) union smb_lpq *lpq; /* parse request */ - REQ_CHECK_WCT(req, 2); - REQ_TALLOC(lpq, union smb_lpq); + SMBSRV_CHECK_WCT(req, 2); + SMBSRV_TALLOC_IO_PTR(lpq, union smb_lpq); + SMBSRV_SETUP_NTVFS_REQUEST(reply_printqueue_send, NTVFS_ASYNC_STATE_MAY_ASYNC); lpq->retq.level = RAW_LPQ_RETQ; lpq->retq.in.maxcount = SVAL(req->in.vwv, VWV(0)); lpq->retq.in.startidx = SVAL(req->in.vwv, VWV(1)); - 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_states->status = ntvfs_lpq(req, lpq); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_lpq(req->ntvfs, lpq)); } @@ -1552,8 +1402,9 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) union smb_write *io; /* parse request */ - REQ_CHECK_WCT(req, 1); - REQ_TALLOC(io, union smb_write); + SMBSRV_CHECK_WCT(req, 1); + SMBSRV_TALLOC_IO_PTR(io, union smb_write); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->splwrite.level = RAW_WRITE_SPLWRITE; @@ -1572,13 +1423,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) return; } - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_write(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } @@ -1590,19 +1435,14 @@ void smbsrv_reply_mkdir(struct smbsrv_request *req) union smb_mkdir *io; /* parse the request */ - REQ_CHECK_WCT(req, 0); - REQ_TALLOC(io, union smb_mkdir); + SMBSRV_CHECK_WCT(req, 0); + SMBSRV_TALLOC_IO_PTR(io, union smb_mkdir); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->generic.level = RAW_MKDIR_MKDIR; req_pull_ascii4(req, &io->mkdir.in.path, req->in.data, STR_TERMINATE); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_mkdir(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_mkdir(req->ntvfs, io)); } @@ -1614,18 +1454,13 @@ void smbsrv_reply_rmdir(struct smbsrv_request *req) struct smb_rmdir *io; /* parse the request */ - REQ_CHECK_WCT(req, 0); - REQ_TALLOC(io, struct smb_rmdir); + SMBSRV_CHECK_WCT(req, 0); + SMBSRV_TALLOC_IO_PTR(io, struct smb_rmdir); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE); - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_rmdir(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_rmdir(req->ntvfs, io)); } @@ -1638,8 +1473,9 @@ void smbsrv_reply_mv(struct smbsrv_request *req) uint8_t *p; /* parse the request */ - REQ_CHECK_WCT(req, 1); - REQ_TALLOC(io, union smb_rename); + SMBSRV_CHECK_WCT(req, 1); + SMBSRV_TALLOC_IO_PTR(io, union smb_rename); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->generic.level = RAW_RENAME_RENAME; io->rename.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -1653,13 +1489,7 @@ void smbsrv_reply_mv(struct smbsrv_request *req) return; } - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_rename(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_rename(req->ntvfs, io)); } @@ -1672,8 +1502,9 @@ void smbsrv_reply_ntrename(struct smbsrv_request *req) uint8_t *p; /* parse the request */ - REQ_CHECK_WCT(req, 4); - REQ_TALLOC(io, union smb_rename); + SMBSRV_CHECK_WCT(req, 4); + SMBSRV_TALLOC_IO_PTR(io, union smb_rename); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->generic.level = RAW_RENAME_NTRENAME; io->ntrename.in.attrib = SVAL(req->in.vwv, VWV(0)); @@ -1689,23 +1520,18 @@ void smbsrv_reply_ntrename(struct smbsrv_request *req) return; } - req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_rename(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_rename(req->ntvfs, io)); } /**************************************************************************** Reply to a file copy (async reply) ****************************************************************************/ -static void reply_copy_send(struct smbsrv_request *req) +static void reply_copy_send(struct ntvfs_request *ntvfs) { - struct smb_copy *cp = req->async_states->private_data; + struct smbsrv_request *req; + struct smb_copy *cp; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(cp, struct smb_copy); /* build the reply */ smbsrv_setup_reply(req, 1, 0); @@ -1724,8 +1550,9 @@ void smbsrv_reply_copy(struct smbsrv_request *req) uint8_t *p; /* parse request */ - REQ_CHECK_WCT(req, 3); - REQ_TALLOC(cp, struct smb_copy); + SMBSRV_CHECK_WCT(req, 3); + SMBSRV_TALLOC_IO_PTR(cp, struct smb_copy); + SMBSRV_SETUP_NTVFS_REQUEST(reply_copy_send, NTVFS_ASYNC_STATE_MAY_ASYNC); cp->in.tid2 = SVAL(req->in.vwv, VWV(0)); cp->in.ofun = SVAL(req->in.vwv, VWV(1)); @@ -1740,24 +1567,18 @@ void smbsrv_reply_copy(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_copy(req, cp); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_copy(req->ntvfs, cp)); } /**************************************************************************** Reply to a lockingX request (async send) ****************************************************************************/ -static void reply_lockingX_send(struct smbsrv_request *req) +static void reply_lockingX_send(struct ntvfs_request *ntvfs) { - union smb_lock *lck = req->async_states->private_data; + struct smbsrv_request *req; + union smb_lock *lck; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(lck, union smb_lock); /* if it was an oplock break ack then we only send a reply if there was an error */ @@ -1787,8 +1608,9 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) uint8_t *p; /* parse request */ - REQ_CHECK_WCT(req, 8); - REQ_TALLOC(lck, union smb_lock); + SMBSRV_CHECK_WCT(req, 8); + SMBSRV_TALLOC_IO_PTR(lck, union smb_lock); + SMBSRV_SETUP_NTVFS_REQUEST(reply_lockingX_send, NTVFS_ASYNC_STATE_MAY_ASYNC); lck->lockx.level = RAW_LOCK_LOCKX; lck->lockx.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); @@ -1846,14 +1668,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) p += lck_size; } - 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_states->status = ntvfs_lock(req, lck); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, lck)); } /**************************************************************************** @@ -1874,8 +1689,9 @@ void smbsrv_reply_setattrE(struct smbsrv_request *req) union smb_setfileinfo *info; /* parse request */ - REQ_CHECK_WCT(req, 7); - REQ_TALLOC(info, union smb_setfileinfo); + SMBSRV_CHECK_WCT(req, 7); + SMBSRV_TALLOC_IO_PTR(info, union smb_setfileinfo); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); info->setattre.level = RAW_SFILEINFO_SETATTRE; info->setattre.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); @@ -1883,13 +1699,7 @@ void smbsrv_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_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC; - req->async_states->send_fn = reply_simple_send; - - /* call backend */ - req->async_states->status = ntvfs_setfileinfo(req, info); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_setfileinfo(req->ntvfs, info)); } @@ -1915,11 +1725,12 @@ void smbsrv_reply_writebs(struct smbsrv_request *req) /**************************************************************************** Reply to a SMBgetattrE (async reply) ****************************************************************************/ -static void reply_getattrE_send(struct smbsrv_request *req) +static void reply_getattrE_send(struct ntvfs_request *ntvfs) { - union smb_fileinfo *info = req->async_states->private_data; + struct smbsrv_request *req; + union smb_fileinfo *info; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(info, union smb_fileinfo); /* setup reply */ smbsrv_setup_reply(req, 11, 0); @@ -1942,20 +1753,14 @@ void smbsrv_reply_getattrE(struct smbsrv_request *req) union smb_fileinfo *info; /* parse request */ - REQ_CHECK_WCT(req, 1); - REQ_TALLOC(info, union smb_fileinfo); + SMBSRV_CHECK_WCT(req, 1); + SMBSRV_TALLOC_IO_PTR(info, union smb_fileinfo); + SMBSRV_SETUP_NTVFS_REQUEST(reply_getattrE_send, NTVFS_ASYNC_STATE_MAY_ASYNC); info->getattr.level = RAW_FILEINFO_GETATTRE; info->getattr.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - 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_states->status = ntvfs_qfileinfo(req, info); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_qfileinfo(req->ntvfs, info)); } @@ -2186,10 +1991,11 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) open by this user on all open tree connects */ for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { req->tcon = tcon; - req->ctx = tcon->ntvfs; - status = ntvfs_logoff(req); + SMBSRV_SETUP_NTVFS_REQUEST(NULL,0); + status = ntvfs_logoff(req->ntvfs); + talloc_free(req->ntvfs); + req->ntvfs = NULL; req->tcon = NULL; - req->ctx = NULL; if (!NT_STATUS_IS_OK(status)) { smbsrv_send_error(req, status); return; @@ -2208,34 +2014,22 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) smbsrv_chain_reply(req); } - /**************************************************************************** Reply to an SMBfindclose request ****************************************************************************/ void smbsrv_reply_findclose(struct smbsrv_request *req) { - NTSTATUS status; - union smb_search_close io; - - io.findclose.level = RAW_FINDCLOSE_FINDCLOSE; + union smb_search_close *io; /* parse request */ - REQ_CHECK_WCT(req, 1); + SMBSRV_CHECK_WCT(req, 1); + SMBSRV_TALLOC_IO_PTR(io, union smb_search_close); + SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - io.findclose.in.handle = SVAL(req->in.vwv, VWV(0)); - - /* call backend */ - status = ntvfs_search_close(req, &io); + io->findclose.level = RAW_FINDCLOSE_FINDCLOSE; + io->findclose.in.handle = SVAL(req->in.vwv, VWV(0)); - if (!NT_STATUS_IS_OK(status)) { - smbsrv_send_error(req, status); - return; - } - - /* construct reply */ - smbsrv_setup_reply(req, 0, 0); - - smbsrv_send_reply(req); + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_search_close(req->ntvfs, io)); } /**************************************************************************** @@ -2250,11 +2044,12 @@ void smbsrv_reply_findnclose(struct smbsrv_request *req) /**************************************************************************** Reply to an SMBntcreateX request (async send) ****************************************************************************/ -static void reply_ntcreate_and_X_send(struct smbsrv_request *req) +static void reply_ntcreate_and_X_send(struct ntvfs_request *ntvfs) { - union smb_open *io = req->async_states->private_data; + struct smbsrv_request *req; + union smb_open *io; - CHECK_ASYNC_STATUS; + SMBSRV_CHECK_ASYNC_STATUS(io, union smb_open); /* construct reply */ smbsrv_setup_reply(req, 34, 0); @@ -2291,8 +2086,9 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) uint16_t fname_len; /* parse the request */ - REQ_CHECK_WCT(req, 24); - REQ_TALLOC(io, union smb_open); + SMBSRV_CHECK_WCT(req, 24); + SMBSRV_TALLOC_IO_PTR(io, union smb_open); + SMBSRV_SETUP_NTVFS_REQUEST(reply_ntcreate_and_X_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->ntcreatex.level = RAW_OPEN_NTCREATEX; @@ -2323,14 +2119,7 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) return; } - 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_states->status = ntvfs_open(req, io); - - REQ_ASYNC_TAIL; + SMBSRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, io)); } @@ -2340,7 +2129,8 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) void smbsrv_reply_ntcancel(struct smbsrv_request *req) { /* NOTE: this request does not generate a reply */ - ntvfs_cancel(req); + SMBSRV_SETUP_NTVFS_REQUEST(NULL,0); + ntvfs_cancel(req->ntvfs); talloc_free(req); } -- cgit From d72632ba08adb495459609303d10a225f79cedb0 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 22 Mar 2006 14:58:34 +0000 Subject: r14644: fix SMBecho, used by w2k clients, failing this, causes an SMBulogoffX and SMBtdis jelmer: I think this should go into TP2 metze (This used to be commit 94d775c74d611e950bb5502bfe7f7c4015c6f772) --- source4/smb_server/smb/reply.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 65976fd385..cfd004304a 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1247,7 +1247,7 @@ void smbsrv_reply_echo(struct smbsrv_request *req) uint16_t count; int i; - SMBSRV_CHECK_WCT(req, 0); + SMBSRV_CHECK_WCT(req, 1); count = SVAL(req->in.vwv, VWV(0)); -- cgit From 7f0e17e9030ad734977f66c2cc27faec501154a2 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Fri, 19 May 2006 15:10:39 +0000 Subject: r15718: - split the SMBflush with the 0xFFFF wildcard fnum into a different level metze (This used to be commit 95bf41b4d4ec96349802955e364fe44ef85f9077) --- source4/smb_server/smb/reply.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index cfd004304a..768fba1319 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1069,13 +1069,21 @@ void smbsrv_reply_lseek(struct smbsrv_request *req) void smbsrv_reply_flush(struct smbsrv_request *req) { union smb_flush *io; + uint16_t fnum; /* parse request */ SMBSRV_CHECK_WCT(req, 1); SMBSRV_TALLOC_IO_PTR(io, union smb_flush); SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - io->flush.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + fnum = req_fnum(req, req->in.vwv, VWV(0)); + + if (fnum == 0xFFFF) { + io->flush_all.level = RAW_FLUSH_ALL; + } else { + io->flush.level = RAW_FLUSH_FLUSH; + io->flush.in.file.fnum = fnum; + } SMBSRV_CALL_NTVFS_BACKEND(ntvfs_flush(req->ntvfs, io)); } -- cgit From 9ef33f5f5c786b83311ca088357fb2f0aa72fc9e Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Sat, 20 May 2006 08:15:22 +0000 Subject: r15734: This is a major change to the NTVFS subsystem: - to use a struct ntvfs_handle instead of a uint16_t fnum. (to make it independend from the frontend protocol) - the allocation of handles now is provided by the frontend (smbsrv_*) via callbacks and not by each backend module - this also makes sure that file handles are only passed to the ntvfs subsystem when the tcon and session matches, so modules can rely on this and need to check this. - this allows multiple modules in the ntvfs module chain to allocate file handles. This can be used for virtual files like "\\$Extend\\$Quota:$Q:$INDEX_ALLOCATION"... - also this will make SMB2 with 128 bit file handles possible metze (This used to be commit 287fc1c22d670f6e568014b420f7f4cb31dc7958) --- source4/smb_server/smb/reply.c | 229 ++++++++++++++++++++++++++--------------- 1 file changed, 145 insertions(+), 84 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 768fba1319..9abb35ad86 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -3,6 +3,7 @@ Main SMB reply routines Copyright (C) Andrew Tridgell 1992-2003 Copyright (C) James J Myers 2003 + Copyright (C) Stefan Metzmacher 2006 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -20,7 +21,7 @@ */ /* This file handles most of the reply_ calls that the server - makes to handle specific protocols + makes to handle specific SMB commands */ #include "includes.h" @@ -204,10 +205,11 @@ void smbsrv_reply_ioctl(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_ioctl_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->ioctl.level = RAW_IOCTL_IOCTL; - io->ioctl.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->ioctl.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io->ioctl.in.request = IVAL(req->in.vwv, VWV(1)); - /* call backend */ + SMBSRV_CHECK_FILE_HANDLE_ERROR(io->ioctl.in.file.ntvfs, + NT_STATUS_DOS(ERRSRV, ERRerror)); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_ioctl(req->ntvfs, io)); } @@ -353,7 +355,7 @@ static void reply_open_send(struct ntvfs_request *ntvfs) /* construct reply */ smbsrv_setup_reply(req, 7, 0); - SSVAL(req->out.vwv, VWV(0), oi->openold.out.file.fnum); + smbsrv_push_fnum(req->out.vwv, VWV(0), oi->openold.out.file.ntvfs); 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); @@ -408,7 +410,7 @@ static void reply_open_and_X_send(struct ntvfs_request *ntvfs) SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); - SSVAL(req->out.vwv, VWV(2), oi->openx.out.file.fnum); + smbsrv_push_fnum(req->out.vwv, VWV(2), oi->openx.out.file.ntvfs); SSVAL(req->out.vwv, VWV(3), oi->openx.out.attrib); srv_push_dos_date3(req->smb_conn, req->out.vwv, VWV(4), oi->openx.out.write_time); SIVAL(req->out.vwv, VWV(6), oi->openx.out.size); @@ -423,7 +425,7 @@ static void reply_open_and_X_send(struct ntvfs_request *ntvfs) SMBSRV_VWV_RESERVED(17, 2); } - req->chained_fnum = oi->openx.out.file.fnum; + req->chained_fnum = SVAL(req->out.vwv, VWV(2)); smbsrv_chain_reply(req); } @@ -475,7 +477,7 @@ static void reply_mknew_send(struct ntvfs_request *ntvfs) /* build the reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->mknew.out.file.fnum); + smbsrv_push_fnum(req->out.vwv, VWV(0), oi->mknew.out.file.ntvfs); smbsrv_send_reply(req); } @@ -524,7 +526,7 @@ static void reply_ctemp_send(struct ntvfs_request *ntvfs) /* build the reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->ctemp.out.file.fnum); + smbsrv_push_fnum(req->out.vwv, VWV(0), oi->ctemp.out.file.ntvfs); /* the returned filename is relative to the directory */ req_push_str(req, NULL, oi->ctemp.out.name, -1, STR_TERMINATE | STR_ASCII); @@ -599,12 +601,16 @@ void smbsrv_reply_readbraw(struct smbsrv_request *req) goto failed; } - io.readbraw.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io.readbraw.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io.readbraw.in.offset = IVAL(req->in.vwv, VWV(1)); 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)); + if (!io.readbraw.in.file.ntvfs) { + goto failed; + } + /* the 64 bit variant */ if (req->in.wct == 10) { uint32_t offset_high = IVAL(req->in.vwv, VWV(8)); @@ -695,17 +701,18 @@ void smbsrv_reply_lockread(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_lockread_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->lockread.level = RAW_READ_LOCKREAD; - io->lockread.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->lockread.in.file.ntvfs= smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io->lockread.in.count = SVAL(req->in.vwv, VWV(1)); io->lockread.in.offset = IVAL(req->in.vwv, VWV(2)); io->lockread.in.remaining = SVAL(req->in.vwv, VWV(4)); - + /* setup the reply packet assuming the maximum possible read */ smbsrv_setup_reply(req, 5, 3 + io->lockread.in.count); /* tell the backend where to put the data */ io->lockread.out.data = req->out.data + 3; + SMBSRV_CHECK_FILE_HANDLE(io->lockread.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io)); } @@ -749,17 +756,18 @@ void smbsrv_reply_read(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_read_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->read.level = RAW_READ_READ; - io->read.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->read.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io->read.in.count = SVAL(req->in.vwv, VWV(1)); io->read.in.offset = IVAL(req->in.vwv, VWV(2)); io->read.in.remaining = SVAL(req->in.vwv, VWV(4)); - + /* setup the reply packet assuming the maximum possible read */ smbsrv_setup_reply(req, 5, 3 + io->read.in.count); /* tell the backend where to put the data */ io->read.out.data = req->out.data + 3; + SMBSRV_CHECK_FILE_HANDLE(io->read.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io)); } @@ -812,7 +820,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_read_and_X_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->readx.level = RAW_READ_READX; - io->readx.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->readx.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(2)); io->readx.in.offset = IVAL(req->in.vwv, VWV(3)); io->readx.in.maxcnt = SVAL(req->in.vwv, VWV(5)); io->readx.in.mincnt = SVAL(req->in.vwv, VWV(6)); @@ -847,6 +855,7 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) io->readx.out.data = req->out.data; } + SMBSRV_CHECK_FILE_HANDLE(io->readx.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_read(req->ntvfs, io)); } @@ -890,7 +899,7 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_writeunlock_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->writeunlock.level = RAW_WRITE_WRITEUNLOCK; - io->writeunlock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->writeunlock.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io->writeunlock.in.count = SVAL(req->in.vwv, VWV(1)); io->writeunlock.in.offset = IVAL(req->in.vwv, VWV(2)); io->writeunlock.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -908,6 +917,7 @@ void smbsrv_reply_writeunlock(struct smbsrv_request *req) return; } + SMBSRV_CHECK_FILE_HANDLE(io->writeunlock.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } @@ -943,7 +953,7 @@ void smbsrv_reply_write(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_write_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->write.level = RAW_WRITE_WRITE; - io->write.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->write.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io->write.in.count = SVAL(req->in.vwv, VWV(1)); io->write.in.offset = IVAL(req->in.vwv, VWV(2)); io->write.in.remaining = SVAL(req->in.vwv, VWV(4)); @@ -961,6 +971,7 @@ void smbsrv_reply_write(struct smbsrv_request *req) return; } + SMBSRV_CHECK_FILE_HANDLE(io->write.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } @@ -1003,7 +1014,7 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_write_and_X_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->writex.level = RAW_WRITE_WRITEX; - io->writex.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); + io->writex.in.file.ntvfs= smbsrv_pull_fnum(req, req->in.vwv, VWV(2)); io->writex.in.offset = IVAL(req->in.vwv, VWV(3)); io->writex.in.wmode = SVAL(req->in.vwv, VWV(7)); io->writex.in.remaining = SVAL(req->in.vwv, VWV(8)); @@ -1021,8 +1032,9 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) if (req_data_oob(req, io->writex.in.data, io->writex.in.count)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; - } + } + SMBSRV_CHECK_FILE_HANDLE(io->writex.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } @@ -1056,10 +1068,11 @@ void smbsrv_reply_lseek(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(io, union smb_seek); SMBSRV_SETUP_NTVFS_REQUEST(reply_lseek_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - io->lseek.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->lseek.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io->lseek.in.mode = SVAL(req->in.vwv, VWV(1)); io->lseek.in.offset = IVALS(req->in.vwv, VWV(2)); + SMBSRV_CHECK_FILE_HANDLE(io->lseek.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_seek(req->ntvfs, io)); } @@ -1076,46 +1089,18 @@ void smbsrv_reply_flush(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(io, union smb_flush); SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - fnum = req_fnum(req, req->in.vwv, VWV(0)); - + fnum = SVAL(req->in.vwv, VWV(0)); if (fnum == 0xFFFF) { io->flush_all.level = RAW_FLUSH_ALL; } else { io->flush.level = RAW_FLUSH_FLUSH; - io->flush.in.file.fnum = fnum; + io->flush.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); + SMBSRV_CHECK_FILE_HANDLE(io->flush.in.file.ntvfs); } SMBSRV_CALL_NTVFS_BACKEND(ntvfs_flush(req->ntvfs, io)); } - -/**************************************************************************** - Reply to a exit. This closes all files open by a smbpid -****************************************************************************/ -void smbsrv_reply_exit(struct smbsrv_request *req) -{ - NTSTATUS status; - struct smbsrv_tcon *tcon; - SMBSRV_CHECK_WCT(req, 0); - - for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { - req->tcon = tcon; - SMBSRV_SETUP_NTVFS_REQUEST(NULL,0); - status = ntvfs_exit(req->ntvfs); - talloc_free(req->ntvfs); - req->ntvfs = NULL; - req->tcon = NULL; - if (!NT_STATUS_IS_OK(status)) { - smbsrv_send_error(req, status); - return; - } - } - - smbsrv_setup_reply(req, 0, 0); - smbsrv_send_reply(req); -} - - /**************************************************************************** Reply to a close @@ -1131,9 +1116,10 @@ void smbsrv_reply_close(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->close.level = RAW_CLOSE_CLOSE; - io->close.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->close.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); io->close.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1)); + SMBSRV_CHECK_FILE_HANDLE(io->close.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_close(req->ntvfs, io)); } @@ -1171,12 +1157,12 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(io, union smb_write); SMBSRV_SETUP_NTVFS_REQUEST(reply_writeclose_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - io->writeclose.level = RAW_WRITE_WRITECLOSE; - io->writeclose.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - io->writeclose.in.count = SVAL(req->in.vwv, VWV(1)); - io->writeclose.in.offset = IVAL(req->in.vwv, VWV(2)); - io->writeclose.in.mtime = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(4)); - io->writeclose.in.data = req->in.data + 1; + io->writeclose.level = RAW_WRITE_WRITECLOSE; + io->writeclose.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); + io->writeclose.in.count = SVAL(req->in.vwv, VWV(1)); + io->writeclose.in.offset = IVAL(req->in.vwv, VWV(2)); + io->writeclose.in.mtime = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(4)); + io->writeclose.in.data = req->in.data + 1; /* make sure they gave us the data they promised */ if (req_data_oob(req, io->writeclose.in.data, io->writeclose.in.count)) { @@ -1184,6 +1170,7 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) return; } + SMBSRV_CHECK_FILE_HANDLE(io->writeclose.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } @@ -1200,10 +1187,11 @@ void smbsrv_reply_lock(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); lck->lock.level = RAW_LOCK_LOCK; - lck->lock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->lock.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); lck->lock.in.count = IVAL(req->in.vwv, VWV(1)); lck->lock.in.offset = IVAL(req->in.vwv, VWV(3)); + SMBSRV_CHECK_FILE_HANDLE(lck->lock.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, lck)); } @@ -1221,10 +1209,11 @@ void smbsrv_reply_unlock(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); lck->unlock.level = RAW_LOCK_UNLOCK; - lck->unlock.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + lck->unlock.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); lck->unlock.in.count = IVAL(req->in.vwv, VWV(1)); lck->unlock.in.offset = IVAL(req->in.vwv, VWV(3)); + SMBSRV_CHECK_FILE_HANDLE(lck->unlock.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, lck)); } @@ -1234,14 +1223,27 @@ void smbsrv_reply_unlock(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_tdis(struct smbsrv_request *req) { + struct smbsrv_handle *h, *nh; + SMBSRV_CHECK_WCT(req, 0); + /* + * TODO: cancel all pending requests on this tcon + */ + + /* + * close all handles on this tcon + */ + for (h=req->tcon->handles.list; h; h=nh) { + nh = h->next; + talloc_free(h); + } + + /* finaly destroy the tcon */ talloc_free(req->tcon); req->tcon = NULL; - /* construct reply */ smbsrv_setup_reply(req, 0, 0); - smbsrv_send_reply(req); } @@ -1292,7 +1294,7 @@ static void reply_printopen_send(struct ntvfs_request *ntvfs) /* construct reply */ smbsrv_setup_reply(req, 1, 0); - SSVAL(req->out.vwv, VWV(0), oi->openold.out.file.fnum); + smbsrv_push_fnum(req->out.vwv, VWV(0), oi->openold.out.file.ntvfs); smbsrv_send_reply(req); } @@ -1330,9 +1332,10 @@ void smbsrv_reply_printclose(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(io, union smb_close); SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - io->splclose.level = RAW_CLOSE_SPLCLOSE; - io->splclose.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + io->splclose.level = RAW_CLOSE_SPLCLOSE; + io->splclose.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); + SMBSRV_CHECK_FILE_HANDLE(io->splclose.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_close(req->ntvfs, io)); } @@ -1414,16 +1417,15 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(io, union smb_write); SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - io->splwrite.level = RAW_WRITE_SPLWRITE; - if (req->in.data_size < 3) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } - io->splwrite.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); - io->splwrite.in.count = SVAL(req->in.data, 1); - io->splwrite.in.data = req->in.data + 3; + io->splwrite.level = RAW_WRITE_SPLWRITE; + io->splwrite.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); + io->splwrite.in.count = SVAL(req->in.data, 1); + io->splwrite.in.data = req->in.data + 3; /* make sure they gave us the data they promised */ if (req_data_oob(req, io->splwrite.in.data, io->splwrite.in.count)) { @@ -1431,6 +1433,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) return; } + SMBSRV_CHECK_FILE_HANDLE(io->splwrite.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_write(req->ntvfs, io)); } @@ -1621,7 +1624,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_lockingX_send, NTVFS_ASYNC_STATE_MAY_ASYNC); lck->lockx.level = RAW_LOCK_LOCKX; - lck->lockx.in.file.fnum = req_fnum(req, req->in.vwv, VWV(2)); + lck->lockx.in.file.ntvfs= smbsrv_pull_fnum(req, req->in.vwv, VWV(2)); lck->lockx.in.mode = SVAL(req->in.vwv, VWV(3)); lck->lockx.in.timeout = IVAL(req->in.vwv, VWV(4)); lck->lockx.in.ulock_cnt = SVAL(req->in.vwv, VWV(6)); @@ -1676,6 +1679,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) p += lck_size; } + SMBSRV_CHECK_FILE_HANDLE(lck->lockx.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, lck)); } @@ -1702,11 +1706,12 @@ void smbsrv_reply_setattrE(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); info->setattre.level = RAW_SFILEINFO_SETATTRE; - info->setattre.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + info->setattre.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); info->setattre.in.create_time = srv_pull_dos_date2(req->smb_conn, req->in.vwv + VWV(1)); 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)); + SMBSRV_CHECK_FILE_HANDLE(info->setattre.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_setfileinfo(req->ntvfs, info)); } @@ -1765,9 +1770,10 @@ void smbsrv_reply_getattrE(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(info, union smb_fileinfo); SMBSRV_SETUP_NTVFS_REQUEST(reply_getattrE_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - info->getattr.level = RAW_FILEINFO_GETATTRE; - info->getattr.in.file.fnum = req_fnum(req, req->in.vwv, VWV(0)); + info->getattr.level = RAW_FILEINFO_GETATTRE; + info->getattr.in.file.ntvfs = smbsrv_pull_fnum(req, req->in.vwv, VWV(0)); + SMBSRV_CHECK_FILE_HANDLE(info->getattr.in.file.ntvfs); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_qfileinfo(req->ntvfs, info)); } @@ -1987,27 +1993,82 @@ void smbsrv_reply_sesssetup(struct smbsrv_request *req) smbsrv_send_error(req, NT_STATUS_FOOBAR); } +/**************************************************************************** + Reply to a exit. This closes all files open by a smbpid +****************************************************************************/ +void smbsrv_reply_exit(struct smbsrv_request *req) +{ + struct smbsrv_handle_session_item *i, *ni; + struct smbsrv_handle *h; + struct smbsrv_tcon *tcon; + uint16_t smbpid; + + SMBSRV_CHECK_WCT(req, 0); + + smbpid = SVAL(req->in.hdr,HDR_PID); + + /* first destroy all handles, which have the same PID as the request */ + for (i=req->session->handles; i; i=ni) { + ni = i->next; + h = i->handle; + if (h->smbpid != smbpid) continue; + + talloc_free(h); + } + + /* + * then let the ntvfs backends proxy the call if they want to, + * but we didn't check the return value of the backends, + * as for the SMB client the call succeed + */ + for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { + req->tcon = tcon; + SMBSRV_SETUP_NTVFS_REQUEST(NULL,0); + ntvfs_exit(req->ntvfs); + talloc_free(req->ntvfs); + req->ntvfs = NULL; + req->tcon = NULL; + } + + smbsrv_setup_reply(req, 0, 0); + smbsrv_send_reply(req); +} + /**************************************************************************** Reply to a SMBulogoffX. ****************************************************************************/ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) { + struct smbsrv_handle_session_item *i, *ni; + struct smbsrv_handle *h; struct smbsrv_tcon *tcon; - NTSTATUS status; - /* in user level security we are supposed to close any files - open by this user on all open tree connects */ + SMBSRV_CHECK_WCT(req, 2); + + /* + * TODO: cancel all pending requests + */ + + + /* destroy all handles */ + for (i=req->session->handles; i; i=ni) { + ni = i->next; + h = i->handle; + talloc_free(h); + } + + /* + * then let the ntvfs backends proxy the call if they want to, + * but we didn't check the return value of the backends, + * as for the SMB client the call succeed + */ for (tcon=req->smb_conn->smb_tcons.list;tcon;tcon=tcon->next) { req->tcon = tcon; SMBSRV_SETUP_NTVFS_REQUEST(NULL,0); - status = ntvfs_logoff(req->ntvfs); + ntvfs_logoff(req->ntvfs); talloc_free(req->ntvfs); req->ntvfs = NULL; req->tcon = NULL; - if (!NT_STATUS_IS_OK(status)) { - smbsrv_send_error(req, status); - return; - } } talloc_free(req->session); @@ -2018,7 +2079,7 @@ void smbsrv_reply_ulogoffX(struct smbsrv_request *req) SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); SSVAL(req->out.vwv, VWV(1), 0); - + smbsrv_chain_reply(req); } @@ -2067,7 +2128,7 @@ static void reply_ntcreate_and_X_send(struct ntvfs_request *ntvfs) SCVAL(req->out.vwv, VWV(2), io->ntcreatex.out.oplock_level); /* the rest of the parameters are not aligned! */ - SSVAL(req->out.vwv, 5, io->ntcreatex.out.file.fnum); + smbsrv_push_fnum(req->out.vwv, 5, io->ntcreatex.out.file.ntvfs); SIVAL(req->out.vwv, 7, io->ntcreatex.out.create_action); push_nttime(req->out.vwv, 11, io->ntcreatex.out.create_time); push_nttime(req->out.vwv, 19, io->ntcreatex.out.access_time); @@ -2080,7 +2141,7 @@ static void reply_ntcreate_and_X_send(struct ntvfs_request *ntvfs) SSVAL(req->out.vwv, 65, io->ntcreatex.out.ipc_state); SCVAL(req->out.vwv, 67, io->ntcreatex.out.is_directory); - req->chained_fnum = io->ntcreatex.out.file.fnum; + req->chained_fnum = SVAL(req->out.vwv, 5); smbsrv_chain_reply(req); } -- cgit From 03e7d374616c4b0be3e9d62e5925ffb054b20642 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 23 May 2006 03:53:36 +0000 Subject: r15827: fixed a spelling error (This used to be commit 801357af2ef80fe270750c084a78142711ae9e6c) --- source4/smb_server/smb/reply.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 9abb35ad86..75830ae73a 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1239,7 +1239,7 @@ void smbsrv_reply_tdis(struct smbsrv_request *req) talloc_free(h); } - /* finaly destroy the tcon */ + /* finally destroy the tcon */ talloc_free(req->tcon); req->tcon = NULL; -- cgit From 3b36a857980b1f9fa5a6be0253e85c975f35c13f Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Tue, 11 Jul 2006 18:15:42 +0000 Subject: r16950: remove the smb mid from the ntvfs layer and keep a list of pending requests on the smbsrv_connection, to be able to match then on ntcancel metze (This used to be commit 04f0d3d03179b6060fd013b867d13caa92ec6460) --- source4/smb_server/smb/reply.c | 23 ++++++++++++++++++----- 1 file changed, 18 insertions(+), 5 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 75830ae73a..c79ad15ea8 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -633,7 +633,6 @@ void smbsrv_reply_readbraw(struct smbsrv_request *req) req->ntvfs = ntvfs_request_create(req->tcon->ntvfs, req, req->session->session_info, SVAL(req->in.hdr,HDR_PID), - SVAL(req->in.hdr,HDR_MID), req->request_time, req, NULL, 0); if (!req->ntvfs) { @@ -2197,10 +2196,24 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) ****************************************************************************/ void smbsrv_reply_ntcancel(struct smbsrv_request *req) { - /* NOTE: this request does not generate a reply */ - SMBSRV_SETUP_NTVFS_REQUEST(NULL,0); - ntvfs_cancel(req->ntvfs); - talloc_free(req); + struct smbsrv_request *r; + uint16_t mid = SVAL(req->in.hdr,HDR_MID); + uint16_t pid = SVAL(req->in.hdr,HDR_PID); + + for (r = req->smb_conn->requests; r; r = r->next) { + if (mid != SVAL(r->in.hdr,HDR_MID)) continue; + /* do we really need to check the PID? */ + if (pid != SVAL(r->in.hdr,HDR_PID)) continue; + + SMBSRV_CHECK(ntvfs_cancel(r->ntvfs)); + + /* NOTE: this request does not generate a reply */ + talloc_free(req); + return; + } + + /* TODO: workout the correct error code */ + smbsrv_send_error(req, NT_STATUS_FOOBAR); } /* -- cgit From e6b29409a29bdf99c45b2c0aefecb321904f2fd3 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Wed, 12 Jul 2006 14:15:06 +0000 Subject: r16979: - ntcancel should compare TID,UID,MID and PID - don't return ntcancel error, as we don't know how signing works for them metze (This used to be commit 20311e58d512e9fcc38ce786aaecf7246d182ca4) --- source4/smb_server/smb/reply.c | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index c79ad15ea8..256abc0c7c 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -2197,12 +2197,15 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) void smbsrv_reply_ntcancel(struct smbsrv_request *req) { struct smbsrv_request *r; + uint16_t tid = SVAL(req->in.hdr,HDR_TID); + uint16_t uid = SVAL(req->in.hdr,HDR_UID); uint16_t mid = SVAL(req->in.hdr,HDR_MID); uint16_t pid = SVAL(req->in.hdr,HDR_PID); for (r = req->smb_conn->requests; r; r = r->next) { + if (tid != SVAL(r->in.hdr,HDR_TID)) continue; + if (uid != SVAL(r->in.hdr,HDR_UID)) continue; if (mid != SVAL(r->in.hdr,HDR_MID)) continue; - /* do we really need to check the PID? */ if (pid != SVAL(r->in.hdr,HDR_PID)) continue; SMBSRV_CHECK(ntvfs_cancel(r->ntvfs)); @@ -2212,8 +2215,12 @@ void smbsrv_reply_ntcancel(struct smbsrv_request *req) return; } - /* TODO: workout the correct error code */ - smbsrv_send_error(req, NT_STATUS_FOOBAR); + /* TODO: workout the correct error code, + * until we know how the smb signing works + * for ntcancel replies, don't send an error + */ + /*smbsrv_send_error(req, NT_STATUS_FOOBAR);*/ + talloc_free(req); } /* -- cgit From 1575743c36e742403c48a15a61bb0afa518012d8 Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 27 Jul 2006 19:07:15 +0000 Subject: r17283: use the async calls of auth_check_password() and gensec_update() in the smb server. metze (This used to be commit 216e02c69cf5914487f0000d836d1082795487b2) --- source4/smb_server/smb/reply.c | 237 ++++++++++++++++++++++------------------- 1 file changed, 128 insertions(+), 109 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 256abc0c7c..dd5e964bae 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -1776,25 +1776,106 @@ void smbsrv_reply_getattrE(struct smbsrv_request *req) SMBSRV_CALL_NTVFS_BACKEND(ntvfs_qfileinfo(req->ntvfs, info)); } +void smbsrv_reply_sesssetup_send(struct smbsrv_request *req, + union smb_sesssetup *io, + NTSTATUS status) +{ + switch (io->old.level) { + case RAW_SESSSETUP_OLD: + if (!NT_STATUS_IS_OK(status)) { + smbsrv_send_error(req, status); + return; + } + + /* construct reply */ + smbsrv_setup_reply(req, 3, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), io->old.out.action); + + SSVAL(req->out.hdr, HDR_UID, io->old.out.vuid); + + smbsrv_chain_reply(req); + return; + + case RAW_SESSSETUP_NT1: + if (!NT_STATUS_IS_OK(status)) { + smbsrv_send_error(req, status); + return; + } + + /* construct reply */ + smbsrv_setup_reply(req, 3, 0); + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), io->nt1.out.action); + + SSVAL(req->out.hdr, HDR_UID, io->nt1.out.vuid); + + req_push_str(req, NULL, io->nt1.out.os, -1, STR_TERMINATE); + req_push_str(req, NULL, io->nt1.out.lanman, -1, STR_TERMINATE); + req_push_str(req, NULL, io->nt1.out.domain, -1, STR_TERMINATE); + + smbsrv_chain_reply(req); + return; + + case RAW_SESSSETUP_SPNEGO: + if (!NT_STATUS_IS_OK(status) && + !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + smbsrv_send_error(req, status); + return; + } + + /* construct reply */ + smbsrv_setup_reply(req, 4, io->spnego.out.secblob.length); + + if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { + smbsrv_setup_error(req, status); + } + + SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); + SSVAL(req->out.vwv, VWV(1), 0); + SSVAL(req->out.vwv, VWV(2), io->spnego.out.action); + SSVAL(req->out.vwv, VWV(3), io->spnego.out.secblob.length); + + SSVAL(req->out.hdr, HDR_UID, io->spnego.out.vuid); + + memcpy(req->out.data, io->spnego.out.secblob.data, io->spnego.out.secblob.length); + req_push_str(req, NULL, io->spnego.out.os, -1, STR_TERMINATE); + req_push_str(req, NULL, io->spnego.out.lanman, -1, STR_TERMINATE); + req_push_str(req, NULL, io->spnego.out.workgroup, -1, STR_TERMINATE); + + smbsrv_chain_reply(req); + return; + + case RAW_SESSSETUP_SMB2: + break; + } + + smbsrv_send_error(req, NT_STATUS_INTERNAL_ERROR); +} /**************************************************************************** reply to an old style session setup command ****************************************************************************/ static void reply_sesssetup_old(struct smbsrv_request *req) { - NTSTATUS status; - union smb_sesssetup sess; uint8_t *p; uint16_t passlen; + union smb_sesssetup *io; + + SMBSRV_TALLOC_IO_PTR(io, union smb_sesssetup); - sess.old.level = RAW_SESSSETUP_OLD; + io->old.level = RAW_SESSSETUP_OLD; /* parse request */ - sess.old.in.bufsize = SVAL(req->in.vwv, VWV(2)); - sess.old.in.mpx_max = SVAL(req->in.vwv, VWV(3)); - sess.old.in.vc_num = SVAL(req->in.vwv, VWV(4)); - sess.old.in.sesskey = IVAL(req->in.vwv, VWV(5)); - passlen = SVAL(req->in.vwv, VWV(7)); + io->old.in.bufsize = SVAL(req->in.vwv, VWV(2)); + io->old.in.mpx_max = SVAL(req->in.vwv, VWV(3)); + io->old.in.vc_num = SVAL(req->in.vwv, VWV(4)); + io->old.in.sesskey = IVAL(req->in.vwv, VWV(5)); + passlen = SVAL(req->in.vwv, VWV(7)); /* check the request isn't malformed */ if (req_data_oob(req, req->in.data, passlen)) { @@ -1803,58 +1884,42 @@ static void reply_sesssetup_old(struct smbsrv_request *req) } p = req->in.data; - if (!req_pull_blob(req, p, passlen, &sess.old.in.password)) { + if (!req_pull_blob(req, p, passlen, &io->old.in.password)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen; - p += req_pull_string(req, &sess.old.in.user, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.old.in.domain, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.old.in.os, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.old.in.lanman, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->old.in.user, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->old.in.domain, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->old.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->old.in.lanman, p, -1, STR_TERMINATE); /* call the generic handler */ - status = smbsrv_sesssetup_backend(req, &sess); - - if (!NT_STATUS_IS_OK(status)) { - smbsrv_send_error(req, status); - return; - } - - /* construct reply */ - smbsrv_setup_reply(req, 3, 0); - - SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); - SSVAL(req->out.vwv, VWV(1), 0); - SSVAL(req->out.vwv, VWV(2), sess.old.out.action); - - SSVAL(req->out.hdr, HDR_UID, sess.old.out.vuid); - - smbsrv_chain_reply(req); + smbsrv_sesssetup_backend(req, io); } - /**************************************************************************** reply to an NT1 style session setup command ****************************************************************************/ static void reply_sesssetup_nt1(struct smbsrv_request *req) { - NTSTATUS status; - union smb_sesssetup sess; uint8_t *p; uint16_t passlen1, passlen2; + union smb_sesssetup *io; + + SMBSRV_TALLOC_IO_PTR(io, union smb_sesssetup); - sess.nt1.level = RAW_SESSSETUP_NT1; + io->nt1.level = RAW_SESSSETUP_NT1; /* parse request */ - sess.nt1.in.bufsize = SVAL(req->in.vwv, VWV(2)); - sess.nt1.in.mpx_max = SVAL(req->in.vwv, VWV(3)); - sess.nt1.in.vc_num = SVAL(req->in.vwv, VWV(4)); - sess.nt1.in.sesskey = IVAL(req->in.vwv, VWV(5)); - passlen1 = SVAL(req->in.vwv, VWV(7)); - passlen2 = SVAL(req->in.vwv, VWV(8)); - sess.nt1.in.capabilities = IVAL(req->in.vwv, VWV(11)); + io->nt1.in.bufsize = SVAL(req->in.vwv, VWV(2)); + io->nt1.in.mpx_max = SVAL(req->in.vwv, VWV(3)); + io->nt1.in.vc_num = SVAL(req->in.vwv, VWV(4)); + io->nt1.in.sesskey = IVAL(req->in.vwv, VWV(5)); + passlen1 = SVAL(req->in.vwv, VWV(7)); + passlen2 = SVAL(req->in.vwv, VWV(8)); + io->nt1.in.capabilities = IVAL(req->in.vwv, VWV(11)); /* check the request isn't malformed */ if (req_data_oob(req, req->in.data, passlen1) || @@ -1864,44 +1929,24 @@ static void reply_sesssetup_nt1(struct smbsrv_request *req) } p = req->in.data; - if (!req_pull_blob(req, p, passlen1, &sess.nt1.in.password1)) { + if (!req_pull_blob(req, p, passlen1, &io->nt1.in.password1)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen1; - if (!req_pull_blob(req, p, passlen2, &sess.nt1.in.password2)) { + if (!req_pull_blob(req, p, passlen2, &io->nt1.in.password2)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen2; - p += req_pull_string(req, &sess.nt1.in.user, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.nt1.in.domain, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.nt1.in.os, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.nt1.in.lanman, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->nt1.in.user, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->nt1.in.domain, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->nt1.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->nt1.in.lanman, p, -1, STR_TERMINATE); /* call the generic handler */ - status = smbsrv_sesssetup_backend(req, &sess); - - if (!NT_STATUS_IS_OK(status)) { - smbsrv_send_error(req, status); - return; - } - - /* construct reply */ - smbsrv_setup_reply(req, 3, 0); - - SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); - SSVAL(req->out.vwv, VWV(1), 0); - SSVAL(req->out.vwv, VWV(2), sess.nt1.out.action); - - SSVAL(req->out.hdr, HDR_UID, sess.nt1.out.vuid); - - req_push_str(req, NULL, sess.nt1.out.os, -1, STR_TERMINATE); - req_push_str(req, NULL, sess.nt1.out.lanman, -1, STR_TERMINATE); - req_push_str(req, NULL, sess.nt1.out.domain, -1, STR_TERMINATE); - - smbsrv_chain_reply(req); + smbsrv_sesssetup_backend(req, io); } @@ -1910,61 +1955,35 @@ reply to an SPNEGO style session setup command ****************************************************************************/ static void reply_sesssetup_spnego(struct smbsrv_request *req) { - NTSTATUS status; - union smb_sesssetup sess; uint8_t *p; uint16_t blob_len; + union smb_sesssetup *io; - sess.spnego.level = RAW_SESSSETUP_SPNEGO; + SMBSRV_TALLOC_IO_PTR(io, union smb_sesssetup); + + io->spnego.level = RAW_SESSSETUP_SPNEGO; /* parse request */ - sess.spnego.in.bufsize = SVAL(req->in.vwv, VWV(2)); - sess.spnego.in.mpx_max = SVAL(req->in.vwv, VWV(3)); - sess.spnego.in.vc_num = SVAL(req->in.vwv, VWV(4)); - sess.spnego.in.sesskey = IVAL(req->in.vwv, VWV(5)); - blob_len = SVAL(req->in.vwv, VWV(7)); - sess.spnego.in.capabilities = IVAL(req->in.vwv, VWV(10)); + io->spnego.in.bufsize = SVAL(req->in.vwv, VWV(2)); + io->spnego.in.mpx_max = SVAL(req->in.vwv, VWV(3)); + io->spnego.in.vc_num = SVAL(req->in.vwv, VWV(4)); + io->spnego.in.sesskey = IVAL(req->in.vwv, VWV(5)); + blob_len = SVAL(req->in.vwv, VWV(7)); + io->spnego.in.capabilities = IVAL(req->in.vwv, VWV(10)); p = req->in.data; - if (!req_pull_blob(req, p, blob_len, &sess.spnego.in.secblob)) { + if (!req_pull_blob(req, p, blob_len, &io->spnego.in.secblob)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += blob_len; - p += req_pull_string(req, &sess.spnego.in.os, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.spnego.in.lanman, p, -1, STR_TERMINATE); - p += req_pull_string(req, &sess.spnego.in.workgroup, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->spnego.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->spnego.in.lanman, p, -1, STR_TERMINATE); + p += req_pull_string(req, &io->spnego.in.workgroup, p, -1, STR_TERMINATE); /* call the generic handler */ - status = smbsrv_sesssetup_backend(req, &sess); - - if (!NT_STATUS_IS_OK(status) && - !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { - smbsrv_send_error(req, status); - return; - } - - /* construct reply */ - smbsrv_setup_reply(req, 4, sess.spnego.out.secblob.length); - - if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) { - smbsrv_setup_error(req, status); - } - - SSVAL(req->out.vwv, VWV(0), SMB_CHAIN_NONE); - SSVAL(req->out.vwv, VWV(1), 0); - SSVAL(req->out.vwv, VWV(2), sess.spnego.out.action); - SSVAL(req->out.vwv, VWV(3), sess.spnego.out.secblob.length); - - SSVAL(req->out.hdr, HDR_UID, sess.spnego.out.vuid); - - memcpy(req->out.data, sess.spnego.out.secblob.data, sess.spnego.out.secblob.length); - req_push_str(req, NULL, sess.spnego.out.os, -1, STR_TERMINATE); - req_push_str(req, NULL, sess.spnego.out.lanman, -1, STR_TERMINATE); - req_push_str(req, NULL, sess.spnego.out.workgroup, -1, STR_TERMINATE); - - smbsrv_chain_reply(req); + smbsrv_sesssetup_backend(req, io); } -- cgit From 0479a2f1cbae51fcd8dbdc3c148c808421fb4d25 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Tue, 10 Jul 2007 02:07:03 +0000 Subject: r23792: convert Samba4 to GPLv3 There are still a few tidyups of old FSF addresses to come (in both s3 and s4). More commits soon. (This used to be commit fcf38a38ac691abd0fa51b89dc951a08e89fdafa) --- source4/smb_server/smb/reply.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index dd5e964bae..47963a205f 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -7,7 +7,7 @@ This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,8 +16,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with this program. If not, see . */ /* This file handles most of the reply_ calls that the server -- cgit From 0c56f8dac31c51a42dedf2a1da9fd76896855b19 Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Sat, 6 Oct 2007 22:10:49 +0000 Subject: r25551: Convert to standard bool type. (This used to be commit c9651e2c5c078edee7b91085e936a93625c8d708) --- source4/smb_server/smb/reply.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 47963a205f..aff0587bc6 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -824,9 +824,9 @@ void smbsrv_reply_read_and_X(struct smbsrv_request *req) io->readx.in.mincnt = SVAL(req->in.vwv, VWV(6)); io->readx.in.remaining = SVAL(req->in.vwv, VWV(9)); if (req->flags2 & FLAGS2_READ_PERMIT_EXECUTE) { - io->readx.in.read_for_execute = True; + io->readx.in.read_for_execute = true; } else { - io->readx.in.read_for_execute = False; + io->readx.in.read_for_execute = false; } if (req->smb_conn->negotiate.client_caps & CAP_LARGE_READX) { @@ -2272,7 +2272,7 @@ static NTSTATUS parse_session_request(struct smbsrv_request *req) req->smb_conn->negotiate.calling_name); NT_STATUS_NOT_OK_RETURN(status); - req->smb_conn->negotiate.done_nbt_session = True; + req->smb_conn->negotiate.done_nbt_session = true; return NT_STATUS_OK; } -- cgit From e870cfec9f3512b0f1bd3110d7b975652525e28a Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Thu, 14 Feb 2008 10:12:33 +1100 Subject: Convert SMB and SMB2 code to use a common buffer handling structure This converts our SMB and SMB2 code to use a common structure "struct request_bufinfo" for information on the buffer bounds of a packet, alignment information and string handling. This allows us to use a common backend for SMB and SMB2 code, while still using all the same string and blob handling functions. Up to now we had been passing a NULL req handle into these common routines from the SMB2 side of the server, which meant that we failed any operation which did a bounds checked string extraction (such as a RenameInformation setinfo call, which is what Vista uses for renaming files) There is still some more work to be done on this - for example we can now remove many of the SMB2 specific buffer handling functions that we had, and use the SMB ones. (This used to be commit ca6d9be6cb6a403a81b18fa6e9a6a0518d7f0f68) --- source4/smb_server/smb/reply.c | 94 +++++++++++++++++++++--------------------- 1 file changed, 47 insertions(+), 47 deletions(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index aff0587bc6..40cad91062 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -58,9 +58,9 @@ void smbsrv_reply_tcon(struct smbsrv_request *req) con.tcon.level = RAW_TCON_TCON; p = req->in.data; - p += req_pull_ascii4(req, &con.tcon.in.service, p, STR_TERMINATE); - p += req_pull_ascii4(req, &con.tcon.in.password, p, STR_TERMINATE); - p += req_pull_ascii4(req, &con.tcon.in.dev, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &con.tcon.in.service, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &con.tcon.in.password, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &con.tcon.in.dev, p, STR_TERMINATE); if (!con.tcon.in.service || !con.tcon.in.password || !con.tcon.in.dev) { smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER); @@ -106,14 +106,14 @@ void smbsrv_reply_tcon_and_X(struct smbsrv_request *req) p = req->in.data; - if (!req_pull_blob(req, p, passlen, &con.tconx.in.password)) { + if (!req_pull_blob(&req->in.bufinfo, p, passlen, &con.tconx.in.password)) { smbsrv_send_error(req, NT_STATUS_ILL_FORMED_PASSWORD); return; } p += passlen; - p += req_pull_string(req, &con.tconx.in.path, p, -1, STR_TERMINATE); - p += req_pull_string(req, &con.tconx.in.device, p, -1, STR_ASCII); + p += req_pull_string(&req->in.bufinfo, &con.tconx.in.path, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &con.tconx.in.device, p, -1, STR_ASCII); if (!con.tconx.in.path || !con.tconx.in.device) { smbsrv_send_error(req, NT_STATUS_BAD_DEVICE_TYPE); @@ -223,7 +223,7 @@ void smbsrv_reply_chkpth(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(io, union smb_chkpath); SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - req_pull_ascii4(req, &io->chkpath.in.path, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &io->chkpath.in.path, req->in.data, STR_TERMINATE); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_chkpath(req->ntvfs, io)); } @@ -264,7 +264,7 @@ void smbsrv_reply_getatr(struct smbsrv_request *req) st->getattr.level = RAW_FILEINFO_GETATTR; /* parse request */ - req_pull_ascii4(req, &st->getattr.in.file.path, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &st->getattr.in.file.path, req->in.data, STR_TERMINATE); if (!st->getattr.in.file.path) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); return; @@ -290,7 +290,7 @@ void smbsrv_reply_setatr(struct smbsrv_request *req) st->setattr.in.attrib = SVAL(req->in.vwv, VWV(0)); st->setattr.in.write_time = srv_pull_dos_date3(req->smb_conn, req->in.vwv + VWV(1)); - req_pull_ascii4(req, &st->setattr.in.file.path, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &st->setattr.in.file.path, req->in.data, STR_TERMINATE); if (!st->setattr.in.file.path) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); @@ -379,7 +379,7 @@ void smbsrv_reply_open(struct smbsrv_request *req) oi->openold.in.open_mode = SVAL(req->in.vwv, VWV(0)); oi->openold.in.search_attrs = SVAL(req->in.vwv, VWV(1)); - req_pull_ascii4(req, &oi->openold.in.fname, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &oi->openold.in.fname, req->in.data, STR_TERMINATE); if (!oi->openold.in.fname) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); @@ -452,7 +452,7 @@ void smbsrv_reply_open_and_X(struct smbsrv_request *req) oi->openx.in.size = IVAL(req->in.vwv, VWV(9)); oi->openx.in.timeout = IVAL(req->in.vwv, VWV(11)); - req_pull_ascii4(req, &oi->openx.in.fname, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &oi->openx.in.fname, req->in.data, STR_TERMINATE); if (!oi->openx.in.fname) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); @@ -502,7 +502,7 @@ void smbsrv_reply_mknew(struct smbsrv_request *req) 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)); - req_pull_ascii4(req, &oi->mknew.in.fname, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &oi->mknew.in.fname, req->in.data, STR_TERMINATE); if (!oi->mknew.in.fname) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); @@ -551,7 +551,7 @@ void smbsrv_reply_ctemp(struct smbsrv_request *req) /* the filename is actually a directory name, the server provides a filename in that directory */ - req_pull_ascii4(req, &oi->ctemp.in.directory, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &oi->ctemp.in.directory, req->in.data, STR_TERMINATE); if (!oi->ctemp.in.directory) { smbsrv_send_error(req, NT_STATUS_OBJECT_NAME_NOT_FOUND); @@ -576,7 +576,7 @@ void smbsrv_reply_unlink(struct smbsrv_request *req) unl->unlink.in.attrib = SVAL(req->in.vwv, VWV(0)); - req_pull_ascii4(req, &unl->unlink.in.pattern, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &unl->unlink.in.pattern, req->in.data, STR_TERMINATE); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_unlink(req->ntvfs, unl)); } @@ -958,7 +958,7 @@ void smbsrv_reply_write(struct smbsrv_request *req) io->write.in.data = req->in.data + 3; /* make sure they gave us the data they promised */ - if (req_data_oob(req, io->write.in.data, io->write.in.count)) { + if (req_data_oob(&req->in.bufinfo, io->write.in.data, io->write.in.count)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1027,7 +1027,7 @@ void smbsrv_reply_write_and_X(struct smbsrv_request *req) } /* make sure the data is in bounds */ - if (req_data_oob(req, io->writex.in.data, io->writex.in.count)) { + if (req_data_oob(&req->in.bufinfo, io->writex.in.data, io->writex.in.count)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1163,7 +1163,7 @@ void smbsrv_reply_writeclose(struct smbsrv_request *req) io->writeclose.in.data = req->in.data + 1; /* make sure they gave us the data they promised */ - if (req_data_oob(req, io->writeclose.in.data, io->writeclose.in.count)) { + if (req_data_oob(&req->in.bufinfo, io->writeclose.in.data, io->writeclose.in.count)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1313,7 +1313,7 @@ void smbsrv_reply_printopen(struct smbsrv_request *req) oi->splopen.in.setup_length = SVAL(req->in.vwv, VWV(0)); oi->splopen.in.mode = SVAL(req->in.vwv, VWV(1)); - req_pull_ascii4(req, &oi->splopen.in.ident, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &oi->splopen.in.ident, req->in.data, STR_TERMINATE); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_open(req->ntvfs, oi)); } @@ -1426,7 +1426,7 @@ void smbsrv_reply_printwrite(struct smbsrv_request *req) io->splwrite.in.data = req->in.data + 3; /* make sure they gave us the data they promised */ - if (req_data_oob(req, io->splwrite.in.data, io->splwrite.in.count)) { + if (req_data_oob(&req->in.bufinfo, io->splwrite.in.data, io->splwrite.in.count)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1449,7 +1449,7 @@ void smbsrv_reply_mkdir(struct smbsrv_request *req) SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); io->generic.level = RAW_MKDIR_MKDIR; - req_pull_ascii4(req, &io->mkdir.in.path, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &io->mkdir.in.path, req->in.data, STR_TERMINATE); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_mkdir(req->ntvfs, io)); } @@ -1467,7 +1467,7 @@ void smbsrv_reply_rmdir(struct smbsrv_request *req) SMBSRV_TALLOC_IO_PTR(io, struct smb_rmdir); SMBSRV_SETUP_NTVFS_REQUEST(reply_simple_send, NTVFS_ASYNC_STATE_MAY_ASYNC); - req_pull_ascii4(req, &io->in.path, req->in.data, STR_TERMINATE); + req_pull_ascii4(&req->in.bufinfo, &io->in.path, req->in.data, STR_TERMINATE); SMBSRV_CALL_NTVFS_BACKEND(ntvfs_rmdir(req->ntvfs, io)); } @@ -1490,8 +1490,8 @@ void smbsrv_reply_mv(struct smbsrv_request *req) io->rename.in.attrib = SVAL(req->in.vwv, VWV(0)); p = req->in.data; - p += req_pull_ascii4(req, &io->rename.in.pattern1, p, STR_TERMINATE); - p += req_pull_ascii4(req, &io->rename.in.pattern2, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &io->rename.in.pattern1, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &io->rename.in.pattern2, p, STR_TERMINATE); if (!io->rename.in.pattern1 || !io->rename.in.pattern2) { smbsrv_send_error(req, NT_STATUS_FOOBAR); @@ -1521,8 +1521,8 @@ void smbsrv_reply_ntrename(struct smbsrv_request *req) io->ntrename.in.cluster_size = IVAL(req->in.vwv, VWV(2)); p = req->in.data; - p += req_pull_ascii4(req, &io->ntrename.in.old_name, p, STR_TERMINATE); - p += req_pull_ascii4(req, &io->ntrename.in.new_name, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &io->ntrename.in.old_name, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &io->ntrename.in.new_name, p, STR_TERMINATE); if (!io->ntrename.in.old_name || !io->ntrename.in.new_name) { smbsrv_send_error(req, NT_STATUS_FOOBAR); @@ -1568,8 +1568,8 @@ void smbsrv_reply_copy(struct smbsrv_request *req) cp->in.flags = SVAL(req->in.vwv, VWV(2)); p = req->in.data; - p += req_pull_ascii4(req, &cp->in.path1, p, STR_TERMINATE); - p += req_pull_ascii4(req, &cp->in.path2, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &cp->in.path1, p, STR_TERMINATE); + p += req_pull_ascii4(&req->in.bufinfo, &cp->in.path2, p, STR_TERMINATE); if (!cp->in.path1 || !cp->in.path2) { smbsrv_send_error(req, NT_STATUS_FOOBAR); @@ -1638,7 +1638,7 @@ void smbsrv_reply_lockingX(struct smbsrv_request *req) } /* make sure we got the promised data */ - if (req_data_oob(req, req->in.data, total_locks * lck_size)) { + if (req_data_oob(&req->in.bufinfo, req->in.data, total_locks * lck_size)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } @@ -1877,22 +1877,22 @@ static void reply_sesssetup_old(struct smbsrv_request *req) passlen = SVAL(req->in.vwv, VWV(7)); /* check the request isn't malformed */ - if (req_data_oob(req, req->in.data, passlen)) { + if (req_data_oob(&req->in.bufinfo, req->in.data, passlen)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p = req->in.data; - if (!req_pull_blob(req, p, passlen, &io->old.in.password)) { + if (!req_pull_blob(&req->in.bufinfo, p, passlen, &io->old.in.password)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen; - p += req_pull_string(req, &io->old.in.user, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->old.in.domain, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->old.in.os, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->old.in.lanman, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->old.in.user, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->old.in.domain, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->old.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->old.in.lanman, p, -1, STR_TERMINATE); /* call the generic handler */ smbsrv_sesssetup_backend(req, io); @@ -1921,28 +1921,28 @@ static void reply_sesssetup_nt1(struct smbsrv_request *req) io->nt1.in.capabilities = IVAL(req->in.vwv, VWV(11)); /* check the request isn't malformed */ - if (req_data_oob(req, req->in.data, passlen1) || - req_data_oob(req, req->in.data + passlen1, passlen2)) { + if (req_data_oob(&req->in.bufinfo, req->in.data, passlen1) || + req_data_oob(&req->in.bufinfo, req->in.data + passlen1, passlen2)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p = req->in.data; - if (!req_pull_blob(req, p, passlen1, &io->nt1.in.password1)) { + if (!req_pull_blob(&req->in.bufinfo, p, passlen1, &io->nt1.in.password1)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen1; - if (!req_pull_blob(req, p, passlen2, &io->nt1.in.password2)) { + if (!req_pull_blob(&req->in.bufinfo, p, passlen2, &io->nt1.in.password2)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += passlen2; - p += req_pull_string(req, &io->nt1.in.user, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->nt1.in.domain, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->nt1.in.os, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->nt1.in.lanman, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->nt1.in.user, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->nt1.in.domain, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->nt1.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->nt1.in.lanman, p, -1, STR_TERMINATE); /* call the generic handler */ smbsrv_sesssetup_backend(req, io); @@ -1971,15 +1971,15 @@ static void reply_sesssetup_spnego(struct smbsrv_request *req) io->spnego.in.capabilities = IVAL(req->in.vwv, VWV(10)); p = req->in.data; - if (!req_pull_blob(req, p, blob_len, &io->spnego.in.secblob)) { + if (!req_pull_blob(&req->in.bufinfo, p, blob_len, &io->spnego.in.secblob)) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; } p += blob_len; - p += req_pull_string(req, &io->spnego.in.os, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->spnego.in.lanman, p, -1, STR_TERMINATE); - p += req_pull_string(req, &io->spnego.in.workgroup, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->spnego.in.os, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->spnego.in.lanman, p, -1, STR_TERMINATE); + p += req_pull_string(&req->in.bufinfo, &io->spnego.in.workgroup, p, -1, STR_TERMINATE); /* call the generic handler */ smbsrv_sesssetup_backend(req, io); @@ -2199,7 +2199,7 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) fname_len++; } - req_pull_string(req, &io->ntcreatex.in.fname, req->in.data, fname_len, STR_TERMINATE); + req_pull_string(&req->in.bufinfo, &io->ntcreatex.in.fname, req->in.data, fname_len, STR_TERMINATE); if (!io->ntcreatex.in.fname) { smbsrv_send_error(req, NT_STATUS_FOOBAR); return; -- cgit From 2ad2bdda89c07c0b8ce754c3b0cd4664eefc697d Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Mon, 26 May 2008 15:02:43 +1000 Subject: stricter checks for valid inputs in SMB2 open and lock (This used to be commit a7b5689a73adde59de28770aa3949660441291ea) --- source4/smb_server/smb/reply.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index 40cad91062..d28f4b6072 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -2193,6 +2193,11 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) io->ntcreatex.in.ea_list = NULL; io->ntcreatex.in.sec_desc = NULL; + /* we use a couple of bits of the create options internally */ + if (io->ntcreatex.in.create_options & NTCREATEX_OPTIONS_PRIVATE_MASK) { + return NT_STATUS_INVALID_PARAMETER; + } + /* we need a neater way to handle this alignment */ if ((req->flags2 & FLAGS2_UNICODE_STRINGS) && ucs2_align(req->in.buffer, req->in.data, STR_TERMINATE|STR_UNICODE)) { -- cgit From f85cfa91616224226c4748e002a363828433b78b Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Wed, 28 May 2008 11:47:39 +1000 Subject: make sure we send a reply packet for bad create options (This used to be commit f9b94f62998aef5f5f3879ac3cfba93016fa521b) --- source4/smb_server/smb/reply.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index d28f4b6072..d7ed052ba0 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -2195,7 +2195,8 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) /* we use a couple of bits of the create options internally */ if (io->ntcreatex.in.create_options & NTCREATEX_OPTIONS_PRIVATE_MASK) { - return NT_STATUS_INVALID_PARAMETER; + smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER); + return; } /* we need a neater way to handle this alignment */ -- cgit From 091c141abae41f58a75e4b4cbcc4154b5c3343eb Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Thu, 24 Jul 2008 14:20:02 +1000 Subject: make sure we initialise query_maximal_access (This used to be commit 036f73d39a7ef882fd76afcd3c11eef483f6c308) --- source4/smb_server/smb/reply.c | 1 + 1 file changed, 1 insertion(+) (limited to 'source4/smb_server/smb/reply.c') diff --git a/source4/smb_server/smb/reply.c b/source4/smb_server/smb/reply.c index d7ed052ba0..9c4ee993d2 100644 --- a/source4/smb_server/smb/reply.c +++ b/source4/smb_server/smb/reply.c @@ -2192,6 +2192,7 @@ void smbsrv_reply_ntcreate_and_X(struct smbsrv_request *req) io->ntcreatex.in.security_flags = CVAL(req->in.vwv, 47); io->ntcreatex.in.ea_list = NULL; io->ntcreatex.in.sec_desc = NULL; + io->ntcreatex.in.query_maximal_access = false; /* we use a couple of bits of the create options internally */ if (io->ntcreatex.in.create_options & NTCREATEX_OPTIONS_PRIVATE_MASK) { -- cgit