From 8cc6ab9e4e1fa3de9b5c76f7f5f34426aeb6f91c Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 14:56:06 -0700 Subject: [PATCH 1/9] 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 f1ecbe9..c447795 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 2147c9180505489bfda00dfa3fb0bc9de0495454 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:23:52 -0700 Subject: [PATCH 2/9] 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 4c60a05..b8cd7df 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 2b834eaf4adcd8ed962f062721f5fd72c28d0455 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:32:13 -0700 Subject: [PATCH 3/9] Fix the algorithm for looking at upper length field in read_and_X. If the upper len is 0xFFFF, ignore. This cannot be a valid value (some clients deliberately send this). If the client is Samba, always look (we always correctly set the upper length value). If the client has told us via UNIX extensions it can do large READ, look at the upper length value. If the client has sent the CAP_LARGE_READX in sessionsetupX, look at the upper length value. Otherwise ignore. Signed-off-by: Jeremy Allison --- source3/smbd/reply.c | 46 ++++++++++++++++++++++++++++++++++++---------- 1 file changed, 36 insertions(+), 10 deletions(-) diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c index 64c4fdb..afa2064 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -3849,23 +3849,48 @@ nosendfile_read: } /**************************************************************************** - MacOSX clients send large reads without telling us they are going to do that. + MacOSX clients send large reads without telling us they are going to do that + via the UNIX extensions mechanism (they do set the client CAP_LARGE_READX + bit in their SessionSetupX reply). 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. + Allow this if we are talking to a Samba client, or if the client told us + it supported this via the UNIX extensions or the client capabilities. ****************************************************************************/ -static bool server_will_accept_large_read(void) +static bool server_will_accept_large_read(struct smbd_server_connection *sconn, + size_t upper_size) { - /* Samba client ? No problem. */ + /* + * 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) { + return false; + } + + /* + * Samba early 4.0.x client doesn't set + * CAP_LARGE_READX in the sessionsetupX request so + * just assume for a Samba client it's ok. + */ if (get_remote_arch() == RA_SAMBA) { return true; } - /* Need UNIX extensions. */ - if (!lp_unix_extensions()) { - return false; + + /* + * Client told us via UNIX extensions it can do this. + */ + if (sconn->smb1.unix_info.client_cap_low & CIFS_UNIX_LARGE_READ_CAP) { + return true; } - return true; + + /* + * Clients that use LARGE_READX (MacOSX, CIFSFS, Samba) + * set CAP_LARGE_READX in their sessionsetupX requests. + */ + return (global_client_caps & CAP_LARGE_READX); } /**************************************************************************** @@ -3874,6 +3899,7 @@ static bool server_will_accept_large_read(void) void reply_read_and_X(struct smb_request *req) { + struct smbd_server_connection *sconn = req->sconn; connection_struct *conn = req->conn; files_struct *fsp; off_t startpos; @@ -3914,7 +3940,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()) { + if ((upper_size != 0) && server_will_accept_large_read(sconn, upper_size)) { /* * This is Samba only behavior (up to Samba 3.6)! * -- 1.8.1.3 From 62328bcc198631422a2ae4628b7b37eac9513860 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:36:56 -0700 Subject: [PATCH 4/9] Remove out of date comment. Signed-off-by: Jeremy Allison --- source3/smbd/reply.c | 7 ------- 1 file changed, 7 deletions(-) diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c index afa2064..14cb3c8 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -3941,13 +3941,6 @@ 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(sconn, upper_size)) { - /* - * 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. - */ smb_maxcnt |= (upper_size<<16); if (upper_size > 1) { /* Can't do this on a chained packet. */ -- 1.8.1.3 From ca07c87af2cfa6b3c8c19ea3063787d65f4a5fb7 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:37:50 -0700 Subject: [PATCH 5/9] Fix identification of a large_readX. We can't just look for the upper length value being greater than 1, as the actual limit is 0x1FFFF minus the SMB header and VWV sizes. 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 14cb3c8..4868a8f 100644 --- a/source3/smbd/reply.c +++ b/source3/smbd/reply.c @@ -3942,7 +3942,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(sconn, upper_size)) { smb_maxcnt |= (upper_size<<16); - 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 e23bb3e44c8d775f584c9a9ff4c693b044ed1251 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:41:05 -0700 Subject: [PATCH 6/9] 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 b8cd7df..571ef28 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 f7b60d3..476f68d 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 1fb6eef989ce7c5c5f9da54835c176c5ec650a90 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:43:21 -0700 Subject: [PATCH 7/9] Add new LARGE_READX test to investigate large SMBreadX behavior. Signed-off-by: Jeremy Allison --- source3/torture/torture.c | 354 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 354 insertions(+) diff --git a/source3/torture/torture.c b/source3/torture/torture.c index 93b9cfd..b5678f1 100644 --- a/source3/torture/torture.c +++ b/source3/torture/torture.c @@ -7239,6 +7239,359 @@ static bool run_windows_write(int dummy) return ret; } +/* Test large readX variants. */ +static bool large_readx_tests(struct cli_state *cli, + uint16_t fnum, + uint8_t *buf) +{ + NTSTATUS status; + struct tevent_req *req = NULL; + ssize_t len_read = 0; + struct tevent_context *ev = NULL; + + ev = samba_tevent_context_init(talloc_tos()); + if (ev == NULL) { + return false; + } + + /* A read of 0xFFFF0001 should *always* return 1 byte. */ + req = cli_read_andx_send(talloc_tos(), + ev, + cli, + fnum, + 0, + 0xFFFF0001); + + 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); + + if (len_read != 1) { + d_printf("read of 0xFFFF001 failed: returned %d " + "(should return 1)\n", + (int)len_read); + return false; + } + + /* A read of 0x10000 should return 10000 bytes. */ + req = cli_read_andx_send(talloc_tos(), + ev, + cli, + fnum, + 0, + 0x10000); + + 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); + + if (len_read != 0x10000) { + d_printf("read of 0x10000 failed: %d\n", (int)len_read); + return false; + } + + /* + * With signing or encryption + * doing reads >= 0x1FFFF are + * not supported. + */ + if (smb1cli_conn_signing_is_active(cli->conn)) { + d_printf("Server is signing - not testing reads > 0x10000\n"); + return true; + } + if (smb1cli_conn_encryption_on(cli->conn)) { + d_printf("Server is sealing - not testing reads > 0x10000\n"); + return true; + } + + /* A read of 0x1FFFF should return 1FFFF bytes. */ + req = cli_read_andx_send(talloc_tos(), + ev, + cli, + fnum, + 0, + 0x1FFFF); + + 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); + + if (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 0x1FFFF\n"); + } else if (len_read != 0x1FFFF) { + d_printf("read of 0x1FFFF failed: %d\n", (int)len_read); + return false; + } else { + d_printf("Server supports CAP_LARGE_READX fully\n"); + } + + /* + * With signing or encryption + * doing reads > 0x1FFFF returns + * NT_STATUS_NOT_SUPPORTED. + */ + if (smb1cli_conn_signing_is_active(cli->conn)) { + d_printf("Server is signing - not testing 1MB read\n"); + return true; + } + if (smb1cli_conn_encryption_on(cli->conn)) { + d_printf("Server is sealing - not testing 1MB read\n"); + return true; + } + + /* A read of 1MB should return 1MB bytes. */ + req = cli_read_andx_send(talloc_tos(), + ev, + cli, + fnum, + 0, + 0x100000); + + 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; + } + + if (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 0x100000\n"); + } else if (len_read != 0x100000) { + d_printf("read of 0x100000 failed: %d\n", (int)len_read); + return false; + } else { + d_printf("Server supports CAP_LARGE_READX fully\n"); + } + + 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; @@ -9153,6 +9506,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 bbd2c04b21b55a2a014dcc106e601e15d8f34479 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:44:22 -0700 Subject: [PATCH 8/9] 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 180a543..cdd7227 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 80479ed8171ae0064cbe15ae576363242f1e27a2 Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Wed, 13 Mar 2013 15:45:12 -0700 Subject: [PATCH 9/9] 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 30253ca..1c123f5 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