sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-25 23:21:54 +03:00
Code

Merge branch 'v4-0-test' of ssh://git.samba.org/data/git/samba into 4-0-abartlet

Browse Source 
(This used to be commit 13a0941d34)
This commit is contained in:
Andrew Bartlett 2008-04-19 09:59:07 +02:00
commit 61fba82594
13 changed files with 500 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
source4/build/make/rules.mk
View File

@ -211,7 +211,9 @@ include/includes.d: include/includes.h
@echo "Compiling $<"
@-mkdir -p `dirname $@`
@$(COMPILE) && exit 0 ; \
$(COMPILE)
echo "The following command failed:" 1>&2;\
echo "$(COMPILE)" 1>&2;\
$(COMPILE) >/dev/null 2>&1

17
source4/libcli/raw/interfaces.h
View File

@ -1862,7 +1862,8 @@ enum smb_lock_level {
RAW_LOCK_LOCK,
RAW_LOCK_UNLOCK,
RAW_LOCK_LOCKX,
RAW_LOCK_SMB2
RAW_LOCK_SMB2,
RAW_LOCK_SMB2_BREAK
};
/* the generic interface is defined to be equal to the lockingX interface */
@ -1925,6 +1926,20 @@ union smb_lock {
uint16_t unknown1;
} out;
} smb2;
/* SMB2 Break */
struct smb2_break {
enum smb_lock_level level;
struct {
union smb_handle file;
/* static body buffer 24 (0x18) bytes */
uint8_t oplock_level;
uint8_t reserved;
uint32_t reserved2;
/* struct smb2_handle handle; */
} in, out;
} smb2_break;
};

74
source4/libcli/smb2/break.c Normal file
View File

@ -0,0 +1,74 @@
/*
Unix SMB/CIFS implementation.
SMB2 client oplock break handling
Copyright (C) Stefan Metzmacher 2008
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
/*
send a break request
*/
struct smb2_request *smb2_break_send(struct smb2_tree *tree, struct smb2_break *io)
{
struct smb2_request *req;
req = smb2_request_init_tree(tree, SMB2_OP_BREAK, 0x18, false, 0);
if (req == NULL) return NULL;
SCVAL(req->out.body, 0x02, io->in.oplock_level);
SCVAL(req->out.body, 0x03, io->in.reserved);
SIVAL(req->out.body, 0x04, io->in.reserved2);
smb2_push_handle(req->out.body+0x08, &io->in.file.handle);
smb2_transport_send(req);
return req;
}
/*
recv a break reply
*/
NTSTATUS smb2_break_recv(struct smb2_request *req, struct smb2_break *io)
{
if (!smb2_request_receive(req) ||
!smb2_request_is_ok(req)) {
return smb2_request_destroy(req);
}
SMB2_CHECK_PACKET_RECV(req, 0x18, false);
io->out.oplock_level = CVAL(req->in.body, 0x02);
io->out.reserved = CVAL(req->in.body, 0x03);
io->out.reserved2 = IVAL(req->in.body, 0x04);
smb2_pull_handle(req->in.body+0x08, &io->out.file.handle);
return smb2_request_destroy(req);
}
/*
sync flush request
*/
NTSTATUS smb2_break(struct smb2_tree *tree, struct smb2_break *io)
{
struct smb2_request *req = smb2_break_send(tree, io);
return smb2_break_recv(req, io);
}

2
source4/libcli/smb2/config.mk
View File

@ -6,5 +6,5 @@ LIBCLI_SMB2_OBJ_FILES = $(addprefix libcli/smb2/, \
transport.o request.o negprot.o session.o tcon.o \
create.o close.o connect.o getinfo.o write.o read.o \
setinfo.o find.o ioctl.o logoff.o tdis.o flush.o \
lock.o notify.o cancel.o keepalive.o)
lock.o notify.o cancel.o keepalive.o break.o)

11
source4/libcli/smb2/smb2.h
View File

@ -21,6 +21,8 @@
#include "libcli/raw/request.h"
struct smb2_handle;
struct smb2_options {
uint32_t timeout;
};
@ -58,6 +60,15 @@ struct smb2_transport {
void *private;
uint_t period;
} idle;
struct {
/* a oplock break request handler */
bool (*handler)(struct smb2_transport *transport,
const struct smb2_handle *handle,
uint8_t level, void *private_data);
/* private data passed to the oplock handler */
void *private_data;
} oplock;
};

43
source4/libcli/smb2/transport.c
View File

@ -140,6 +140,44 @@ void smb2_transport_dead(struct smb2_transport *transport, NTSTATUS status)
}
}
static bool smb2_handle_oplock_break(struct smb2_transport *transport,
const DATA_BLOB *blob)
{
uint8_t *hdr;
uint16_t opcode;
uint64_t seqnum;
hdr = blob->data+NBT_HDR_SIZE;
if (blob->length < (SMB2_MIN_SIZE+0x18)) {
DEBUG(1,("Discarding smb2 oplock reply of size %u\n",
blob->length));
return false;
}
opcode = SVAL(hdr, SMB2_HDR_OPCODE);
seqnum = BVAL(hdr, SMB2_HDR_MESSAGE_ID);
if ((opcode != SMB2_OP_BREAK) ||
(seqnum != UINT64_MAX)) {
return false;
}
if (transport->oplock.handler) {
uint8_t *body = hdr+SMB2_HDR_BODY;
struct smb2_handle h;
uint8_t level;
level = CVAL(body, 0x02);
smb2_pull_handle(body+0x08, &h);
transport->oplock.handler(transport, &h, level,
transport->oplock.private_data);
}
return true;
}
/*
we have a full request in our receive buffer - match it to a pending request
and process
@ -167,6 +205,11 @@ static NTSTATUS smb2_transport_finish_recv(void *private, DATA_BLOB blob)
goto error;
}
if (smb2_handle_oplock_break(transport, &blob)) {
talloc_free(buffer);
return NT_STATUS_OK;
}
flags = IVAL(hdr, SMB2_HDR_FLAGS);
seqnum = BVAL(hdr, SMB2_HDR_MESSAGE_ID);

23
source4/ntvfs/ntvfs_generic.c
View File

@ -209,13 +209,13 @@ static NTSTATUS ntvfs_map_open_finish(struct ntvfs_module_context *ntvfs,
case RAW_OPEN_SMB2:
io->smb2.out.file.ntvfs = io2->generic.out.file.ntvfs;
switch (io2->generic.out.oplock_level) {
case OPLOCK_BATCH:
case BATCH_OPLOCK_RETURN:
io->smb2.out.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
break;
case OPLOCK_EXCLUSIVE:
case EXCLUSIVE_OPLOCK_RETURN:
io->smb2.out.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
break;
case OPLOCK_LEVEL_II:
case LEVEL_II_OPLOCK_RETURN:
io->smb2.out.oplock_level = SMB2_OPLOCK_LEVEL_II;
break;
default:
@ -1043,6 +1043,23 @@ NTSTATUS ntvfs_map_lock(struct ntvfs_module_context *ntvfs,
/* initialize output value */
lck->smb2.out.unknown1 = 0;
break;
case RAW_LOCK_SMB2_BREAK:
lck2->generic.level = RAW_LOCK_GENERIC;
lck2->generic.in.file.ntvfs = lck->smb2_break.in.file.ntvfs;
lck2->generic.in.mode = LOCKING_ANDX_OPLOCK_RELEASE |
((lck->smb2_break.in.oplock_level << 8) & 0xFF00);
lck2->generic.in.timeout = 0;
lck2->generic.in.ulock_cnt = 0;
lck2->generic.in.lock_cnt = 0;
lck2->generic.in.locks = NULL;
/* initialize output value */
lck->smb2_break.out.oplock_level= lck->smb2_break.in.oplock_level;
lck->smb2_break.out.reserved = lck->smb2_break.in.reserved;
lck->smb2_break.out.reserved2 = lck->smb2_break.in.reserved2;
lck->smb2_break.out.file = lck->smb2_break.in.file;
break;
}
/*

227
source4/smb_server/smb/receive.c
View File

@ -65,111 +65,16 @@ NTSTATUS smbsrv_send_oplock_break(void *p, struct ntvfs_handle *ntvfs, uint8_t l
static void switch_message(int type, struct smbsrv_request *req);
/****************************************************************************
receive a SMB request header from the wire, forming a request_context
from the result
****************************************************************************/
NTSTATUS smbsrv_recv_smb_request(void *private, DATA_BLOB blob)
{
struct smbsrv_connection *smb_conn = talloc_get_type(private, struct smbsrv_connection);
struct smbsrv_request *req;
struct timeval cur_time = timeval_current();
uint8_t command;
smb_conn->statistics.last_request_time = cur_time;
/* see if its a special NBT packet */
if (CVAL(blob.data, 0) != 0) {
req = smbsrv_init_request(smb_conn);
NT_STATUS_HAVE_NO_MEMORY(req);
ZERO_STRUCT(req->in);
req->in.buffer = talloc_steal(req, blob.data);
req->in.size = blob.length;
req->request_time = cur_time;
smbsrv_reply_special(req);
return NT_STATUS_OK;
}
if ((NBT_HDR_SIZE + MIN_SMB_SIZE) > blob.length) {
DEBUG(2,("Invalid SMB packet: length %ld\n", (long)blob.length));
smbsrv_terminate_connection(smb_conn, "Invalid SMB packet");
return NT_STATUS_OK;
}
/* Make sure this is an SMB packet */
if (IVAL(blob.data, NBT_HDR_SIZE) != SMB_MAGIC) {
DEBUG(2,("Non-SMB packet of length %ld. Terminating connection\n",
(long)blob.length));
smbsrv_terminate_connection(smb_conn, "Non-SMB packet");
return NT_STATUS_OK;
}
req = smbsrv_init_request(smb_conn);
NT_STATUS_HAVE_NO_MEMORY(req);
req->in.buffer = talloc_steal(req, blob.data);
req->in.size = blob.length;
req->request_time = cur_time;
req->chained_fnum = -1;
req->in.allocated = req->in.size;
req->in.hdr = req->in.buffer + NBT_HDR_SIZE;
req->in.vwv = req->in.hdr + HDR_VWV;
req->in.wct = CVAL(req->in.hdr, HDR_WCT);
if (req->in.vwv + VWV(req->in.wct) <= req->in.buffer + req->in.size) {
req->in.data = req->in.vwv + VWV(req->in.wct) + 2;
req->in.data_size = SVAL(req->in.vwv, VWV(req->in.wct));
/* the bcc length is only 16 bits, but some packets
(such as SMBwriteX) can be much larger than 64k. We
detect this by looking for a large non-chained NBT
packet (at least 64k bigger than what is
specified). If it is detected then the NBT size is
used instead of the bcc size */
if (req->in.data_size + 0x10000 <=
req->in.size - PTR_DIFF(req->in.data, req->in.buffer) &&
(req->in.wct < 1 || SVAL(req->in.vwv, VWV(0)) == SMB_CHAIN_NONE)) {
/* its an oversized packet! fun for all the family */
req->in.data_size = req->in.size - PTR_DIFF(req->in.data,req->in.buffer);
}
}
if (NBT_HDR_SIZE + MIN_SMB_SIZE + 2*req->in.wct > req->in.size) {
DEBUG(2,("Invalid SMB word count %d\n", req->in.wct));
smbsrv_terminate_connection(req->smb_conn, "Invalid SMB packet");
return NT_STATUS_OK;
}
if (NBT_HDR_SIZE + MIN_SMB_SIZE + 2*req->in.wct + req->in.data_size > req->in.size) {
DEBUG(2,("Invalid SMB buffer length count %d\n",
(int)req->in.data_size));
smbsrv_terminate_connection(req->smb_conn, "Invalid SMB packet");
return NT_STATUS_OK;
}
req->flags2 = SVAL(req->in.hdr, HDR_FLG2);
/* fix the bufinfo */
smbsrv_setup_bufinfo(req);
if (!smbsrv_signing_check_incoming(req)) {
smbsrv_send_error(req, NT_STATUS_ACCESS_DENIED);
return NT_STATUS_OK;
}
command = CVAL(req->in.hdr, HDR_COM);
switch_message(command, req);
return NT_STATUS_OK;
}
/*
These flags determine some of the permissions required to do an operation
*/
#define NEED_SESS (1<<0)
#define NEED_TCON (1<<1)
#define SIGNING_NO_REPLY (1<<2)
/* does VWV(0) of the request hold chaining information */
#define AND_X (1<<3)
/* The 64Kb question: are requests > 64K valid? */
#define LARGE_REQUEST (1<<4)
/*
define a list of possible SMB messages and their corresponding
@ -180,6 +85,7 @@ static const struct smb_message_struct
{
const char *name;
void (*fn)(struct smbsrv_request *);
#define message_flags(type) smb_messages[(type) & 0xff].flags
int flags;
}
smb_messages[256] = {
@ -219,7 +125,7 @@ static const struct smb_message_struct
/* 0x21 */ { NULL, NULL, 0 },
/* 0x22 */ { "SMBsetattrE", smbsrv_reply_setattrE, NEED_SESS|NEED_TCON },
/* 0x23 */ { "SMBgetattrE", smbsrv_reply_getattrE, NEED_SESS|NEED_TCON },
/* 0x24 */ { "SMBlockingX", smbsrv_reply_lockingX, NEED_SESS|NEED_TCON },
/* 0x24 */ { "SMBlockingX", smbsrv_reply_lockingX, NEED_SESS|NEED_TCON|AND_X },
/* 0x25 */ { "SMBtrans", smbsrv_reply_trans, NEED_SESS|NEED_TCON },
/* 0x26 */ { "SMBtranss", smbsrv_reply_transs, NEED_SESS|NEED_TCON },
/* 0x27 */ { "SMBioctl", smbsrv_reply_ioctl, NEED_SESS|NEED_TCON },
@ -228,9 +134,9 @@ static const struct smb_message_struct
/* 0x2a */ { "SMBmove", NULL, NEED_SESS|NEED_TCON },
/* 0x2b */ { "SMBecho", smbsrv_reply_echo, 0 },
/* 0x2c */ { "SMBwriteclose", smbsrv_reply_writeclose, NEED_SESS|NEED_TCON },
/* 0x2d */ { "SMBopenX", smbsrv_reply_open_and_X, NEED_SESS|NEED_TCON },
/* 0x2e */ { "SMBreadX", smbsrv_reply_read_and_X, NEED_SESS|NEED_TCON },
/* 0x2f */ { "SMBwriteX", smbsrv_reply_write_and_X, NEED_SESS|NEED_TCON},
/* 0x2d */ { "SMBopenX", smbsrv_reply_open_and_X, NEED_SESS|NEED_TCON|AND_X },
/* 0x2e */ { "SMBreadX", smbsrv_reply_read_and_X, NEED_SESS|NEED_TCON|AND_X },
/* 0x2f */ { "SMBwriteX", smbsrv_reply_write_and_X, NEED_SESS|NEED_TCON|AND_X|LARGE_REQUEST},
/* 0x30 */ { NULL, NULL, 0 },
/* 0x31 */ { NULL, NULL, 0 },
/* 0x32 */ { "SMBtrans2", smbsrv_reply_trans2, NEED_SESS|NEED_TCON },
@ -298,9 +204,9 @@ static const struct smb_message_struct
/* 0x70 */ { "SMBtcon", smbsrv_reply_tcon, NEED_SESS },
/* 0x71 */ { "SMBtdis", smbsrv_reply_tdis, NEED_TCON },
/* 0x72 */ { "SMBnegprot", smbsrv_reply_negprot, 0 },
/* 0x73 */ { "SMBsesssetupX", smbsrv_reply_sesssetup, 0 },
/* 0x74 */ { "SMBulogoffX", smbsrv_reply_ulogoffX, NEED_SESS }, /* ulogoff doesn't give a valid TID */
/* 0x75 */ { "SMBtconX", smbsrv_reply_tcon_and_X, NEED_SESS },
/* 0x73 */ { "SMBsesssetupX", smbsrv_reply_sesssetup, AND_X },
/* 0x74 */ { "SMBulogoffX", smbsrv_reply_ulogoffX, NEED_SESS|AND_X }, /* ulogoff doesn't give a valid TID */
/* 0x75 */ { "SMBtconX", smbsrv_reply_tcon_and_X, NEED_SESS|AND_X },
/* 0x76 */ { NULL, NULL, 0 },
/* 0x77 */ { NULL, NULL, 0 },
/* 0x78 */ { NULL, NULL, 0 },
@ -343,9 +249,9 @@ static const struct smb_message_struct
/* 0x9d */ { NULL, NULL, 0 },
/* 0x9e */ { NULL, NULL, 0 },
/* 0x9f */ { NULL, NULL, 0 },
/* 0xa0 */ { "SMBnttrans", smbsrv_reply_nttrans, NEED_SESS|NEED_TCON },
/* 0xa0 */ { "SMBnttrans", smbsrv_reply_nttrans, NEED_SESS|NEED_TCON|LARGE_REQUEST },
/* 0xa1 */ { "SMBnttranss", smbsrv_reply_nttranss, NEED_SESS|NEED_TCON },
/* 0xa2 */ { "SMBntcreateX", smbsrv_reply_ntcreate_and_X, NEED_SESS|NEED_TCON },
/* 0xa2 */ { "SMBntcreateX", smbsrv_reply_ntcreate_and_X, NEED_SESS|NEED_TCON|AND_X },
/* 0xa3 */ { NULL, NULL, 0 },
/* 0xa4 */ { "SMBntcancel", smbsrv_reply_ntcancel, NEED_SESS|NEED_TCON|SIGNING_NO_REPLY },
/* 0xa5 */ { "SMBntrename", smbsrv_reply_ntrename, NEED_SESS|NEED_TCON },
@ -441,6 +347,111 @@ static const struct smb_message_struct
/* 0xff */ { NULL, NULL, 0 }
};
/****************************************************************************
receive a SMB request header from the wire, forming a request_context
from the result
****************************************************************************/
NTSTATUS smbsrv_recv_smb_request(void *private, DATA_BLOB blob)
{
struct smbsrv_connection *smb_conn = talloc_get_type(private, struct smbsrv_connection);
struct smbsrv_request *req;
struct timeval cur_time = timeval_current();
uint8_t command;
smb_conn->statistics.last_request_time = cur_time;
/* see if its a special NBT packet */
if (CVAL(blob.data, 0) != 0) {
req = smbsrv_init_request(smb_conn);
NT_STATUS_HAVE_NO_MEMORY(req);
ZERO_STRUCT(req->in);
req->in.buffer = talloc_steal(req, blob.data);
req->in.size = blob.length;
req->request_time = cur_time;
smbsrv_reply_special(req);
return NT_STATUS_OK;
}
if ((NBT_HDR_SIZE + MIN_SMB_SIZE) > blob.length) {
DEBUG(2,("Invalid SMB packet: length %ld\n", (long)blob.length));
smbsrv_terminate_connection(smb_conn, "Invalid SMB packet");
return NT_STATUS_OK;
}
/* Make sure this is an SMB packet */
if (IVAL(blob.data, NBT_HDR_SIZE) != SMB_MAGIC) {
DEBUG(2,("Non-SMB packet of length %ld. Terminating connection\n",
(long)blob.length));
smbsrv_terminate_connection(smb_conn, "Non-SMB packet");
return NT_STATUS_OK;
}
req = smbsrv_init_request(smb_conn);
NT_STATUS_HAVE_NO_MEMORY(req);
req->in.buffer = talloc_steal(req, blob.data);
req->in.size = blob.length;
req->request_time = cur_time;
req->chained_fnum = -1;
req->in.allocated = req->in.size;
req->in.hdr = req->in.buffer + NBT_HDR_SIZE;
req->in.vwv = req->in.hdr + HDR_VWV;
req->in.wct = CVAL(req->in.hdr, HDR_WCT);
command = CVAL(req->in.hdr, HDR_COM);
if (req->in.vwv + VWV(req->in.wct) <= req->in.buffer + req->in.size) {
req->in.data = req->in.vwv + VWV(req->in.wct) + 2;
req->in.data_size = SVAL(req->in.vwv, VWV(req->in.wct));
/* the bcc length is only 16 bits, but some packets
(such as SMBwriteX) can be much larger than 64k. We
detect this by looking for a large non-chained NBT
packet (at least 64k bigger than what is
specified). If it is detected then the NBT size is
used instead of the bcc size */
if (req->in.data_size + 0x10000 <=
req->in.size - PTR_DIFF(req->in.data, req->in.buffer) &&
( message_flags(command) & LARGE_REQUEST) &&
( !(message_flags(command) & AND_X) ||
(req->in.wct < 1 || SVAL(req->in.vwv, VWV(0)) == SMB_CHAIN_NONE) )
) {
/* its an oversized packet! fun for all the family */
req->in.data_size = req->in.size - PTR_DIFF(req->in.data,req->in.buffer);
}
}
if (NBT_HDR_SIZE + MIN_SMB_SIZE + 2*req->in.wct > req->in.size) {
DEBUG(2,("Invalid SMB word count %d\n", req->in.wct));
smbsrv_terminate_connection(req->smb_conn, "Invalid SMB packet");
return NT_STATUS_OK;
}
if (NBT_HDR_SIZE + MIN_SMB_SIZE + 2*req->in.wct + req->in.data_size > req->in.size) {
DEBUG(2,("Invalid SMB buffer length count %d\n",
(int)req->in.data_size));
smbsrv_terminate_connection(req->smb_conn, "Invalid SMB packet");
return NT_STATUS_OK;
}
req->flags2 = SVAL(req->in.hdr, HDR_FLG2);
/* fix the bufinfo */
smbsrv_setup_bufinfo(req);
if (!smbsrv_signing_check_incoming(req)) {
smbsrv_send_error(req, NT_STATUS_ACCESS_DENIED);
return NT_STATUS_OK;
}
command = CVAL(req->in.hdr, HDR_COM);
switch_message(command, req);
return NT_STATUS_OK;
}
/****************************************************************************
return a string containing the function name of a SMB command
****************************************************************************/

31
source4/smb_server/smb2/fileio.c
View File

@ -410,7 +410,36 @@ void smb2srv_notify_recv(struct smb2srv_request *req)
SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_notify(req->ntvfs, io));
}
static void smb2srv_break_send(struct ntvfs_request *ntvfs)
{
struct smb2srv_request *req;
union smb_lock *io;
SMB2SRV_CHECK_ASYNC_STATUS_ERR(io, union smb_lock);
SMB2SRV_CHECK(smb2srv_setup_reply(req, 0x18, false, 0));
SCVAL(req->out.body, 0x02, io->smb2_break.out.oplock_level);
SCVAL(req->out.body, 0x03, io->smb2_break.out.reserved);
SIVAL(req->out.body, 0x04, io->smb2_break.out.reserved2);
smb2srv_push_handle(req->out.body, 0x08,io->smb2_break.out.file.ntvfs);
smb2srv_send_reply(req);
}
void smb2srv_break_recv(struct smb2srv_request *req)
{
smb2srv_send_error(req, NT_STATUS_NOT_IMPLEMENTED);
union smb_lock *io;
SMB2SRV_CHECK_BODY_SIZE(req, 0x18, false);
SMB2SRV_TALLOC_IO_PTR(io, union smb_lock);
SMB2SRV_SETUP_NTVFS_REQUEST(smb2srv_break_send, NTVFS_ASYNC_STATE_MAY_ASYNC);
io->smb2_break.level = RAW_LOCK_SMB2_BREAK;
io->smb2_break.in.oplock_level = CVAL(req->in.body, 0x02);
io->smb2_break.in.reserved = CVAL(req->in.body, 0x03);
io->smb2_break.in.reserved2 = IVAL(req->in.body, 0x04);
io->smb2_break.in.file.ntvfs = smb2srv_pull_handle(req, req->in.body, 0x08);
SMB2SRV_CHECK_FILE_HANDLE(io->smb2_break.in.file.ntvfs);
SMB2SRV_CALL_NTVFS_BACKEND(ntvfs_lock(req->ntvfs, io));
}

3
source4/torture/smb2/config.mk
View File

@ -21,5 +21,6 @@ TORTURE_SMB2_OBJ_FILES = $(addprefix torture/smb2/, \
lock.o \
notify.o \
smb2.o \
persistent_handles.o)
persistent_handles.o \
oplocks.o)

178
source4/torture/smb2/oplocks.c Normal file
View File

@ -0,0 +1,178 @@
/*
Unix SMB/CIFS implementation.
test suite for SMB2 oplocks
Copyright (C) Stefan Metzmacher 2008
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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "librpc/gen_ndr/security.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
#include "torture/torture.h"
#include "torture/smb2/proto.h"
#include "param/param.h"
#define CHECK_VAL(v, correct) do { \
if ((v) != (correct)) { \
torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%x - should be 0x%x\n", \
__location__, #v, (int)v, (int)correct); \
ret = false; \
}} while (0)
#define CHECK_STATUS(status, correct) do { \
if (!NT_STATUS_EQUAL(status, correct)) { \
torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
nt_errstr(status), nt_errstr(correct)); \
ret = false; \
goto done; \
}} while (0)
static struct {
struct smb2_handle handle;
uint8_t level;
struct smb2_break br;
int count;
int failures;
} break_info;
static void torture_oplock_break_callback(struct smb2_request *req)
{
NTSTATUS status;
struct smb2_break br;
ZERO_STRUCT(br);
status = smb2_break_recv(req, &break_info.br);
if (!NT_STATUS_IS_OK(status)) {
break_info.failures++;
}
return;
}
/* a oplock break request handler */
static bool torture_oplock_handler(struct smb2_transport *transport,
const struct smb2_handle *handle,
uint8_t level, void *private_data)
{
struct smb2_tree *tree = private_data;
const char *name;
struct smb2_request *req;
break_info.handle = *handle;
break_info.level = level;
break_info.count++;
switch (level) {
case SMB2_OPLOCK_LEVEL_II:
name = "level II";
break;
case SMB2_OPLOCK_LEVEL_NONE:
name = "none";
break;
default:
name = "unknown";
break_info.failures++;
}
printf("Acking to %s [0x%02X] in oplock handler\n",
name, level);
ZERO_STRUCT(break_info.br);
break_info.br.in.file.handle = *handle;
break_info.br.in.oplock_level = level;
break_info.br.in.reserved = 0;
break_info.br.in.reserved2 = 0;
req = smb2_break_send(tree, &break_info.br);
req->async.fn = torture_oplock_break_callback;
req->async.private = NULL;
return true;
}
bool torture_smb2_oplock_batch1(struct torture_context *tctx,
struct smb2_tree *tree)
{
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle h1, h2;
struct smb2_create io;
NTSTATUS status;
const char *fname = "oplock.dat";
bool ret = true;
tree->session->transport->oplock.handler = torture_oplock_handler;
tree->session->transport->oplock.private_data = tree;
smb2_util_unlink(tree, fname);
ZERO_STRUCT(break_info);
ZERO_STRUCT(io);
io.in.security_flags = 0x00;
io.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
io.in.impersonation_level = NTCREATEX_IMPERSONATION_IMPERSONATION;
io.in.create_flags = 0x00000000;
io.in.reserved = 0x00000000;
io.in.desired_access = SEC_RIGHTS_FILE_ALL;
io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
io.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
NTCREATEX_SHARE_ACCESS_WRITE |
NTCREATEX_SHARE_ACCESS_DELETE;
io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
io.in.create_options = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
NTCREATEX_OPTIONS_ASYNC_ALERT |
NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
0x00200000;
io.in.fname = fname;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
/*CHECK_VAL(io.out.reserved, 0);*/
CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_CREATED);
CHECK_VAL(io.out.alloc_size, 0);
CHECK_VAL(io.out.size, 0);
CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.reserved2, 0);
CHECK_VAL(break_info.count, 0);
h1 = io.out.file.handle;
ZERO_STRUCT(io.in.blobs);
status = smb2_create(tree, mem_ctx, &io);
CHECK_VAL(break_info.count, 1);
CHECK_VAL(break_info.failures, 0);
CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
/*CHECK_VAL(io.out.reserved, 0);*/
CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_EXISTED);
CHECK_VAL(io.out.alloc_size, 0);
CHECK_VAL(io.out.size, 0);
CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.reserved2, 0);
h2 = io.out.file.handle;
done:
talloc_free(mem_ctx);
smb2_util_close(tree, h1);
smb2_util_close(tree, h2);
smb2_util_unlink(tree, fname);
return ret;
}

2
source4/torture/smb2/persistent_handles.c
View File

@ -174,6 +174,8 @@ bool torture_smb2_persistent_handles1(struct torture_context *tctx,
torture_comment(tctx, "position: %llu\n",
(unsigned long long)pos);
smb2_util_close(tree2, h2);
talloc_free(mem_ctx);
smb2_util_unlink(tree2, fname);

1
source4/torture/smb2/smb2.c
View File

@ -138,6 +138,7 @@ NTSTATUS torture_smb2_init(void)
torture_suite_add_suite(suite, torture_smb2_lock_init());
torture_suite_add_simple_test(suite, "NOTIFY", torture_smb2_notify);
torture_suite_add_2smb2_test(suite, "PERSISTENT-HANDLES1", torture_smb2_persistent_handles1);
torture_suite_add_1smb2_test(suite, "OPLOCK-BATCH1", torture_smb2_oplock_batch1);
suite->description = talloc_strdup(suite, "SMB2-specific tests");