From f4613783d0507c0289fe4f16beaace6d58e81ba4 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 14:56:06 -0700 Subject: [PATCH 01/10] Ensure we send CAP_LARGE_READX/CAP_LARGE_WRITEX to the server on SMB1 sessionsetupX. A Windows client doesn't do this, but that's because they never do large reads/writes over SMB1. It's in the spec that this should occur, and Samba 3.6.x uses it. Also, MacOSX, CIFSFS and Android (jCIFS) honour this setting and send it. We need to as well in order to give servers a better idea of our capabilities. Signed-off-by: Jeremy Allison --- libcli/smb/smb_constants.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libcli/smb/smb_constants.h b/libcli/smb/smb_constants.h index 8cb3b6e..3644d85 100644 --- a/libcli/smb/smb_constants.h +++ b/libcli/smb/smb_constants.h @@ -234,6 +234,8 @@ enum smb_signing_setting { CAP_NT_SMBS | \ CAP_STATUS32 | \ CAP_LEVEL_II_OPLOCKS | \ + CAP_LARGE_READX | \ + CAP_LARGE_WRITEX | \ CAP_EXTENDED_SECURITY | \ 0) #define SMB_CAP_SERVER_MASK ( \ @@ -245,8 +247,6 @@ enum smb_signing_setting { CAP_NT_FIND | \ CAP_DFS | \ CAP_W2K_SMBS | \ - CAP_LARGE_READX | \ - CAP_LARGE_WRITEX | \ CAP_LWIO | \ CAP_UNIX | \ 0) -- 1.8.1.3 From a3ecce5fa0a468cceec0a70fe4c8b27587530635 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:23:52 -0700 Subject: [PATCH 02/10] smb1cli_inbuf_parse_chain() and smb1cli_conn_dispatch_incoming() should use smb_len_tcp. They have to cope with large READX call replies that have a length greater than smb_len_nbt() can handle. Signed-off-by: Jeremy Allison --- libcli/smb/smbXcli_base.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libcli/smb/smbXcli_base.c b/libcli/smb/smbXcli_base.c index c547515..2222a35 100644 --- a/libcli/smb/smbXcli_base.c +++ b/libcli/smb/smbXcli_base.c @@ -1618,7 +1618,7 @@ static NTSTATUS smb1cli_inbuf_parse_chain(uint8_t *buf, TALLOC_CTX *mem_ctx, NTSTATUS status; size_t min_size = MIN_SMB_SIZE; - buflen = smb_len_nbt(buf); + buflen = smb_len_tcp(buf); taken = 0; hdr = buf + NBT_HDR_SIZE; @@ -1845,7 +1845,7 @@ static NTSTATUS smb1cli_conn_dispatch_incoming(struct smbXcli_conn *conn, uint16_t mid; bool oplock_break; uint8_t *inhdr = inbuf + NBT_HDR_SIZE; - size_t len = smb_len_nbt(inbuf); + size_t len = smb_len_tcp(inbuf); struct iovec *iov = NULL; int num_iov = 0; struct tevent_req **chain = NULL; -- 1.8.1.3 From b2bf622e5f36e12ae7e66eb3fa4a06fe751e5b90 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 15 Mar 2013 11:53:04 -0700 Subject: [PATCH 03/10] Remove server_will_accept_large_read() and erroneous comment. We're going to replace this with a function that calculates the max PDU to return on a read and supports short reads. Signed-off-by: Jeremy Allison --- source3/smbd/reply.c | 29 +---------------------------- 1 file changed, 1 insertion(+), 28 deletions(-) diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c index 7b19817..4abc879 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -3849,26 +3849,6 @@ nosendfile_read: } /**************************************************************************** - MacOSX clients send large reads without telling us they are going to do that. - Bug #9572 - File corruption during SMB1 read by Mac OSX 10.8.2 clients - Allow this if we are talking to a Samba client, or if we told the client - we supported this. -****************************************************************************/ - -static bool server_will_accept_large_read(void) -{ - /* Samba client ? No problem. */ - if (get_remote_arch() == RA_SAMBA) { - return true; - } - /* Need UNIX extensions. */ - if (!lp_unix_extensions()) { - return false; - } - return true; -} - -/**************************************************************************** Reply to a read and X. ****************************************************************************/ @@ -3914,14 +3894,7 @@ void reply_read_and_X(struct smb_request *req) } upper_size = SVAL(req->vwv+7, 0); - if ((upper_size != 0) && server_will_accept_large_read()) { - /* - * This is Samba only behavior (up to Samba 3.6)! - * - * Windows 2008 R2 ignores the upper_size, - * so we do unless unix extentions are active - * or "smbclient" is talking to us. - */ + if (upper_size != 0) { smb_maxcnt |= (upper_size<<16); if (upper_size > 1) { /* Can't do this on a chained packet. */ -- 1.8.1.3 From 78a3ff5e190eac6d0aa8e00f00bec72ce3b66e7a Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 15 Mar 2013 11:57:48 -0700 Subject: [PATCH 04/10] Add functions calc_max_read_pdu()/calc_read_size() to work out the length we should return. LARGE_READX test shows it's always safe to return a short read. Windows does so. Do the calculations to return what will fit in a read depending on what the client negotiated. Conservative, in that if no flags are negotiated then the max read is set to default Win2K12 max_pdu size of 0x10000 + headers. Signed-off-by: Jeremy Allison --- source3/smbd/reply.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 75 insertions(+), 1 deletion(-) diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c index 4abc879..1c6ddc8 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -3849,6 +3849,80 @@ nosendfile_read: } /**************************************************************************** + Work out how much space we have for a read return. +****************************************************************************/ + +static size_t calc_max_read_pdu(const struct smb_request *req) +{ + /* Default Win2K12 max_pdu size of 0x10000 + headers. */ + size_t max_pdu = 0x10000 + (smb_size -4 + 12*2); + + if (req->encrypted) { + /* + * Don't take encrypted traffic up to the + * limit. There are padding considerations + * that make that tricky. + */ + return max_pdu; + } + + if (req->sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_LARGE_READ_CAP) { + if (srv_is_signing_active(req->sconn)) { + /* + * Ignore POSIX large read size on a signed + * connection. + */ + if (global_client_caps & CAP_LARGE_READX) { + max_pdu = 0x1FFFF; + } + } else { + /* + * We can do ultra-large POSIX reads. + */ + max_pdu = 0xFFFFFF; + } + } else if (global_client_caps & CAP_LARGE_READX) { + /* + * "Normal" max PDU size. + */ + max_pdu = 0x1FFFF; + } + + return max_pdu; +} + +/**************************************************************************** + Calculate how big a read can be. Copes with all clients. It's always + safe to return a short read - Windows does this. +****************************************************************************/ + +static size_t calc_read_size(const struct smb_request *req, + size_t upper_size, + size_t lower_size) +{ + size_t max_pdu = calc_max_read_pdu(req); + size_t total_size = 0; + + /* + * Windows explicitly ignores upper size of 0xFFFF. + * See [MS-SMB].pdf <26> Section 2.2.4.2.1: + * We must do the same as these will never fit even in + * an extended size NetBIOS packet. + */ + if (upper_size == 0xFFFF) { + upper_size = 0; + } + + total_size = ((upper_size<<16) | lower_size); + + /* + * LARGE_READX test shows it's always safe to return + * a short read. Windows does so. + */ + return MIN(total_size, max_pdu - (smb_size -4 + 12*2)); +} + +/**************************************************************************** Reply to a read and X. ****************************************************************************/ @@ -3895,7 +3969,7 @@ void reply_read_and_X(struct smb_request *req) upper_size = SVAL(req->vwv+7, 0); if (upper_size != 0) { - smb_maxcnt |= (upper_size<<16); + smb_maxcnt = calc_read_size(req, upper_size, smb_maxcnt); if (upper_size > 1) { /* Can't do this on a chained packet. */ if ((CVAL(req->vwv+0, 0) != 0xFF)) { -- 1.8.1.3 From b581a447b149400788dfb28c64922e2e860b7520 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 15 Mar 2013 12:02:28 -0700 Subject: [PATCH 05/10] Don't just check for upper_size > 1, check for actual PDU space. Signed-off-by: Jeremy Allison --- source3/smbd/reply.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c index 1c6ddc8..26f113c 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -3970,7 +3970,7 @@ void reply_read_and_X(struct smb_request *req) upper_size = SVAL(req->vwv+7, 0); if (upper_size != 0) { smb_maxcnt = calc_read_size(req, upper_size, smb_maxcnt); - if (upper_size > 1) { + if (smb_maxcnt > (0x1FFFF - (smb_size -4 + 12*2))) { /* Can't do this on a chained packet. */ if ((CVAL(req->vwv+0, 0) != 0xFF)) { reply_nterror(req, NT_STATUS_NOT_SUPPORTED); -- 1.8.1.3 From 5c82e14095a79f27db4aceb09d0e80357fec2292 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Fri, 15 Mar 2013 12:03:47 -0700 Subject: [PATCH 06/10] Remove unneeded checks. We truncate the read inside calc_read_size() now. Signed-off-by: Jeremy Allison --- source3/smbd/reply.c | 14 -------------- 1 file changed, 14 deletions(-) diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c index 26f113c..67229e6 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -3977,20 +3977,6 @@ void reply_read_and_X(struct smb_request *req) END_PROFILE(SMBreadX); return; } - /* We currently don't do this on signed or sealed data. */ - if (srv_is_signing_active(req->sconn) || - is_encrypted_packet(req->sconn, req->inbuf)) { - reply_nterror(req, NT_STATUS_NOT_SUPPORTED); - END_PROFILE(SMBreadX); - return; - } - /* Is there room in the reply for this data ? */ - if (smb_maxcnt > (0xFFFFFF - (smb_size -4 + 12*2))) { - reply_nterror(req, - NT_STATUS_INVALID_PARAMETER); - END_PROFILE(SMBreadX); - return; - } big_readX = True; } } -- 1.8.1.3 From fe70fb62d1dbe295ea1176fddfa536320457c0db Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:41:05 -0700 Subject: [PATCH 07/10] Add set_XX() functions for fields we need to modify for testing large READX. Signed-off-by: Jeremy Allison --- libcli/smb/smbXcli_base.c | 10 ++++++++++ libcli/smb/smbXcli_base.h | 2 ++ 2 files changed, 12 insertions(+) diff --git a/libcli/smb/smbXcli_base.c b/libcli/smb/smbXcli_base.c index 2222a35..90b194f 100644 --- a/libcli/smb/smbXcli_base.c +++ b/libcli/smb/smbXcli_base.c @@ -585,11 +585,21 @@ uint32_t smb1cli_conn_capabilities(struct smbXcli_conn *conn) return conn->smb1.capabilities; } +void smb1cli_conn_set_capabilities(struct smbXcli_conn *conn, uint32_t capabilities) +{ + conn->smb1.capabilities = capabilities; +} + uint32_t smb1cli_conn_max_xmit(struct smbXcli_conn *conn) { return conn->smb1.max_xmit; } +void smb1cli_conn_set_max_xmit(struct smbXcli_conn *conn, uint32_t max_xmit) +{ + conn->smb1.max_xmit = max_xmit; +} + uint32_t smb1cli_conn_server_session_key(struct smbXcli_conn *conn) { return conn->smb1.server.session_key; diff --git a/libcli/smb/smbXcli_base.h b/libcli/smb/smbXcli_base.h index 9a6ccc6..083efaf 100644 --- a/libcli/smb/smbXcli_base.h +++ b/libcli/smb/smbXcli_base.h @@ -67,7 +67,9 @@ void smbXcli_req_unset_pending(struct tevent_req *req); bool smbXcli_req_set_pending(struct tevent_req *req); uint32_t smb1cli_conn_capabilities(struct smbXcli_conn *conn); +void smb1cli_conn_set_capabilities(struct smbXcli_conn *conn, uint32_t capabilities); uint32_t smb1cli_conn_max_xmit(struct smbXcli_conn *conn); +void smb1cli_conn_set_max_xmit(struct smbXcli_conn *conn, uint32_t max_xmit); uint32_t smb1cli_conn_server_session_key(struct smbXcli_conn *conn); const uint8_t *smb1cli_conn_server_challenge(struct smbXcli_conn *conn); uint16_t smb1cli_conn_server_security_mode(struct smbXcli_conn *conn); -- 1.8.1.3 From 6431c353d874e7df7980c1c6a4111a9f1a789969 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:43:21 -0700 Subject: [PATCH 08/10] Add new LARGE_READX test to investigate large SMBreadX behavior. Signed-off-by: Jeremy Allison --- source3/torture/torture.c | 308 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 308 insertions(+) diff --git a/source3/torture/torture.c b/source3/torture/torture.c index cd885a1..d31c1c2 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -7237,6 +7237,313 @@ static bool run_windows_write(int dummy) return ret; } +static size_t calc_expected_return(struct cli_state *cli, size_t len_requested) +{ + size_t max_pdu = cli->server_posix_capabilities ? 0xFFFFFF : 0x1FFFF; + + if ((len_requested & 0xFFFF0000) == 0xFFFF0000) { + len_requested &= 0xFFFF; + } + + if (smb1cli_conn_encryption_on(cli->conn)) { + return MIN(len_requested, 0x10000 + (smb_size -4 + 12*2)); + } else if (smb1cli_conn_signing_is_active(cli->conn)) { + /* + * When signed or encrypted we don't return PDU's + * larger than normal NetBIOS 0x1FFFF PDU size. + */ + return MIN(len_requested, 0x1FFFF - (smb_size -4 + 12*2)); + } + + /* Max size depends on whether POSIX was negotiated. */ + return MIN(len_requested, max_pdu - (smb_size -4 + 12*2)); +} + +static bool check_read_call(struct cli_state *cli, + uint16_t fnum, + uint8_t *buf, + size_t len_requested) +{ + NTSTATUS status; + struct tevent_req *req = NULL; + ssize_t len_read = 0; + size_t len_expected = 0; + struct tevent_context *ev = NULL; + + ev = tevent_context_init(talloc_tos()); + if (ev == NULL) { + return false; + } + + req = cli_read_andx_send(talloc_tos(), + ev, + cli, + fnum, + 0, + len_requested); + + if (!tevent_req_poll_ntstatus(req, ev, &status)) { + return false; + } + + status = cli_read_andx_recv(req, &len_read, &buf); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_read_andx_recv failed: %s\n", nt_errstr(status)); + return false; + } + + TALLOC_FREE(req); + TALLOC_FREE(ev); + + len_expected = calc_expected_return(cli, len_requested); + + if (len_expected > 0x10000 && len_read == 0x10000) { + /* Windows servers only return a max of 0x10000, + doesn't matter if you set CAP_LARGE_READX in + the client sessionsetupX call or not. */ + d_printf("Windows server - returned 0x10000 on a read of 0x%x\n", + (unsigned int)len_requested); + } else if (len_read != len_expected) { + d_printf("read of 0x%x failed: got 0x%x, expected 0x%x\n", + (unsigned int)len_requested, + (unsigned int)len_read, + (unsigned int)len_expected); + return false; + } else { + d_printf("Correct read reply.\n"); + } + + return true; +} + +/* Test large readX variants. */ +static bool large_readx_tests(struct cli_state *cli, + uint16_t fnum, + uint8_t *buf) +{ + /* A read of 0xFFFF0001 should *always* return 1 byte. */ + if (check_read_call(cli, fnum, buf, 0xFFFF0001) == false) { + return false; + } + /* A read of 0x10000 should return 10000 bytes. */ + if (check_read_call(cli, fnum, buf, 0x10000) == false) { + return false; + } + /* A read of 0x1FFFF - (smb_size -4 + 12*2) should return + the requested number of bytes. */ + if (check_read_call(cli, fnum, buf, 0x1FFFF - (smb_size -4 + 12*2)) == false) { + return false; + } + /* A read of 1MB should return 1MB bytes (on Samba). */ + if (check_read_call(cli, fnum, buf, 0x100000) == false) { + return false; + } + + if (check_read_call(cli, fnum, buf, 0x20001) == false) { + return false; + } + if (check_read_call(cli, fnum, buf, 0x22000001) == false) { + return false; + } + if (check_read_call(cli, fnum, buf, 0xFFFE0001) == false) { + return false; + } + return true; +} + +static bool run_large_readx(int dummy) +{ + uint8_t *buf = NULL; + struct cli_state *cli = NULL; + bool correct = false; + const char *fname = "\\large_readx.dat"; + NTSTATUS status; + uint16_t fnum = -1; + uint32_t normal_caps = 0; + TALLOC_CTX *frame = talloc_stackframe(); + + printf("starting large_readx test\n"); + + if (!torture_open_connection(&cli, 0)) { + goto out; + } + + normal_caps = smb1cli_conn_capabilities(cli->conn); + + if (!(normal_caps & CAP_LARGE_READX)) { + d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n", + (unsigned int)normal_caps); + goto out; + } + + cli_unlink(cli, fname, FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + + /* Create a file of size 4MB. */ + status = cli_ntcreate(cli, fname, 0, GENERIC_ALL_ACCESS, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OVERWRITE_IF, + 0, 0, &fnum); + + if (!NT_STATUS_IS_OK(status)) { + d_printf("open %s failed: %s\n", fname, nt_errstr(status)); + goto out; + } + + /* Write 4MB. */ + buf = talloc_zero_array(frame, uint8_t, 4*1024*1024); + if (buf == NULL) { + goto out; + } + + status = cli_writeall(cli, + fnum, + 0, + buf, + 0, + 4*1024*1024, + NULL); + + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_writeall failed: %s\n", nt_errstr(status)); + goto out; + } + + /* + * Mangle the cli state to allow us to do a read + * with upper bytes of 0xFFFF. + */ + cli->server_posix_capabilities &= ~CIFS_UNIX_LARGE_READ_CAP; + smb1cli_conn_set_max_xmit(cli->conn, 0xFFFFFF00); + smb1cli_conn_set_capabilities(cli->conn, (normal_caps & ~CAP_LARGE_READX)); + + if (!large_readx_tests(cli, fnum, buf)) { + goto out; + } + + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_close failed: %s\n", nt_errstr(status)); + goto out; + } + + fnum = -1; + + if (!torture_close_connection(cli)) { + goto out; + } + + cli = NULL; + + /* + * Open a second connection ensuring we don't + * announce ourselves as Samba. This way we + * should elicit the same behavior from a + * Samba server as we give to a Windows + * or MacOSX client. + */ + + if (!(cli = open_nbt_connection())) { + goto out; + } + + /* Ensure we don't announce ourselves as Samba. */ + status = smbXcli_negprot(cli->conn, + cli->timeout, + PROTOCOL_NT1, + PROTOCOL_NT1); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + status = cli_session_setup(cli, + username, + password, + strlen(password)+1, + password, + strlen(password)+1, + workgroup); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + status = cli_tree_connect(cli, + share, + "?????", + password, + strlen(password)+1); + if (!NT_STATUS_IS_OK(status)) { + goto out; + } + + cli_set_timeout(cli, 120000); /* set a really long timeout (2 minutes) */ + + if (do_encrypt) { + if (force_cli_encryption(cli, share) == false) { + goto out; + } + } + + normal_caps = smb1cli_conn_capabilities(cli->conn); + + if (!(normal_caps & CAP_LARGE_READX)) { + d_printf("Server doesn't have CAP_LARGE_READX 0x%x\n", + (unsigned int)normal_caps); + goto out; + } + + status = cli_ntcreate(cli, fname, 0, FILE_READ_DATA, + FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN, + 0, 0, &fnum); + + if (!NT_STATUS_IS_OK(status)) { + d_printf("Second open %s failed: %s\n", fname, nt_errstr(status)); + goto out; + } + + /* + * Mangle the cli state to allow us to do a read + * with upper bytes of 0xFFFF. + */ + cli->server_posix_capabilities &= ~CIFS_UNIX_LARGE_READ_CAP; + smb1cli_conn_set_max_xmit(cli->conn, 0xFFFFFF00); + smb1cli_conn_set_capabilities(cli->conn, (normal_caps & ~CAP_LARGE_READX)); + + if (!large_readx_tests(cli, fnum, buf)) { + goto out; + } + + correct = true; + printf("Success on large_readx test\n"); + + out: + + if (fnum != -1) { + status = cli_close(cli, fnum); + if (!NT_STATUS_IS_OK(status)) { + d_printf("cli_close failed: %s\n", nt_errstr(status)); + } + fnum = -1; + } + + status = cli_unlink(cli, + fname, + FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN); + if (!NT_STATUS_IS_OK(status)) { + printf("unlink failed (%s)\n", nt_errstr(status)); + } + + if (cli) { + if (!torture_close_connection(cli)) { + correct = false; + } + } + + TALLOC_FREE(frame); + + printf("finished large_readx test\n"); + return correct; +} + + static bool run_cli_echo(int dummy) { struct cli_state *cli; @@ -9151,6 +9458,7 @@ static struct { { "CHAIN2", run_chain2, 0}, { "CHAIN3", run_chain3, 0}, { "WINDOWS-WRITE", run_windows_write, 0}, + { "LARGE_READX", run_large_readx, 0}, { "NTTRANS-CREATE", run_nttrans_create, 0}, { "NTTRANS-FSCTL", run_nttrans_fsctl, 0}, { "CLI_ECHO", run_cli_echo, 0}, -- 1.8.1.3 From a8b32ea5df260bb30f749e6d6c6ca6ab7c0b1586 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:44:22 -0700 Subject: [PATCH 09/10] New LARGE_READX doesn't work against ntvfs server. Signed-off-by: Jeremy Allison --- selftest/knownfail | 1 + 1 file changed, 1 insertion(+) diff --git a/selftest/knownfail b/selftest/knownfail index 84eb769..f2119e1 100644 --- a/selftest/knownfail +++ b/selftest/knownfail @@ -13,6 +13,7 @@ ^samba3.smbtorture_s3.plain\(dc\).DIR-CREATETIME # Fails against the s4 ntvfs server ^samba3.smbtorture_s3.plain\(dc\).DELETE-LN # Fails against the s4 ntvfs server ^samba3.smbtorture_s3.plain\(dc\).POSIX # Fails against the s4 ntvfs server +^samba3.smbtorture_s3.plain\(dc\).LARGE_READX # Fails against the s4 ntvfs server ^samba3.smbtorture_s3.plain\(dc\).UID-REGRESSION-TEST # Fails against the s4 ntvfs server ^samba3.smbtorture_s3.plain\(dc\).SHORTNAME-TEST # Fails against the s4 ntvfs server ^samba3.smbtorture_s3.plain\(dc\).POSIX-APPEND # Fails against the s4 ntvfs server -- 1.8.1.3 From d35e202d45b74e07e0b16d00737827bbf2e15191 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:45:12 -0700 Subject: [PATCH 10/10] Add LARGE_READX test into our make test infrastructure. Tested against non-encrypted and encrypted connections. Signed-off-by: Jeremy Allison --- source3/selftest/tests.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source3/selftest/tests.py b/source3/selftest/tests.py index 57c80f2..4453c4d 100755 --- a/source3/selftest/tests.py +++ b/source3/selftest/tests.py @@ -54,7 +54,7 @@ plantestsuite("samba3.blackbox.registry.upgrade", "s3dc:local", [os.path.join(sa tests = ["FDPASS", "LOCK1", "LOCK2", "LOCK3", "LOCK4", "LOCK5", "LOCK6", "LOCK7", "LOCK9", "UNLINK", "BROWSE", "ATTR", "TRANS2", "TORTURE", "OPLOCK1", "OPLOCK2", "OPLOCK4", "STREAMERROR", - "DIR", "DIR1", "DIR-CREATETIME", "TCON", "TCONDEV", "RW1", "RW2", "RW3", "RW-SIGNING", + "DIR", "DIR1", "DIR-CREATETIME", "TCON", "TCONDEV", "RW1", "RW2", "RW3", "LARGE_READX", "RW-SIGNING", "OPEN", "XCOPY", "RENAME", "DELETE", "DELETE-LN", "PROPERTIES", "W2K", "TCON2", "IOCTL", "CHKPATH", "FDSESS", "CHAIN1", "CHAIN2", "CHAIN3", -- 1.8.1.3