Changeset 989 for vendor/current/source4

Timestamp:

Nov 25, 2016, 8:04:54 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.7

Location:

vendor/current/source4

Files:

• dns_server/dns_crypto.c (modified) (5 diffs)
• dns_server/dns_server.c (modified) (3 diffs)
• dsdb/samdb/ldb_modules/objectclass_attrs.c (modified) (1 diff)
• dsdb/samdb/ldb_modules/ranged_results.c (modified) (2 diffs)
• heimdal/kdc/misc.c (modified) (1 diff)
• heimdal/lib/asn1/krb5.asn1 (modified) (1 diff)
• heimdal/lib/krb5/mcache.c (modified) (4 diffs)
• lib/wmi/wmi_wrap.c (modified) (1 diff)
• librpc/rpc/dcerpc.c (modified) (4 diffs)
• librpc/rpc/dcerpc.h (modified) (1 diff)
• ntvfs/posix/posix_eadb.c (modified) (6 diffs)
• ntvfs/posix/wscript_build (modified) (1 diff)
• ntvfs/wscript_build (modified) (1 diff)
• param/pyparam.c (modified) (2 diffs)
• rpc_server/common/server_info.c (modified) (1 diff)
• rpc_server/dcerpc_server.c (modified) (6 diffs)
• rpc_server/dcerpc_server.h (modified) (1 diff)
• rpc_server/dcesrv_auth.c (modified) (7 diffs)
• rpc_server/wkssvc/dcesrv_wkssvc.c (modified) (1 diff)
• rpc_server/wscript_build (modified) (4 diffs)
• scripting/bin/samba_spnupdate (modified) (1 diff)
• selftest/tests.py (modified) (4 diffs)
• smb_server/service_smb.c (modified) (2 diffs)
• smb_server/wscript_build (modified) (1 diff)
• smbd/server.c (modified) (2 diffs)
• torture/raw/read.c (modified) (3 diffs)
• torture/rpc/lsa.c (modified) (1 diff)
• torture/smb2/dosmode.c (added)
• torture/smb2/getinfo.c (modified) (2 diffs)
• torture/smb2/ioctl.c (modified) (8 diffs)
• torture/smb2/lock.c (modified) (2 diffs)
• torture/smb2/read.c (modified) (3 diffs)
• torture/smb2/replay.c (modified) (6 diffs)
• torture/smb2/smb2.c (modified) (1 diff)
• torture/smb2/util.c (modified) (6 diffs)
• torture/smb2/wscript_build (modified) (1 diff)
• torture/vfs/acl_xattr.c (added)
• torture/vfs/vfs.c (modified) (1 diff)
• torture/wscript_build (modified) (1 diff)

vendor/current/source4/dns_server/dns_crypto.c

@@ -147 +147 @@
         tkey = dns_find_tkey(dns->tkeys, state->tsig->name);
         if (tkey == NULL) {
+                /*
+                 * We must save the name for use in the TSIG error
+                 * response and have no choice here but to save the
+                 * keyname from the TSIG request.
+                 */
+                state->key_name = talloc_strdup(state->mem_ctx,
+                                                state->tsig->name);
+                if (state->key_name == NULL) {
+                        return WERR_NOMEM;
+                }
                 state->tsig_error = DNS_RCODE_BADKEY;
                 return DNS_ERR(NOTAUTH);
+        }
+
+        /*
+         * Remember the keyname that found an existing tkey, used
+         * later to fetch the key with dns_find_tkey() when signing
+         * and adding a TSIG record with MAC.
+         */
+        state->key_name = talloc_strdup(state->mem_ctx, tkey->name);
+        if (state->key_name == NULL) {
+                return WERR_NOMEM;
         }
 
@@ -208 +228 @@
         }
 
-        /*FIXME: Why is there too much padding? */
-        buffer_len -= 2;
-
         /* Now we also need to count down the additional record counter */
         arcount = RSVAL(buffer, 10);
@@ -218 +235 @@
                                     buffer, buffer_len, &sig);
         if (NT_STATUS_EQUAL(NT_STATUS_ACCESS_DENIED, status)) {
-                return DNS_ERR(BADKEY);
+                state->tsig_error = DNS_RCODE_BADSIG;
+                return DNS_ERR(NOTAUTH);
         }
 
@@ -227 +245 @@
 
         state->authenticated = true;
-        state->key_name = talloc_strdup(state->mem_ctx, tkey->name);
-        if (state->key_name == NULL) {
-                return WERR_NOMEM;
-        }
-
+
+        return WERR_OK;
+}
+
+static WERROR dns_tsig_compute_mac(TALLOC_CTX *mem_ctx,
+                                   struct dns_request_state *state,
+                                   struct dns_name_packet *packet,
+                                   struct dns_server_tkey *tkey,
+                                   time_t current_time,
+                                   DATA_BLOB *_psig)
+{
+        NTSTATUS status;
+        enum ndr_err_code ndr_err;
+        DATA_BLOB packet_blob, tsig_blob, sig;
+        uint8_t *buffer = NULL;
+        uint8_t *p = NULL;
+        size_t buffer_len = 0;
+        struct dns_fake_tsig_rec *check_rec = talloc_zero(mem_ctx,
+                        struct dns_fake_tsig_rec);
+        size_t mac_size = 0;
+
+        if (check_rec == NULL) {
+                return WERR_NOMEM;
+        }
+
+        /* first build and verify check packet */
+        check_rec->name = talloc_strdup(check_rec, tkey->name);
+        if (check_rec->name == NULL) {
+                return WERR_NOMEM;
+        }
+        check_rec->rr_class = DNS_QCLASS_ANY;
+        check_rec->ttl = 0;
+        check_rec->algorithm_name = talloc_strdup(check_rec, tkey->algorithm);
+        if (check_rec->algorithm_name == NULL) {
+                return WERR_NOMEM;
+        }
+        check_rec->time_prefix = 0;
+        check_rec->time = current_time;
+        check_rec->fudge = 300;
+        check_rec->error = state->tsig_error;
+        check_rec->other_size = 0;
+        check_rec->other_data = NULL;
+
+        ndr_err = ndr_push_struct_blob(&packet_blob, mem_ctx, packet,
+                (ndr_push_flags_fn_t)ndr_push_dns_name_packet);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                DEBUG(1, ("Failed to push packet: %s!\n",
+                          ndr_errstr(ndr_err)));
+                return DNS_ERR(SERVER_FAILURE);
+        }
+
+        ndr_err = ndr_push_struct_blob(&tsig_blob, mem_ctx, check_rec,
+                (ndr_push_flags_fn_t)ndr_push_dns_fake_tsig_rec);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                DEBUG(1, ("Failed to push packet: %s!\n",
+                          ndr_errstr(ndr_err)));
+                return DNS_ERR(SERVER_FAILURE);
+        }
+
+        if (state->tsig != NULL) {
+                mac_size = state->tsig->rdata.tsig_record.mac_size;
+        }
+
+        buffer_len = mac_size;
+
+        buffer_len += packet_blob.length;
+        if (buffer_len < packet_blob.length) {
+                return WERR_INVALID_PARAM;
+        }
+        buffer_len += tsig_blob.length;
+        if (buffer_len < tsig_blob.length) {
+                return WERR_INVALID_PARAM;
+        }
+
+        buffer = talloc_zero_array(mem_ctx, uint8_t, buffer_len);
+        if (buffer == NULL) {
+                return WERR_NOMEM;
+        }
+
+        p = buffer;
+
+        /*
+         * RFC 2845 "4.2 TSIG on Answers", how to lay out the buffer
+         * that we're going to sign:
+         * 1. MAC of request (if present)
+         * 2. Outgoing packet
+         * 3. TSIG record
+         */
+        if (mac_size > 0) {
+                memcpy(p, state->tsig->rdata.tsig_record.mac, mac_size);
+                p += mac_size;
+        }
+
+        memcpy(p, packet_blob.data, packet_blob.length);
+        p += packet_blob.length;
+
+        memcpy(p, tsig_blob.data, tsig_blob.length);
+
+        status = gensec_sign_packet(tkey->gensec, mem_ctx, buffer, buffer_len,
+                                    buffer, buffer_len, &sig);
+        if (!NT_STATUS_IS_OK(status)) {
+                return ntstatus_to_werror(status);
+        }
+
+        *_psig = sig;
         return WERR_OK;
 }
@@ -242 +360 @@
 {
         WERROR werror;
-        NTSTATUS status;
-        enum ndr_err_code ndr_err;
         time_t current_time = time(NULL);
-        DATA_BLOB packet_blob, tsig_blob, sig;
-        uint8_t *buffer = NULL;
-        size_t buffer_len = 0;
-        struct dns_server_tkey * tkey = NULL;
-        struct dns_res_rec *tsig = talloc_zero(mem_ctx, struct dns_res_rec);
-
-        struct dns_fake_tsig_rec *check_rec = talloc_zero(mem_ctx,
-                        struct dns_fake_tsig_rec);
-
+        struct dns_res_rec *tsig = NULL;
+        DATA_BLOB sig = (DATA_BLOB) {
+                .data = NULL,
+                .length = 0
+        };
+
+        tsig = talloc_zero(mem_ctx, struct dns_res_rec);
         if (tsig == NULL) {
                 return WERR_NOMEM;
         }
 
-        if (check_rec == NULL) {
-                return WERR_NOMEM;
-        }
-
-        tkey = dns_find_tkey(dns->tkeys, state->key_name);
-        if (tkey == NULL) {
-                /* FIXME: read up on what to do when we can't find a key */
-                return WERR_OK;
-        }
-
-        /* first build and verify check packet */
-        check_rec->name = talloc_strdup(check_rec, tkey->name);
-        if (check_rec->name == NULL) {
-                return WERR_NOMEM;
-        }
-        check_rec->rr_class = DNS_QCLASS_ANY;
-        check_rec->ttl = 0;
-        check_rec->algorithm_name = talloc_strdup(check_rec, tkey->algorithm);
-        if (check_rec->algorithm_name == NULL) {
-                return WERR_NOMEM;
-        }
-        check_rec->time_prefix = 0;
-        check_rec->time = current_time;
-        check_rec->fudge = 300;
-        check_rec->error = state->tsig_error;
-        check_rec->other_size = 0;
-        check_rec->other_data = NULL;
-
-        ndr_err = ndr_push_struct_blob(&packet_blob, mem_ctx, packet,
-                (ndr_push_flags_fn_t)ndr_push_dns_name_packet);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                DEBUG(1, ("Failed to push packet: %s!\n",
-                          ndr_errstr(ndr_err)));
-                return DNS_ERR(SERVER_FAILURE);
-        }
-
-        ndr_err = ndr_push_struct_blob(&tsig_blob, mem_ctx, check_rec,
-                (ndr_push_flags_fn_t)ndr_push_dns_fake_tsig_rec);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                DEBUG(1, ("Failed to push packet: %s!\n",
-                          ndr_errstr(ndr_err)));
-                return DNS_ERR(SERVER_FAILURE);
-        }
-
-        buffer_len = packet_blob.length + tsig_blob.length;
-        buffer = talloc_zero_array(mem_ctx, uint8_t, buffer_len);
-        if (buffer == NULL) {
-                return WERR_NOMEM;
-        }
-
-        memcpy(buffer, packet_blob.data, packet_blob.length);
-        memcpy(buffer+packet_blob.length, tsig_blob.data, tsig_blob.length);
-
-
-        status = gensec_sign_packet(tkey->gensec, mem_ctx, buffer, buffer_len,
-                                    buffer, buffer_len, &sig);
-        if (!NT_STATUS_IS_OK(status)) {
-                return ntstatus_to_werror(status);
-        }
-
-        tsig->name = talloc_strdup(tsig, check_rec->name);
+        if (state->tsig_error == DNS_RCODE_OK) {
+                struct dns_server_tkey *tkey = dns_find_tkey(
+                        dns->tkeys, state->key_name);
+                if (tkey == NULL) {
+                        return DNS_ERR(SERVER_FAILURE);
+                }
+
+                werror = dns_tsig_compute_mac(mem_ctx, state, packet,
+                                              tkey, current_time, &sig);
+                if (!W_ERROR_IS_OK(werror)) {
+                        return werror;
+                }
+        }
+
+        tsig->name = talloc_strdup(tsig, state->key_name);
         if (tsig->name == NULL) {
                 return WERR_NOMEM;
         }
-        tsig->rr_class = check_rec->rr_class;
+        tsig->rr_class = DNS_QCLASS_ANY;
         tsig->rr_type = DNS_QTYPE_TSIG;
         tsig->ttl = 0;
         tsig->length = UINT16_MAX;
-        tsig->rdata.tsig_record.algorithm_name = talloc_strdup(tsig,
-                        check_rec->algorithm_name);
-        tsig->rdata.tsig_record.time_prefix = check_rec->time_prefix;
-        tsig->rdata.tsig_record.time = check_rec->time;
-        tsig->rdata.tsig_record.fudge = check_rec->fudge;
+        tsig->rdata.tsig_record.algorithm_name = talloc_strdup(tsig, "gss-tsig");
+        tsig->rdata.tsig_record.time_prefix = 0;
+        tsig->rdata.tsig_record.time = current_time;
+        tsig->rdata.tsig_record.fudge = 300;
         tsig->rdata.tsig_record.error = state->tsig_error;
         tsig->rdata.tsig_record.original_id = packet->id;
         tsig->rdata.tsig_record.other_size = 0;
         tsig->rdata.tsig_record.other_data = NULL;
-        tsig->rdata.tsig_record.mac_size = sig.length;
-        tsig->rdata.tsig_record.mac = talloc_memdup(tsig, sig.data, sig.length);
-
+        if (sig.length > 0) {
+                tsig->rdata.tsig_record.mac_size = sig.length;
+                tsig->rdata.tsig_record.mac = talloc_memdup(tsig, sig.data, sig.length);
+        }
 
         if (packet->arcount == 0) {

vendor/current/source4/dns_server/dns_server.c

@@ -153 +153 @@
         }
 
-        ret = dns_verify_tsig(dns, state, &state->state, &state->in_packet, in);
-        if (!W_ERROR_IS_OK(ret)) {
-                DEBUG(1, ("Failed to verify TSIG!\n"));
-                state->dns_err = werr_to_dns_err(ret);
-                tevent_req_done(req);
-                return tevent_req_post(req, ev);
-        }
-
         if (state->in_packet.operation & DNS_FLAG_REPLY) {
                 DEBUG(1, ("Won't reply to replies.\n"));
@@ -176 +168 @@
 
         state->out_packet = state->in_packet;
+
+        ret = dns_verify_tsig(dns, state, &state->state, &state->out_packet, in);
+        if (!W_ERROR_IS_OK(ret)) {
+                state->dns_err = werr_to_dns_err(ret);
+                tevent_req_done(req);
+                return tevent_req_post(req, ev);
+        }
 
         switch (state->in_packet.operation & DNS_OPCODE) {
@@ -237 +236 @@
         }
         if ((state->dns_err != DNS_RCODE_OK) &&
-            (state->dns_err != DNS_RCODE_NXDOMAIN)) {
+            (state->dns_err != DNS_RCODE_NXDOMAIN) &&
+            (state->dns_err != DNS_RCODE_NOTAUTH))
+        {
                 goto drop;
         }

vendor/current/source4/dsdb/samdb/ldb_modules/objectclass_attrs.c

@@ -420 +420 @@
         }
 
+        /*
+         * We skip this check under dbcheck to allow fixing of other
+         * attributes even if an attribute is missing.  This matters
+         * for CN=RID Set as the required attribute rIDNextRid is not
+         * replicated.
+         */
         if (found_must_contain[0] != NULL &&
-            ldb_msg_check_string_attribute(msg, "isDeleted", "TRUE") == 0) {
+            ldb_msg_check_string_attribute(msg, "isDeleted", "TRUE") == 0 &&
+            ldb_request_get_control(ac->req, DSDB_CONTROL_DBCHECK) == NULL) {
                 ldb_asprintf_errstring(ldb, "objectclass_attrs: at least one mandatory attribute ('%s') on entry '%s' wasn't specified!",
                                        found_must_contain[0],

vendor/current/source4/dsdb/samdb/ldb_modules/ranged_results.c

@@ -202 +202 @@
         for (i = 0; req->op.search.attrs && req->op.search.attrs[i]; i++) {
                 char *p;
+                size_t range_len = strlen(";range=");
+
                 new_attrs = talloc_realloc(req, new_attrs, const char *, i+2);
                 new_attrs[i] = req->op.search.attrs[i];
@@ -209 +211 @@
                         continue;
                 }
-                if (strncasecmp(p, ";range=", strlen(";range=")) != 0) {
+                if (strncasecmp(p, ";range=", range_len) != 0) {
                         continue;
                 }
                 end = (unsigned int)-1;
-                if (sscanf(p, ";range=%u-*", &start) != 1) {
-                        if (sscanf(p, ";range=%u-%u", &start, &end) != 2) {
+                if (sscanf(p + range_len, "%u-*", &start) != 1) {
+                        if (sscanf(p + range_len, "%u-%u", &start, &end) != 2) {
                                 ldb_asprintf_errstring(ldb,
                                         "range request error: "

vendor/current/source4/heimdal/kdc/misc.c

@@ -41 +41 @@
               krb5_const_principal principal,
               unsigned flags,
-              krb5uint32 *kvno_ptr,
+              krb5int32 *kvno_ptr,
               HDB **db,
               hdb_entry_ex **h)

vendor/current/source4/heimdal/lib/asn1/krb5.asn1

@@ -361 +361 @@
 EncryptedData ::= SEQUENCE {
         etype[0]                ENCTYPE, -- EncryptionType
-        kvno[1]                 krb5uint32 OPTIONAL,
+        kvno[1]                 krb5int32 OPTIONAL,
         cipher[2]               OCTET STRING -- ciphertext
 }

vendor/current/source4/heimdal/lib/krb5/mcache.c

@@ -156 +156 @@
 }
 
+static void KRB5_CALLCONV
+mcc_destroy_internal(krb5_context context,
+                     krb5_mcache *m)
+{
+    struct link *l;
+
+    if (m->primary_principal != NULL) {
+        krb5_free_principal (context, m->primary_principal);
+        m->primary_principal = NULL;
+    }
+    m->dead = 1;
+
+    l = m->creds;
+    while (l != NULL) {
+        struct link *old;
+
+        krb5_free_cred_contents (context, &l->cred);
+        old = l;
+        l = l->next;
+        free (old);
+    }
+
+    m->creds = NULL;
+    return;
+}
+
 static krb5_error_code KRB5_CALLCONV
 mcc_initialize(krb5_context context,
@@ -162 +188 @@
 {
     krb5_mcache *m = MCACHE(id);
+    /*
+     * It's important to destroy any existing
+     * creds here, that matches the baheviour
+     * of all other backends and also the
+     * MEMORY: backend in MIT.
+     */
+    mcc_destroy_internal(context, m);
     m->dead = 0;
+    m->kdc_offset = 0;
     m->mtime = time(NULL);
     return krb5_copy_principal (context,
@@ -196 +230 @@
 {
     krb5_mcache **n, *m = MCACHE(id);
-    struct link *l;
 
     if (m->refcnt == 0)
@@ -212 +245 @@
         }
         HEIMDAL_MUTEX_unlock(&mcc_mutex);
-        if (m->primary_principal != NULL) {
-            krb5_free_principal (context, m->primary_principal);
-            m->primary_principal = NULL;
-        }
-        m->dead = 1;
-
-        l = m->creds;
-        while (l != NULL) {
-            struct link *old;
-
-            krb5_free_cred_contents (context, &l->cred);
-            old = l;
-            l = l->next;
-            free (old);
-        }
-        m->creds = NULL;
+        mcc_destroy_internal(context, m);
     }
     return 0;

vendor/current/source4/lib/wmi/wmi_wrap.c

@@ -40 +40 @@
 /* attribute recognised by some compilers to avoid 'unused' warnings */
 #ifndef SWIGUNUSED
-# if defined(__GNUC__)
-#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
-#     define SWIGUNUSED __attribute__ ((__unused__)) 
-#   else
-#     define SWIGUNUSED
-#   endif
-# elif defined(__ICC)
+# ifdef HAVE___ATTRIBUTE__
 #   define SWIGUNUSED __attribute__ ((__unused__)) 
 # else

vendor/current/source4/librpc/rpc/dcerpc.c

@@ -156 +156 @@
         c->srv_max_xmit_frag = 5840;
         c->srv_max_recv_frag = 5840;
+        c->max_total_response_size = DCERPC_NCACN_RESPONSE_DEFAULT_MAX_SIZE;
         c->pending = NULL;
 
@@ -1415 +1416 @@
         /* the bind_ack might contain a reply set of credentials */
         if (pkt->auth_length != 0 && sec->tmp_auth_info.in != NULL) {
-                uint32_t auth_length;
-
                 status = dcerpc_pull_auth_trailer(pkt, sec->tmp_auth_info.mem,
                                                   &pkt->u.bind_ack.auth_info,
                                                   sec->tmp_auth_info.in,
-                                                  &auth_length, true);
+                                                  NULL, true);
                 if (tevent_req_nterror(req, status)) {
                         return;
@@ -1578 +1577 @@
         length = pkt->u.response.stub_and_verifier.length;
 
-        if (req->payload.length + length > DCERPC_NCACN_PAYLOAD_MAX_SIZE) {
+        if (req->payload.length + length > c->max_total_response_size) {
                 DEBUG(2,("Unexpected total payload 0x%X > 0x%X dcerpc response\n",
                          (unsigned)req->payload.length + length,
-                         DCERPC_NCACN_PAYLOAD_MAX_SIZE));
+                         (unsigned)c->max_total_response_size));
                 dcerpc_connection_dead(c, NT_STATUS_RPC_PROTOCOL_ERROR);
                 return;
@@ -2435 +2434 @@
         /* the alter_resp might contain a reply set of credentials */
         if (pkt->auth_length != 0 && sec->tmp_auth_info.in != NULL) {
-                uint32_t auth_length;
-
                 status = dcerpc_pull_auth_trailer(pkt, sec->tmp_auth_info.mem,
                                                   &pkt->u.alter_resp.auth_info,
                                                   sec->tmp_auth_info.in,
-                                                  &auth_length, true);
+                                                  NULL, true);
                 if (tevent_req_nterror(req, status)) {
                         return;

vendor/current/source4/librpc/rpc/dcerpc.h

@@ -108 +108 @@
         /* the next context_id to be assigned */
         uint32_t next_context_id;
+
+        /* The maximum total payload of reassembled response pdus */
+        size_t max_total_response_size;
 };
 

vendor/current/source4/ntvfs/posix/posix_eadb.c

@@ -22 +22 @@
 #include "includes.h"
 #include "lib/tdb_wrap/tdb_wrap.h"
+#ifdef WITH_NTVFS_FILESERVER
 #include "vfs_posix.h"
+#endif
 #include "posix_eadb.h"
 
@@ -144 +146 @@
 }
 
-NTSTATUS pull_xattr_blob_tdb(struct pvfs_state *pvfs_state,
-                             TALLOC_CTX *mem_ctx,
-                             const char *attr_name,
-                             const char *fname,
-                             int fd,
-                             size_t estimated_size,
-                             DATA_BLOB *blob)
-{
-        return pull_xattr_blob_tdb_raw(pvfs_state->ea_db,mem_ctx,attr_name,fname,fd,estimated_size,blob);
-}
-
 /*
   push a xattr as a blob, using ea_tdb
@@ -200 +191 @@
         return status;
 }
-NTSTATUS push_xattr_blob_tdb(struct pvfs_state *pvfs_state,
-                             const char *attr_name,
-                             const char *fname,
-                             int fd,
-                             const DATA_BLOB *blob)
-{
-        return push_xattr_blob_tdb_raw(pvfs_state->ea_db, attr_name, fname, fd, blob);
-}
 
 
@@ -235 +218 @@
 
 /*
-  delete a xattr
-*/
-NTSTATUS delete_posix_eadb(struct pvfs_state *pvfs_state, const char *attr_name,
-                          const char *fname, int fd)
-{
-        return delete_posix_eadb_raw(pvfs_state->ea_db,
-                                    attr_name, fname, fd);
-}
-
-
-/*
   delete all xattrs for a file
 */
@@ -272 +244 @@
 
 /*
-  delete all xattrs for a file
-*/
-NTSTATUS unlink_posix_eadb(struct pvfs_state *pvfs_state, const char *fname)
-{
-        return unlink_posix_eadb_raw(pvfs_state->ea_db, fname, -1);
-}
-
-/*
   list all xattrs for a file
 */
@@ -289 +253 @@
                                      fname, fd, 100, list);
 }
+
+#ifdef WITH_NTVFS_FILESERVER
+NTSTATUS pull_xattr_blob_tdb(struct pvfs_state *pvfs_state,
+                             TALLOC_CTX *mem_ctx,
+                             const char *attr_name,
+                             const char *fname,
+                             int fd,
+                             size_t estimated_size,
+                             DATA_BLOB *blob)
+{
+        return pull_xattr_blob_tdb_raw(pvfs_state->ea_db,mem_ctx,attr_name,fname,fd,estimated_size,blob);
+}
+
+NTSTATUS push_xattr_blob_tdb(struct pvfs_state *pvfs_state,
+                             const char *attr_name,
+                             const char *fname,
+                             int fd,
+                             const DATA_BLOB *blob)
+{
+        return push_xattr_blob_tdb_raw(pvfs_state->ea_db, attr_name, fname, fd, blob);
+}
+
+/*
+  delete a xattr
+*/
+NTSTATUS delete_posix_eadb(struct pvfs_state *pvfs_state, const char *attr_name,
+                          const char *fname, int fd)
+{
+        return delete_posix_eadb_raw(pvfs_state->ea_db,
+                                    attr_name, fname, fd);
+}
+
+/*
+  delete all xattrs for a file
+*/
+NTSTATUS unlink_posix_eadb(struct pvfs_state *pvfs_state, const char *fname)
+{
+        return unlink_posix_eadb_raw(pvfs_state->ea_db, fname, -1);
+}
+
+#endif

vendor/current/source4/ntvfs/posix/wscript_build

@@ -1 +1 @@
 #!/usr/bin/env python
 
-bld.SAMBA_SUBSYSTEM('pvfs_acl',
-        source='pvfs_acl.c',
-        autoproto='vfs_acl_proto.h',
-        deps='events samba-modules',
-        )
+if bld.CONFIG_SET('WITH_NTVFS_FILESERVER'):
+    bld.SAMBA_SUBSYSTEM('pvfs_acl',
+                        source='pvfs_acl.c',
+                        autoproto='vfs_acl_proto.h',
+                        deps='events samba-modules',
+    )
 
 
-bld.SAMBA_MODULE('pvfs_acl_xattr',
-        source='pvfs_acl_xattr.c',
-        subsystem='pvfs_acl',
-        init_function='pvfs_acl_xattr_init',
-        deps='NDR_XATTR events'
-        )
+    bld.SAMBA_MODULE('pvfs_acl_xattr',
+                     source='pvfs_acl_xattr.c',
+                     subsystem='pvfs_acl',
+                     init_function='pvfs_acl_xattr_init',
+                    deps='NDR_XATTR events'
+    )
 
 
-bld.SAMBA_MODULE('pvfs_acl_nfs4',
-        source='pvfs_acl_nfs4.c',
-        subsystem='pvfs_acl',
-        init_function='pvfs_acl_nfs4_init',
-        deps='NDR_NFS4ACL samdb events'
-        )
+    bld.SAMBA_MODULE('pvfs_acl_nfs4',
+                     source='pvfs_acl_nfs4.c',
+                     subsystem='pvfs_acl',
+                     init_function='pvfs_acl_nfs4_init',
+                    deps='NDR_NFS4ACL samdb events'
+    )
 
 
-bld.SAMBA_SUBSYSTEM('pvfs_aio',
-        source='pvfs_aio.c',
-        deps='tevent',
-        enabled=False
-        )
+    bld.SAMBA_SUBSYSTEM('pvfs_aio',
+                        source='pvfs_aio.c',
+                        deps='tevent',
+                    enabled=False
+    )
 
 
-bld.SAMBA_MODULE('ntvfs_posix',
-        source='vfs_posix.c pvfs_util.c pvfs_search.c pvfs_dirlist.c pvfs_fileinfo.c pvfs_unlink.c pvfs_mkdir.c pvfs_open.c pvfs_read.c pvfs_flush.c pvfs_write.c pvfs_fsinfo.c pvfs_qfileinfo.c pvfs_setfileinfo.c pvfs_rename.c pvfs_resolve.c pvfs_shortname.c pvfs_lock.c pvfs_oplock.c pvfs_wait.c pvfs_seek.c pvfs_ioctl.c pvfs_xattr.c pvfs_streams.c pvfs_notify.c pvfs_sys.c xattr_system.c',
-        autoproto='vfs_posix_proto.h',
-        subsystem='ntvfs',
-        init_function='ntvfs_posix_init',
-        deps='NDR_XATTR attr ntvfs_common MESSAGING LIBWBCLIENT_OLD pvfs_acl pvfs_aio posix_eadb',
-        internal_module=True
-        )
+    bld.SAMBA_MODULE('ntvfs_posix',
+                     source='vfs_posix.c pvfs_util.c pvfs_search.c pvfs_dirlist.c pvfs_fileinfo.c pvfs_unlink.c pvfs_mkdir.c pvfs_open.c pvfs_read.c pvfs_flush.c pvfs_write.c pvfs_fsinfo.c pvfs_qfileinfo.c pvfs_setfileinfo.c pvfs_rename.c pvfs_resolve.c pvfs_shortname.c pvfs_lock.c pvfs_oplock.c pvfs_wait.c pvfs_seek.c pvfs_ioctl.c pvfs_xattr.c pvfs_streams.c pvfs_notify.c pvfs_sys.c xattr_system.c',
+                     autoproto='vfs_posix_proto.h',
+                     subsystem='ntvfs',
+                    init_function='ntvfs_posix_init',
+                     deps='NDR_XATTR attr ntvfs_common MESSAGING LIBWBCLIENT_OLD pvfs_acl pvfs_aio posix_eadb',
+                     internal_module=True
+    )
 
 

vendor/current/source4/ntvfs/wscript_build

@@ -6 +6 @@
                   deps='tevent samba-modules',
                   private_library=True,
-                  enabled=bld.AD_DC_BUILD_IS_ENABLED()
+                  enabled=bld.CONFIG_SET('WITH_NTVFS_FILESERVER')
                   )
 
-if bld.AD_DC_BUILD_IS_ENABLED():
-    bld.RECURSE('posix')
+bld.RECURSE('posix')
+if bld.CONFIG_SET('WITH_NTVFS_FILESERVER'):
     bld.RECURSE('common')
     bld.RECURSE('unixuid')
     bld.RECURSE('sysdep')
 
-bld.SAMBA_MODULE('ntvfs_cifs',
-        source='cifs/vfs_cifs.c',
-        subsystem='ntvfs',
-        init_function='ntvfs_cifs_init',
-        deps='LIBCLI_SMB smbclient-raw param_options'
-        )
+    bld.SAMBA_MODULE('ntvfs_cifs',
+                     source='cifs/vfs_cifs.c',
+                     subsystem='ntvfs',
+                     init_function='ntvfs_cifs_init',
+                     deps='LIBCLI_SMB smbclient-raw param_options'
+    )
 
 
-bld.SAMBA_MODULE('ntvfs_smb2',
-        source='smb2/vfs_smb2.c',
-        subsystem='ntvfs',
-        init_function='ntvfs_smb2_init',
-        deps='LIBCLI_SMB smbclient-raw param_options'
-        )
+    bld.SAMBA_MODULE('ntvfs_smb2',
+                     source='smb2/vfs_smb2.c',
+                     subsystem='ntvfs',
+                     init_function='ntvfs_smb2_init',
+                     deps='LIBCLI_SMB smbclient-raw param_options'
+    )
 
 
-bld.SAMBA_MODULE('ntvfs_simple',
-        source='simple/vfs_simple.c simple/svfs_util.c',
-        autoproto='simple/proto.h',
-        subsystem='ntvfs',
-        init_function='ntvfs_simple_init',
-        deps='talloc'
-        )
+    bld.SAMBA_MODULE('ntvfs_simple',
+                     source='simple/vfs_simple.c simple/svfs_util.c',
+                     autoproto='simple/proto.h',
+                     subsystem='ntvfs',
+                     init_function='ntvfs_simple_init',
+                     deps='talloc'
+    )
 
 
-bld.SAMBA_MODULE('ntvfs_cifsposix',
-        source='cifs_posix_cli/vfs_cifs_posix.c cifs_posix_cli/svfs_util.c',
-        autoproto='cifs_posix_cli/proto.h',
-        subsystem='ntvfs',
-        init_function='ntvfs_cifs_posix_init',
-        deps='talloc'
-        )
+    bld.SAMBA_MODULE('ntvfs_cifsposix',
+                     source='cifs_posix_cli/vfs_cifs_posix.c cifs_posix_cli/svfs_util.c',
+                     autoproto='cifs_posix_cli/proto.h',
+                     subsystem='ntvfs',
+                     init_function='ntvfs_cifs_posix_init',
+                    deps='talloc'
+    )
 
 
-bld.SAMBA_MODULE('ntvfs_print',
-        source='print/vfs_print.c',
-        subsystem='ntvfs',
-        init_function='ntvfs_print_init',
-        deps='talloc'
-        )
+    bld.SAMBA_MODULE('ntvfs_print',
+                     source='print/vfs_print.c',
+                    subsystem='ntvfs',
+                     init_function='ntvfs_print_init',
+                     deps='talloc'
+    )
 
 
-bld.SAMBA_MODULE('ntvfs_ipc',
-        source='ipc/vfs_ipc.c ipc/ipc_rap.c ipc/rap_server.c',
-        autoproto='ipc/proto.h',
-        subsystem='ntvfs',
-        init_function='ntvfs_ipc_init',
-        deps='NDR_NAMED_PIPE_AUTH npa_tstream gssapi samba-credentials DCERPC_SHARE'
-        )
+    bld.SAMBA_MODULE('ntvfs_ipc',
+                     source='ipc/vfs_ipc.c ipc/ipc_rap.c ipc/rap_server.c',
+                     autoproto='ipc/proto.h',
+                    subsystem='ntvfs',
+                     init_function='ntvfs_ipc_init',
+                     deps='NDR_NAMED_PIPE_AUTH npa_tstream gssapi samba-credentials DCERPC_SHARE'
+    )
 
 
-bld.SAMBA_MODULE('ntvfs_nbench',
-        source='nbench/vfs_nbench.c',
-        subsystem='ntvfs',
-        init_function='ntvfs_nbench_init',
-        deps='talloc'
-        )
+    bld.SAMBA_MODULE('ntvfs_nbench',
+                     source='nbench/vfs_nbench.c',
+                     subsystem='ntvfs',
+                     init_function='ntvfs_nbench_init',
+                     deps='talloc'
+    )
 
 

vendor/current/source4/param/pyparam.c

@@ -322 +322 @@
 
 }
+
+static PyObject *py_lp_log_level(PyObject *self, PyObject *unused)
+{
+        int ret = DEBUGLEVEL_CLASS[DBGC_CLASS];
+        return PyInt_FromLong(ret);
+}
+
 
 static PyObject *py_samdb_url(PyObject *self, PyObject *unused)
@@ -358 +365 @@
         { "dump", py_lp_dump, METH_VARARGS,
                 "S.dump(stream, show_defaults=False)" },
+        { "log_level", py_lp_log_level, METH_NOARGS,
+                "S.log_level() -> int\n Get the active log level" },
         { "dump_a_parameter", py_lp_dump_a_parameter, METH_VARARGS,
                 "S.dump_a_parameter(stream, name, service_name)" },

vendor/current/source4/rpc_server/common/server_info.c

@@ -27 +27 @@
 #include "param/param.h"
 #include "rpc_server/common/common.h"
-#include "rpc_server/common/share.h"
 #include "libds/common/roles.h"
 

vendor/current/source4/rpc_server/dcerpc_server.c

@@ -409 +409 @@
         p->max_recv_frag = 5840;
         p->max_xmit_frag = 5840;
+        p->max_total_request_size = DCERPC_NCACN_REQUEST_DEFAULT_MAX_SIZE;
 
         *_p = p;
@@ -804 +805 @@
                 TALLOC_FREE(call->context);
 
+                if (call->fault_code == DCERPC_NCA_S_PROTO_ERROR) {
+                        return dcesrv_bind_nak(call,
+                        DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED);
+                }
+
                 if (auth->auth_level != DCERPC_AUTH_LEVEL_NONE) {
                         /*
@@ -936 +942 @@
         if (!dcesrv_auth_auth3(call)) {
                 call->conn->auth_state.auth_invalid = true;
+                if (call->fault_code != 0) {
+                        return dcesrv_fault_disconnect(call, call->fault_code);
+                }
         }
 
@@ -1105 +1114 @@
         auth_ok = dcesrv_auth_alter(call);
         if (!auth_ok) {
-                if (call->in_auth_info.auth_type == DCERPC_AUTH_TYPE_NONE) {
-                        return dcesrv_fault_disconnect(call,
-                                        DCERPC_FAULT_ACCESS_DENIED);
+                if (call->fault_code != 0) {
+                        return dcesrv_fault_disconnect(call, call->fault_code);
                 }
         }
@@ -1533 +1541 @@
                  * Up to 4 MByte are allowed by all fragments
                  */
-                available = DCERPC_NCACN_PAYLOAD_MAX_SIZE;
+                available = dce_conn->max_total_request_size;
                 if (er->stub_and_verifier.length > available) {
                         dcesrv_call_disconnect_after(existing,
@@ -1586 +1594 @@
                  * Up to 4 MByte are allowed by all fragments
                  */
-                if (call->pkt.u.request.alloc_hint > DCERPC_NCACN_PAYLOAD_MAX_SIZE) {
+                if (call->pkt.u.request.alloc_hint > dce_conn->max_total_request_size) {
                         dcesrv_call_disconnect_after(call,
                                 "dcesrv_auth_request - initial alloc hint too large");

vendor/current/source4/rpc_server/dcerpc_server.h

@@ -274 +274 @@
         /* the association group the connection belongs to */
         struct dcesrv_assoc_group *assoc_group;
+
+        /* The maximum total payload of reassembled request pdus */
+        size_t max_total_request_size;
 };
 

vendor/current/source4/rpc_server/dcesrv_auth.c

@@ -45 +45 @@
         struct dcesrv_auth *auth = &dce_conn->auth_state;
         NTSTATUS status;
-        uint32_t auth_length;
 
         if (pkt->auth_length == 0) {
@@ -56 +55 @@
         status = dcerpc_pull_auth_trailer(pkt, call, &pkt->u.bind.auth_info,
                                           &call->in_auth_info,
-                                          &auth_length, false);
-        if (!NT_STATUS_IS_OK(status)) {
+                                          NULL, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                /*
+                 * This will cause a
+                 * DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED
+                 * in the caller
+                 */
+                call->fault_code = DCERPC_NCA_S_PROTO_ERROR;
                 return false;
         }
@@ -242 +247 @@
         struct dcesrv_connection *dce_conn = call->conn;
         NTSTATUS status;
-        uint32_t auth_length;
 
         if (pkt->auth_length == 0) {
@@ -258 +262 @@
 
         status = dcerpc_pull_auth_trailer(pkt, call, &pkt->u.auth3.auth_info,
-                                          &call->in_auth_info, &auth_length, true);
-        if (!NT_STATUS_IS_OK(status)) {
+                                          &call->in_auth_info, NULL, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                /*
+                 * Windows returns DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY
+                 * instead of DCERPC_NCA_S_PROTO_ERROR.
+                 */
+                call->fault_code = DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY;
                 return false;
         }
@@ -325 +334 @@
         struct dcesrv_connection *dce_conn = call->conn;
         NTSTATUS status;
-        uint32_t auth_length;
 
         /* on a pure interface change there is no auth blob */
@@ -336 +344 @@
 
         if (dce_conn->auth_state.auth_finished) {
+                call->fault_code = DCERPC_FAULT_ACCESS_DENIED;
                 return false;
         }
@@ -345 +354 @@
 
         status = dcerpc_pull_auth_trailer(pkt, call, &pkt->u.alter.auth_info,
-                                          &call->in_auth_info, &auth_length, true);
-        if (!NT_STATUS_IS_OK(status)) {
+                                          &call->in_auth_info, NULL, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                call->fault_code = DCERPC_NCA_S_PROTO_ERROR;
+                return false;
+        }
+
+        if (call->in_auth_info.auth_type == DCERPC_AUTH_TYPE_NONE) {
+                call->fault_code = DCERPC_FAULT_ACCESS_DENIED;
                 return false;
         }

vendor/current/source4/rpc_server/wkssvc/dcesrv_wkssvc.c

@@ -25 +25 @@
 #include "librpc/gen_ndr/ndr_srvsvc.h"
 #include "rpc_server/common/common.h"
-#include "rpc_server/common/share.h"
 #include "param/param.h"
 

vendor/current/source4/rpc_server/wscript_build

@@ -2 +2 @@
 
 bld.SAMBA_SUBSYSTEM('DCERPC_SHARE',
-        source='common/server_info.c common/share_info.c',
+        source='common/share_info.c',
         autoproto='common/share.h',
         deps='ldb',
-        enabled=bld.AD_DC_BUILD_IS_ENABLED()
+        enabled=bld.CONFIG_SET('WITH_NTVFS_FILESERVER'),
         )
 
 bld.SAMBA_SUBSYSTEM('DCERPC_COMMON',
-        source='common/forward.c common/reply.c dcesrv_auth.c common/loadparm.c',
+        source='common/server_info.c common/forward.c common/reply.c dcesrv_auth.c common/loadparm.c',
         autoproto='common/proto.h',
         deps='ldb DCERPC_SHARE samba_server_gensec',
@@ -55 +55 @@
         subsystem='dcerpc_server',
         init_function='dcerpc_server_srvsvc_init',
-        deps='DCERPC_COMMON NDR_SRVSVC share ntvfs'
+        deps='DCERPC_COMMON NDR_SRVSVC share ntvfs',
+        enabled=bld.CONFIG_SET('WITH_NTVFS_FILESERVER')
         )
 
@@ -89 +90 @@
         init_function='dcerpc_server_winreg_init',
         deps='registry ndr-standard',
-        internal_module=True
+        internal_module=True,
+        enabled=bld.CONFIG_SET('WITH_NTVFS_FILESERVER')
         )
 
@@ -133 +135 @@
         init_function='dcerpc_server_spoolss_init',
         deps='DCERPC_COMMON NDR_SPOOLSS ntptr RPC_NDR_SPOOLSS',
-        internal_module=True
+        internal_module=True,
+        enabled=bld.CONFIG_SET('WITH_NTVFS_FILESERVER')
         )
 

vendor/current/source4/scripting/bin/samba_spnupdate

@@ -220 +220 @@
     try:
         binding_options = "seal"
-        if int(lp.get("log level")) >= 5:
+        if lp.log_level() >= 5:
             binding_options += ",print"
         drs = drsuapi.drsuapi('ncacn_ip_tcp:%s[%s]' % (server, binding_options), lp, creds)

vendor/current/source4/selftest/tests.py

@@ -301 +301 @@
 ntvfsargs = ["--option=torture:sharedelay=100000", "--option=torture:oplocktimeout=3", "--option=torture:writetimeupdatedelay=500000"]
 
-# smb2.change_notify_disabled must only run against env fileserver-notify-disabled
-smb2 = filter(lambda x: "smb2.change_notify_disabled" not in x, smbtorture4_testsuites("smb2."))
+# Filter smb2 tests that should not run against ad_dc_ntvfs
+smb2_s3only = ["smb2.change_notify_disabled", "smb2.dosmode"]
+smb2 = [x for x in smbtorture4_testsuites("smb2.") if x not in smb2_s3only]
 
 #The QFILEINFO-IPC test needs to be on ipc$
@@ -358 +359 @@
 # DNS tests
 plantestsuite_loadlist("samba.tests.dns", "fl2003dc:local", [python, os.path.join(srcdir(), "python/samba/tests/dns.py"), '$SERVER', '$SERVER_IP', '--machine-pass', '-U"$USERNAME%$PASSWORD"', '--workgroup=$DOMAIN', '$LOADLIST', '$LISTOPT'])
+
+plantestsuite_loadlist("samba.tests.dns_tkey", "fl2008r2dc", [python, os.path.join(srcdir(), "python/samba/tests/dns_tkey.py"), '$SERVER', '$SERVER_IP', '--machine-pass', '-U"$USERNAME%$PASSWORD"', '--workgroup=$DOMAIN', '$LOADLIST', '$LISTOPT'])
 
 for t in smbtorture4_testsuites("dns_internal."):
@@ -508 +511 @@
     plantestsuite("samba.ntlm_auth.(%s:local)" % env, "%s:local" % env, [os.path.join(samba3srcdir, "script/tests/test_ntlm_auth_s3.sh"), valgrindify(python), samba3srcdir, ntlm_auth3,  '$DOMAIN', '$DC_USERNAME', '$DC_PASSWORD', configuration])
 
+for env in ["s4member_dflt_domain", "s4member"]:
+    for cmd in ["id", "getent"]:
+        users = ["$DC_USERNAME", "$DC_USERNAME@$REALM"]
+        if env == "s4member":
+            users = ["$DOMAIN/$DC_USERNAME", "$DC_USERNAME@$REALM"]
+        for usr in users:
+            plantestsuite("samba4.winbind.dom_name_parse.cmd", env, "%s/dom_parse.sh %s %s" % (bbdir,cmd,usr))
 
 nsstest4 = binpath("nsstest")
@@ -537 +547 @@
 planpythontestsuite("ad_dc_ntvfs:local", "samba.tests.dcerpc.srvsvc")
 planpythontestsuite("ad_dc_ntvfs:local", "samba.tests.samba_tool.timecmd")
+
+# test fsmo show
+for env in ["ad_dc_ntvfs", "fl2000dc", "fl2003dc", "fl2008r2dc"]:
+    planpythontestsuite(env + ":local", "samba.tests.samba_tool.fsmo")
 
 # We run this test against both AD DC implemetnations because it is

vendor/current/source4/smb_server/service_smb.c

@@ -35 +35 @@
 #include "param/param.h"
 #include "file_server/file_server.h"
-
+#include "ntvfs/ntvfs.h"
+#include "lib/cmdline/popt_common.h"
 /*
   open the smb server sockets
@@ -87 +88 @@
 NTSTATUS server_service_smb_init(void)
 {
+        ntvfs_init(cmdline_lp_ctx);
         share_init();
         return register_server_service("smb", smbsrv_task_init);

vendor/current/source4/smb_server/wscript_build

@@ -6 +6 @@
         subsystem='service',
         init_function='server_service_smb_init',
-        deps='SMB_SERVER netif shares samba-hostconfig',
+        deps='SMB_SERVER netif shares samba-hostconfig POPT_SAMBA',
         internal_module=False,
         enabled=bld.CONFIG_SET('WITH_NTVFS_FILESERVER')

vendor/current/source4/smbd/server.c

@@ -29 +29 @@
 #include "system/dir.h"
 #include "system/filesys.h"
-#include "ntvfs/ntvfs.h"
 #include "ntptr/ntptr.h"
 #include "auth/gensec/gensec.h"
@@ -410 +409 @@
                                                 of the spoolss RPC server instead? */
 
-        ntvfs_init(cmdline_lp_ctx);     /* FIXME: maybe run this in the initialization functions 
-                                                of the SMB[,2] server instead? */
-
         process_model_init(cmdline_lp_ctx); 
 

vendor/current/source4/torture/raw/read.c

@@ -20 +20 @@
 #include "includes.h"
 #include "libcli/raw/libcliraw.h"
+#include "libcli/raw/raw_proto.h"
 #include "system/time.h"
 #include "system/filesys.h"
@@ -374 +375 @@
         const char *test_data = "TEST DATA";
         unsigned int seed = time(NULL);
+        struct smbcli_request *smbreq = NULL;
+        unsigned int i;
 
         buf = talloc_zero_array(tctx, uint8_t, maxsize);
@@ -422 +425 @@
 
         smbcli_write(cli->tree, fnum, 0, test_data, 0, strlen(test_data));
+
+        printf("Checking reserved fields are [0]\n");
+        io.readx.in.file.fnum = fnum;
+        io.readx.in.offset = 0;
+        io.readx.in.remaining = 0;
+        io.readx.in.read_for_execute = false;
+        io.readx.in.mincnt = strlen(test_data);
+        io.readx.in.maxcnt = strlen(test_data);
+        smbreq = smb_raw_read_send(cli->tree, &io);
+        if (smbreq == NULL) {
+                ret = false;
+                torture_fail_goto(tctx, done, "smb_raw_read_send failed\n");
+        }
+        if (!smbcli_request_receive(smbreq) ||
+             smbcli_request_is_error(smbreq)) {
+                status = smbcli_request_destroy(smbreq);
+                torture_fail_goto(tctx, done, "receive failed\n");
+        }
+
+        if (smbreq->in.wct != 12) {
+                ret = false;
+                printf("Incorrect wct %u (should be 12)\n",
+                        (unsigned int)smbreq->in.wct);
+                status = smbcli_request_destroy(smbreq);
+                torture_fail_goto(tctx, done, "bad wct\n");
+        }
+
+        /* Ensure VWV8 - WVW11 are zero. */
+        for (i = 8; i < 12; i++) {
+                uint16_t br = SVAL(smbreq->in.vwv, VWV(i));
+                if (br != 0) {
+                        status = smbcli_request_destroy(smbreq);
+                        ret = false;
+                        printf("reserved field %u is %u not zero\n",
+                                i,
+                                (unsigned int)br);
+                        torture_fail_goto(tctx, done, "bad reserved field\n");
+                }
+        }
+
+        smbcli_request_destroy(smbreq);
 
         printf("Trying small read\n");

vendor/current/source4/torture/rpc/lsa.c

@@ -3184 +3184 @@
         int kvno = cli_credentials_get_kvno(credentials);
         int expected_kvno = 0;
-        krb5uint32 t_kvno = 0;
+        krb5int32 t_kvno = 0;
         const char *host = torture_setting_string(tctx, "host", NULL);
         krb5_error_code k5ret;

vendor/current/source4/torture/smb2/getinfo.c

@@ -127 +127 @@
 }
 
+/*
+  test granted access when desired access includes
+  FILE_EXECUTE and does not include FILE_READ_DATA
+*/
+static bool torture_smb2_fileinfo_grant_read(struct torture_context *tctx)
+{
+        struct smb2_tree *tree;
+        bool ret;
+        struct smb2_handle hfile, hdir;
+        NTSTATUS status;
+        uint32_t file_granted_access, dir_granted_access;
+
+        ret = torture_smb2_connection(tctx, &tree);
+        torture_assert(tctx, ret, "connection failed");
+
+        status = torture_smb2_testfile_access(
+            tree, FNAME, &hfile, SEC_FILE_EXECUTE | SEC_FILE_READ_ATTRIBUTE);
+        torture_assert_ntstatus_ok(tctx, status,
+                                   "Unable to create test file " FNAME "\n");
+        status =
+            torture_smb2_get_allinfo_access(tree, hfile, &file_granted_access);
+        torture_assert_ntstatus_ok(tctx, status,
+                                   "Unable to query test file access ");
+        torture_assert_int_equal(tctx, file_granted_access,
+                                 SEC_FILE_EXECUTE | SEC_FILE_READ_ATTRIBUTE,
+                                 "granted file access ");
+        smb2_util_close(tree, hfile);
+
+        status = torture_smb2_testdir_access(
+            tree, DNAME, &hdir, SEC_FILE_EXECUTE | SEC_FILE_READ_ATTRIBUTE);
+        torture_assert_ntstatus_ok(tctx, status,
+                                   "Unable to create test dir " DNAME "\n");
+        status =
+            torture_smb2_get_allinfo_access(tree, hdir, &dir_granted_access);
+        torture_assert_ntstatus_ok(tctx, status,
+                                   "Unable to query test dir access ");
+        torture_assert_int_equal(tctx, dir_granted_access,
+                                 SEC_FILE_EXECUTE | SEC_FILE_READ_ATTRIBUTE,
+                                 "granted dir access ");
+        smb2_util_close(tree, hdir);
+
+        return true;
+}
 
 /*
@@ -445 +488 @@
         torture_suite_add_simple_test(suite, "qsec_buffercheck",
                                       torture_smb2_qsec_buffercheck);
+        torture_suite_add_simple_test(suite, "granted",
+                                      torture_smb2_fileinfo_grant_read);
         return suite;
 }

vendor/current/source4/torture/smb2/ioctl.c

@@ -274 +274 @@
 {
         bool ok;
+        uint32_t initial_access = desired_access;
+
+        if (size > 0) {
+                initial_access |= SEC_FILE_APPEND_DATA;
+        }
 
         smb2_util_unlink(tree, fname);
@@ -280 +285 @@
                              fname,
                              fh,
-                             desired_access,
+                             initial_access,
                              file_attributes);
-        torture_assert(torture, ok, "file open");
+        torture_assert(torture, ok, "file create");
 
         if (size > 0) {
@@ -288 +293 @@
                 torture_assert(torture, ok, "write pattern");
         }
+
+        if (initial_access != desired_access) {
+                smb2_util_close(tree, *fh);
+                ok = test_setup_open(torture, tree, mem_ctx,
+                                     fname,
+                                     fh,
+                                     desired_access,
+                                     file_attributes);
+                torture_assert(torture, ok, "file open");
+        }
+
         return true;
 }
@@ -1240 +1256 @@
         enum ndr_err_code ndr_ret;
         bool ok;
-
-        /* no read permission on src */
-        ok = test_setup_copy_chunk(torture, tree, tmp_ctx,
-                                   1, /* 1 chunk */
+        /* read permission on src */
+        ok = test_setup_copy_chunk(torture, tree, tmp_ctx, 1, /* 1 chunk */
                                    &src_h, 4096, /* fill 4096 byte src file */
-                                   SEC_RIGHTS_FILE_WRITE,
-                                   &dest_h, 0,  /* 0 byte dest file */
-                                   SEC_RIGHTS_FILE_ALL,
-                                   &cc_copy,
-                                   &ioctl);
+                                   SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE,
+                                   &dest_h, 0, /* 0 byte dest file */
+                                   SEC_RIGHTS_FILE_ALL, &cc_copy, &ioctl);
+        if (!ok) {
+                torture_fail(torture, "setup copy chunk error");
+        }
+
+        cc_copy.chunks[0].source_off = 0;
+        cc_copy.chunks[0].target_off = 0;
+        cc_copy.chunks[0].length = 4096;
+
+        ndr_ret = ndr_push_struct_blob(
+            &ioctl.smb2.in.out, tmp_ctx, &cc_copy,
+            (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
+        torture_assert_ndr_success(torture, ndr_ret,
+                                   "ndr_push_srv_copychunk_copy");
+
+        status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
+        torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
+                                      "FSCTL_SRV_COPYCHUNK");
+
+        smb2_util_close(tree, src_h);
+        smb2_util_close(tree, dest_h);
+
+        /* execute permission on src */
+        ok = test_setup_copy_chunk(torture, tree, tmp_ctx, 1, /* 1 chunk */
+                                   &src_h, 4096, /* fill 4096 byte src file */
+                                   SEC_FILE_EXECUTE | SEC_FILE_READ_ATTRIBUTE,
+                                   &dest_h, 0, /* 0 byte dest file */
+                                   SEC_RIGHTS_FILE_ALL, &cc_copy, &ioctl);
+        if (!ok) {
+                torture_fail(torture, "setup copy chunk error");
+        }
+
+        cc_copy.chunks[0].source_off = 0;
+        cc_copy.chunks[0].target_off = 0;
+        cc_copy.chunks[0].length = 4096;
+
+        ndr_ret = ndr_push_struct_blob(
+            &ioctl.smb2.in.out, tmp_ctx, &cc_copy,
+            (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
+        torture_assert_ndr_success(torture, ndr_ret,
+                                   "ndr_push_srv_copychunk_copy");
+
+        status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
+        torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
+                                      "FSCTL_SRV_COPYCHUNK");
+
+        smb2_util_close(tree, src_h);
+        smb2_util_close(tree, dest_h);
+
+        /* neither read nor execute permission on src */
+        ok = test_setup_copy_chunk(torture, tree, tmp_ctx, 1, /* 1 chunk */
+                                   &src_h, 4096, /* fill 4096 byte src file */
+                                   SEC_FILE_READ_ATTRIBUTE, &dest_h,
+                                   0, /* 0 byte dest file */
+                                   SEC_RIGHTS_FILE_ALL, &cc_copy, &ioctl);
         if (!ok) {
                 torture_fail(torture, "setup copy chunk error");
@@ -1273 +1339 @@
 
         /* no write permission on dest */
-        ok = test_setup_copy_chunk(torture, tree, tmp_ctx,
-                                   1, /* 1 chunk */
-                                   &src_h, 4096, /* fill 4096 byte src file */
-                                   SEC_RIGHTS_FILE_ALL,
-                                   &dest_h, 0,  /* 0 byte dest file */
-                                   (SEC_RIGHTS_FILE_READ
-                                    | SEC_RIGHTS_FILE_EXECUTE),
-                                   &cc_copy,
-                                   &ioctl);
+        ok = test_setup_copy_chunk(
+            torture, tree, tmp_ctx, 1, /* 1 chunk */
+            &src_h, 4096,             /* fill 4096 byte src file */
+            SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE, &dest_h,
+            0, /* 0 byte dest file */
+            (SEC_RIGHTS_FILE_ALL &
+             ~(SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA)),
+            &cc_copy, &ioctl);
         if (!ok) {
                 torture_fail(torture, "setup copy chunk error");
@@ -1305 +1370 @@
 
         /* no read permission on dest */
-        ok = test_setup_copy_chunk(torture, tree, tmp_ctx,
-                                   1, /* 1 chunk */
+        ok = test_setup_copy_chunk(torture, tree, tmp_ctx, 1, /* 1 chunk */
                                    &src_h, 4096, /* fill 4096 byte src file */
-                                   SEC_RIGHTS_FILE_ALL,
-                                   &dest_h, 0,  /* 0 byte dest file */
-                                   (SEC_RIGHTS_FILE_WRITE
-                                    | SEC_RIGHTS_FILE_EXECUTE),
-                                   &cc_copy,
-                                   &ioctl);
+                                   SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE,
+                                   &dest_h, 0, /* 0 byte dest file */
+                                   (SEC_RIGHTS_FILE_ALL & ~SEC_FILE_READ_DATA),
+                                   &cc_copy, &ioctl);
         if (!ok) {
                 torture_fail(torture, "setup copy chunk error");
@@ -2478 +2540 @@
         smb2_util_close(tree, fh);
 
+        talloc_free(tmp_ctx);
+        return true;
+}
+
+static bool test_ioctl_compress_notsup_get(struct torture_context *torture,
+                                           struct smb2_tree *tree)
+{
+        struct smb2_handle fh;
+        NTSTATUS status;
+        TALLOC_CTX *tmp_ctx = talloc_new(tree);
+        bool ok;
+        uint16_t compression_fmt;
+
+        ok = test_setup_create_fill(torture, tree, tmp_ctx,
+                                    FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
+                                    FILE_ATTRIBUTE_NORMAL);
+        torture_assert(torture, ok, "setup compression file");
+
+        /* skip if the server DOES support compression */
+        status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
+                                                  &ok);
+        torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
+        if (ok) {
+                smb2_util_close(tree, fh);
+                torture_skip(torture, "FS compression supported\n");
+        }
+
+        /*
+         * Despite not supporting compression, we should get a successful
+         * response indicating that the file is uncompressed - like WS2016.
+         */
+        status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
+                                         &compression_fmt);
+        torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
+
+        torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
+                       "initial compression state not NONE");
+
+        smb2_util_close(tree, fh);
+        talloc_free(tmp_ctx);
+        return true;
+}
+
+static bool test_ioctl_compress_notsup_set(struct torture_context *torture,
+                                           struct smb2_tree *tree)
+{
+        struct smb2_handle fh;
+        NTSTATUS status;
+        TALLOC_CTX *tmp_ctx = talloc_new(tree);
+        bool ok;
+
+        ok = test_setup_create_fill(torture, tree, tmp_ctx,
+                                    FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
+                                    FILE_ATTRIBUTE_NORMAL);
+        torture_assert(torture, ok, "setup compression file");
+
+        /* skip if the server DOES support compression */
+        status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
+                                                  &ok);
+        torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
+        if (ok) {
+                smb2_util_close(tree, fh);
+                torture_skip(torture, "FS compression supported\n");
+        }
+
+        status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
+                                         COMPRESSION_FORMAT_DEFAULT);
+        torture_assert_ntstatus_equal(torture, status,
+                                      NT_STATUS_NOT_SUPPORTED,
+                                      "FSCTL_GET_COMPRESSION");
+
+        smb2_util_close(tree, fh);
         talloc_free(tmp_ctx);
         return true;
@@ -4850 +4984 @@
         torture_suite_add_1smb2_test(suite, "compress_perms",
                                      test_ioctl_compress_perms);
+        torture_suite_add_1smb2_test(suite, "compress_notsup_get",
+                                     test_ioctl_compress_notsup_get);
+        torture_suite_add_1smb2_test(suite, "compress_notsup_set",
+                                     test_ioctl_compress_notsup_set);
         torture_suite_add_1smb2_test(suite, "network_interface_info",
                                      test_ioctl_network_interface_info);

vendor/current/source4/torture/smb2/lock.c

@@ -3030 +3030 @@
 done:
         smb2_util_close(tree, h);
+        smb2_deltree(tree, BASEDIR);
+        return ret;
+}
+
+/**
+ * Test lock interaction between smbd and ctdb with tombstone records.
+ *
+ * Re-locking an unlocked record could lead to a deadlock between
+ * smbd and ctdb. Make sure we don't regress.
+ *
+ * https://bugzilla.samba.org/show_bug.cgi?id=12005
+ * https://bugzilla.samba.org/show_bug.cgi?id=10008
+ */
+static bool test_deadlock(struct torture_context *torture,
+                          struct smb2_tree *tree)
+{
+        NTSTATUS status;
+        bool ret = true;
+        struct smb2_handle _h;
+        struct smb2_handle *h = NULL;
+        uint8_t buf[200];
+        const char *fname = BASEDIR "\\deadlock.txt";
+
+        if (!lpcfg_clustering(torture->lp_ctx)) {
+                torture_skip(torture, "Test must be run on a ctdb cluster\n");
+                return true;
+        }
+
+        status = torture_smb2_testdir(tree, BASEDIR, &_h);
+        torture_assert_ntstatus_ok(torture, status,
+                                   "torture_smb2_testdir failed");
+        smb2_util_close(tree, _h);
+
+        status = torture_smb2_testfile(tree, fname, &_h);
+        torture_assert_ntstatus_ok_goto(torture, status, ret, done,
+                                        "torture_smb2_testfile failed");
+        h = &_h;
+
+        ZERO_STRUCT(buf);
+        status = smb2_util_write(tree, *h, buf, 0, ARRAY_SIZE(buf));
+        torture_assert_ntstatus_ok_goto(torture, status, ret, done,
+                                        "smb2_util_write failed");
+
+        status = test_smb2_lock(tree, *h, 0, 1, true);
+        torture_assert_ntstatus_ok_goto(torture, status, ret, done,
+                                        "test_smb2_lock failed");
+
+        status = test_smb2_unlock(tree, *h, 0, 1);
+        torture_assert_ntstatus_ok_goto(torture, status, ret, done,
+                                        "test_smb2_unlock failed");
+
+        status = test_smb2_lock(tree, *h, 0, 1, true);
+        torture_assert_ntstatus_ok_goto(torture, status, ret, done,
+                                        "test_smb2_lock failed");
+
+        status = test_smb2_unlock(tree, *h, 0, 1);
+        torture_assert_ntstatus_ok_goto(torture, status, ret, done,
+                                        "test_smb2_unlock failed");
+
+done:
+        if (h != NULL) {
+                smb2_util_close(tree, *h);
+        }
         smb2_deltree(tree, BASEDIR);
         return ret;
@@ -3069 +3132 @@
         torture_suite_add_1smb2_test(suite, "truncate", test_truncate);
         torture_suite_add_1smb2_test(suite, "replay", test_replay);
+        torture_suite_add_1smb2_test(suite, "ctdb-delrec-deadlock", test_deadlock);
 
         suite->description = talloc_strdup(suite, "SMB2-LOCK tests");

vendor/current/source4/torture/smb2/read.c

@@ -28 +28 @@
 
 
-#define CHECK_STATUS(status, correct) do { \
-        if (!NT_STATUS_EQUAL(status, correct)) { \
-                printf("(%s) Incorrect status %s - should be %s\n", \
-                       __location__, nt_errstr(status), nt_errstr(correct)); \
-                ret = false; \
-                goto done; \
-        }} while (0)
-
-#define CHECK_VALUE(v, correct) do { \
-        if ((v) != (correct)) { \
-                printf("(%s) Incorrect value %s=%u - should be %u\n", \
-                       __location__, #v, (unsigned)v, (unsigned)correct); \
-                ret = false; \
-                goto done; \
-        }} while (0)
+#define CHECK_STATUS(_status, _expected) \
+        torture_assert_ntstatus_equal_goto(torture, _status, _expected, \
+                 ret, done, "Incorrect status")
+
+#define CHECK_VALUE(v, correct) \
+        torture_assert_int_equal_goto(torture, v, correct, \
+                 ret, done, "Incorrect value")
 
 #define FNAME "smb2_readtest.dat"
@@ -235 +227 @@
 }
 
+static bool test_read_access(struct torture_context *torture,
+                             struct smb2_tree *tree)
+{
+        bool ret = true;
+        NTSTATUS status;
+        struct smb2_handle h;
+        uint8_t buf[64 * 1024];
+        struct smb2_read rd;
+        TALLOC_CTX *tmp_ctx = talloc_new(tree);
+
+        ZERO_STRUCT(buf);
+
+        /* create a file */
+        smb2_util_unlink(tree, FNAME);
+
+        status = torture_smb2_testfile(tree, FNAME, &h);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        status = smb2_util_close(tree, h);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        /* open w/ READ access - success */
+        status = torture_smb2_testfile_access(
+            tree, FNAME, &h, SEC_FILE_READ_ATTRIBUTE | SEC_FILE_READ_DATA);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        ZERO_STRUCT(rd);
+        rd.in.file.handle = h;
+        rd.in.length = 5;
+        rd.in.offset = 0;
+        status = smb2_read(tree, tree, &rd);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        status = smb2_util_close(tree, h);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        /* open w/ EXECUTE access - success */
+        status = torture_smb2_testfile_access(
+            tree, FNAME, &h, SEC_FILE_READ_ATTRIBUTE | SEC_FILE_EXECUTE);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        ZERO_STRUCT(rd);
+        rd.in.file.handle = h;
+        rd.in.length = 5;
+        rd.in.offset = 0;
+        status = smb2_read(tree, tree, &rd);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        status = smb2_util_close(tree, h);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        /* open without READ or EXECUTE access - access denied */
+        status = torture_smb2_testfile_access(tree, FNAME, &h,
+                                              SEC_FILE_READ_ATTRIBUTE);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+        ZERO_STRUCT(rd);
+        rd.in.file.handle = h;
+        rd.in.length = 5;
+        rd.in.offset = 0;
+        status = smb2_read(tree, tree, &rd);
+        CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
+
+        status = smb2_util_close(tree, h);
+        CHECK_STATUS(status, NT_STATUS_OK);
+
+done:
+        talloc_free(tmp_ctx);
+        return ret;
+}
 
 /* 
@@ -246 +311 @@
         torture_suite_add_1smb2_test(suite, "position", test_read_position);
         torture_suite_add_1smb2_test(suite, "dir", test_read_dir);
+        torture_suite_add_1smb2_test(suite, "access", test_read_access);
 
         suite->description = talloc_strdup(suite, "SMB2-READ tests");

vendor/current/source4/torture/smb2/replay.c

@@ -95 +95 @@
 #define BASEDIR "replaytestdir"
 
-static struct {
+struct break_info {
         struct torture_context *tctx;
         struct smb2_handle handle;
@@ -103 +103 @@
         int failures;
         NTSTATUS failure_status;
-} break_info;
+};
+
+static struct break_info break_info;
+
+static void torture_reset_break_info(struct torture_context *tctx,
+                                     struct break_info *r)
+{
+        ZERO_STRUCTP(r);
+        r->tctx = tctx;
+}
 
 static void torture_oplock_ack_callback(struct smb2_request *req)
@@ -161 +170 @@
         req->async.private_data = NULL;
         return true;
+}
+
+/**
+ * Timer handler function notifies the registering function that time is up
+ */
+static void timeout_cb(struct tevent_context *ev,
+                       struct tevent_timer *te,
+                       struct timeval current_time,
+                       void *private_data)
+{
+        bool *timesup = (bool *)private_data;
+        *timesup = true;
+        return;
+}
+
+/**
+ *  Wait a short period of time to receive a single oplock break request
+ */
+static void torture_wait_for_oplock_break(struct torture_context *tctx)
+{
+        TALLOC_CTX *tmp_ctx = talloc_new(NULL);
+        struct tevent_timer *te = NULL;
+        struct timeval ne;
+        bool timesup = false;
+        int old_count = break_info.count;
+
+        /* Wait .1 seconds for an oplock break */
+        ne = tevent_timeval_current_ofs(0, 100000);
+
+        te = tevent_add_timer(tctx->ev, tmp_ctx, ne, timeout_cb, &timesup);
+        if (te == NULL) {
+                torture_comment(tctx, "Failed to wait for an oplock break. "
+                                      "test results may not be accurate.");
+                goto done;
+        }
+
+        while (!timesup && break_info.count < old_count + 1) {
+                if (tevent_loop_once(tctx->ev) != 0) {
+                        torture_comment(tctx, "Failed to wait for an oplock "
+                                              "break. test results may not be "
+                                              "accurate.");
+                        goto done;
+                }
+        }
+
+done:
+        /*
+         * We don't know if the timed event fired and was freed, we received
+         * our oplock break, or some other event triggered the loop.  Thus,
+         * we create a tmp_ctx to be able to safely free/remove the timed
+         * event in all 3 cases.
+         */
+        talloc_free(tmp_ctx);
+
+        return;
 }
 
@@ -1429 +1493 @@
 }
 
+static bool test_channel_sequence_table(struct torture_context *tctx,
+                                        struct smb2_tree *tree,
+                                        bool do_replay,
+                                        uint16_t opcode)
+{
+        NTSTATUS status;
+        TALLOC_CTX *mem_ctx = talloc_new(tctx);
+        struct smb2_handle handle;
+        struct smb2_handle *phandle = NULL;
+        struct smb2_create io;
+        struct GUID create_guid = GUID_random();
+        bool ret = true;
+        const char *fname = BASEDIR "\\channel_sequence.dat";
+        uint16_t csn = 0;
+        uint16_t limit = UINT16_MAX - 0x7fff;
+        int i;
+        struct {
+                uint16_t csn;
+                bool csn_rand_low;
+                bool csn_rand_high;
+                NTSTATUS expected_status;
+        } tests[] = {
+                {
+                        .csn                    = 0,
+                        .expected_status        = NT_STATUS_OK,
+                },{
+                        .csn                    = 0x7fff + 1,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = 0x7fff + 2,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = -1,
+                        .csn_rand_high          = true,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = 0xffff,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = 0x7fff,
+                        .expected_status        = NT_STATUS_OK,
+                },{
+                        .csn                    = 0x7ffe,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = 0,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = -1,
+                        .csn_rand_low           = true,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = 0x7fff + 1,
+                        .expected_status        = NT_STATUS_OK,
+                },{
+                        .csn                    = 0xffff,
+                        .expected_status        = NT_STATUS_OK,
+                },{
+                        .csn                    = 0,
+                        .expected_status        = NT_STATUS_OK,
+                },{
+                        .csn                    = 1,
+                        .expected_status        = NT_STATUS_OK,
+                },{
+                        .csn                    = 0,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                },{
+                        .csn                    = 1,
+                        .expected_status        = NT_STATUS_OK,
+                },{
+                        .csn                    = 0xffff,
+                        .expected_status        = NT_STATUS_FILE_NOT_AVAILABLE,
+                }
+        };
+
+        smb2cli_session_reset_channel_sequence(tree->session->smbXcli, 0);
+
+        csn = smb2cli_session_current_channel_sequence(tree->session->smbXcli);
+        torture_comment(tctx, "Testing create with channel sequence number: 0x%04x\n", csn);
+
+        smb2_oplock_create_share(&io, fname,
+                        smb2_util_share_access("RWD"),
+                        smb2_util_oplock_level("b"));
+        io.in.durable_open = false;
+        io.in.durable_open_v2 = true;
+        io.in.create_guid = create_guid;
+        io.in.timeout = UINT32_MAX;
+
+        torture_assert_ntstatus_ok_goto(tctx,
+                smb2_create(tree, mem_ctx, &io),
+                ret, done, "failed to call smb2_create");
+
+        handle = io.out.file.handle;
+        phandle = &handle;
+
+        for (i=0; i <ARRAY_SIZE(tests); i++) {
+
+                const char *opstr = "";
+                union smb_fileinfo qfinfo;
+
+                csn = tests[i].csn;
+
+                if (tests[i].csn_rand_low) {
+                        csn = rand() % limit;
+                } else if (tests[i].csn_rand_high) {
+                        csn = rand() % limit + 0x7fff;
+                }
+
+                switch (opcode) {
+                case SMB2_OP_WRITE:
+                        opstr = "write";
+                        break;
+                case SMB2_OP_IOCTL:
+                        opstr = "ioctl";
+                        break;
+                case SMB2_OP_SETINFO:
+                        opstr = "setinfo";
+                        break;
+                default:
+                        break;
+                }
+
+                smb2cli_session_reset_channel_sequence(tree->session->smbXcli, csn);
+                csn = smb2cli_session_current_channel_sequence(tree->session->smbXcli);
+
+                torture_comment(tctx, "Testing %s (replay: %s) with CSN 0x%04x, expecting: %s\n",
+                        opstr, do_replay ? "true" : "false", csn,
+                        nt_errstr(tests[i].expected_status));
+
+                if (do_replay) {
+                        smb2cli_session_start_replay(tree->session->smbXcli);
+                }
+
+                switch (opcode) {
+                case SMB2_OP_WRITE: {
+                        DATA_BLOB blob = data_blob_talloc(tctx, NULL, 255);
+
+                        generate_random_buffer(blob.data, blob.length);
+
+                        status = smb2_util_write(tree, handle, blob.data, 0, blob.length);
+                        if (NT_STATUS_IS_OK(status)) {
+                                struct smb2_read rd;
+
+                                rd = (struct smb2_read) {
+                                        .in.file.handle = handle,
+                                        .in.length = blob.length,
+                                        .in.offset = 0
+                                };
+
+                                torture_assert_ntstatus_ok_goto(tctx,
+                                        smb2_read(tree, tree, &rd),
+                                        ret, done, "failed to read after write");
+
+                                torture_assert_data_blob_equal(tctx,
+                                        rd.out.data, blob,
+                                        "read/write mismatch");
+                        }
+                        break;
+                }
+                case SMB2_OP_IOCTL: {
+                        union smb_ioctl ioctl;
+                        ioctl = (union smb_ioctl) {
+                                .smb2.level = RAW_IOCTL_SMB2,
+                                .smb2.in.file.handle = handle,
+                                .smb2.in.function = FSCTL_CREATE_OR_GET_OBJECT_ID,
+                                .smb2.in.max_response_size = 64,
+                                .smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL
+                        };
+                        status = smb2_ioctl(tree, mem_ctx, &ioctl.smb2);
+                        break;
+                }
+                case SMB2_OP_SETINFO: {
+                        union smb_setfileinfo sfinfo;
+                        ZERO_STRUCT(sfinfo);
+                        sfinfo.generic.level = RAW_SFILEINFO_POSITION_INFORMATION;
+                        sfinfo.generic.in.file.handle = handle;
+                        sfinfo.position_information.in.position = 0x1000;
+                        status = smb2_setinfo_file(tree, &sfinfo);
+                        break;
+                }
+                default:
+                        break;
+                }
+
+                qfinfo = (union smb_fileinfo) {
+                        .generic.level = RAW_SFILEINFO_POSITION_INFORMATION,
+                        .generic.in.file.handle = handle
+                };
+
+                torture_assert_ntstatus_ok_goto(tctx,
+                        smb2_getinfo_file(tree, mem_ctx, &qfinfo),
+                        ret, done, "failed to read after write");
+
+                if (do_replay) {
+                        smb2cli_session_stop_replay(tree->session->smbXcli);
+                }
+
+                torture_assert_ntstatus_equal_goto(tctx,
+                        status, tests[i].expected_status,
+                        ret, done, "got unexpected failure code");
+
+        }
+done:
+        if (phandle != NULL) {
+                smb2_util_close(tree, *phandle);
+        }
+
+        smb2_util_unlink(tree, fname);
+
+        return ret;
+}
+
+static bool test_channel_sequence(struct torture_context *tctx,
+                                  struct smb2_tree *tree)
+{
+        TALLOC_CTX *mem_ctx = talloc_new(tctx);
+        bool ret = true;
+        const char *fname = BASEDIR "\\channel_sequence.dat";
+        struct smb2_transport *transport1 = tree->session->transport;
+        struct smb2_handle handle;
+        uint32_t server_capabilities;
+        uint16_t opcodes[] = { SMB2_OP_WRITE, SMB2_OP_IOCTL, SMB2_OP_SETINFO };
+        int i;
+
+        if (smbXcli_conn_protocol(transport1->conn) < PROTOCOL_SMB3_00) {
+                torture_skip(tctx, "SMB 3.X Dialect family required for "
+                                   "Replay tests\n");
+        }
+
+        server_capabilities = smb2cli_conn_server_capabilities(
+                                        tree->session->transport->conn);
+        if (!(server_capabilities & SMB2_CAP_MULTI_CHANNEL)) {
+                torture_skip(tctx,
+                             "Server does not support multi-channel.");
+        }
+
+        torture_comment(tctx, "Testing channel sequence numbers\n");
+
+        torture_assert_ntstatus_ok_goto(tctx,
+                torture_smb2_testdir(tree, BASEDIR, &handle),
+                ret, done, "failed to setup test directory");
+
+        smb2_util_close(tree, handle);
+        smb2_util_unlink(tree, fname);
+
+        for (i=0; i <ARRAY_SIZE(opcodes); i++) {
+                torture_assert(tctx,
+                        test_channel_sequence_table(tctx, tree, false, opcodes[i]),
+                        "failed to test CSN without replay flag");
+                torture_assert(tctx,
+                        test_channel_sequence_table(tctx, tree, true, opcodes[i]),
+                        "failed to test CSN with replay flag");
+        }
+
+done:
+
+        smb2_util_unlink(tree, fname);
+        smb2_deltree(tree, BASEDIR);
+
+        talloc_free(tree);
+        talloc_free(mem_ctx);
+
+        return ret;
+}
+
 /**
  * Test Durablity V2 Create Replay Detection on Multi Channel
@@ -1957 +2286 @@
 }
 
+
+/**
+ * Test Error Codes when a DurableHandleReqV2 with matching CreateGuid is
+ * re-sent with or without SMB2_FLAGS_REPLAY_OPERATION
+ */
+static bool test_replay6(struct torture_context *tctx, struct smb2_tree *tree)
+{
+        NTSTATUS status;
+        TALLOC_CTX *mem_ctx = talloc_new(tctx);
+        struct smb2_handle _h;
+        struct smb2_handle *h = NULL;
+        struct smb2_create io, ref1;
+        union smb_fileinfo qfinfo;
+        struct GUID create_guid = GUID_random();
+        bool ret = true;
+        const char *fname = BASEDIR "\\replay6.dat";
+        struct smb2_transport *transport = tree->session->transport;
+
+        if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB3_00) {
+                torture_skip(tctx, "SMB 3.X Dialect family required for "
+                                   "replay tests\n");
+        }
+
+        torture_reset_break_info(tctx, &break_info);
+        tree->session->transport->oplock.handler = torture_oplock_ack_handler;
+        tree->session->transport->oplock.private_data = tree;
+
+        torture_comment(tctx, "Error Codes for DurableHandleReqV2 Replay\n");
+        smb2_util_unlink(tree, fname);
+        status = torture_smb2_testdir(tree, BASEDIR, &_h);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        smb2_util_close(tree, _h);
+        torture_wait_for_oplock_break(tctx);
+        CHECK_VAL(break_info.count, 0);
+        torture_reset_break_info(tctx, &break_info);
+
+        smb2_oplock_create_share(&io, fname,
+                        smb2_util_share_access("RWD"),
+                        smb2_util_oplock_level("b"));
+        io.in.durable_open = false;
+        io.in.durable_open_v2 = true;
+        io.in.persistent_open = false;
+        io.in.create_guid = create_guid;
+        io.in.timeout = UINT32_MAX;
+
+        status = smb2_create(tree, mem_ctx, &io);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        ref1 = io;
+        _h = io.out.file.handle;
+        h = &_h;
+        CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+        CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
+        CHECK_VAL(io.out.durable_open, false);
+        CHECK_VAL(io.out.durable_open_v2, true);
+
+        io.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
+        io.in.create_disposition = NTCREATEX_DISP_OPEN;
+        smb2cli_session_start_replay(tree->session->smbXcli);
+        status = smb2_create(tree, mem_ctx, &io);
+        smb2cli_session_stop_replay(tree->session->smbXcli);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_CREATE_OUT(&io, &ref1);
+        torture_wait_for_oplock_break(tctx);
+        CHECK_VAL(break_info.count, 0);
+        torture_reset_break_info(tctx, &break_info);
+
+        qfinfo = (union smb_fileinfo) {
+                .generic.level = RAW_SFILEINFO_POSITION_INFORMATION,
+                .generic.in.file.handle = *h
+        };
+        torture_comment(tctx, "Trying getinfo\n");
+        status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        CHECK_VAL(qfinfo.position_information.out.position, 0);
+
+        smb2cli_session_start_replay(tree->session->smbXcli);
+        status = smb2_create(tree, mem_ctx, &io);
+        smb2cli_session_stop_replay(tree->session->smbXcli);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        torture_assert_u64_not_equal_goto(tctx,
+                io.out.file.handle.data[0],
+                ref1.out.file.handle.data[0],
+                ret, done, "data 0");
+        torture_assert_u64_not_equal_goto(tctx,
+                io.out.file.handle.data[1],
+                ref1.out.file.handle.data[1],
+                ret, done, "data 1");
+        torture_wait_for_oplock_break(tctx);
+        CHECK_VAL(break_info.count, 1);
+        CHECK_VAL(break_info.level, smb2_util_oplock_level("s"));
+        torture_reset_break_info(tctx, &break_info);
+
+        /*
+         * Resend the matching Durable V2 Create without
+         * SMB2_FLAGS_REPLAY_OPERATION. This triggers an oplock break and still
+         * gets NT_STATUS_DUPLICATE_OBJECTID
+         */
+        status = smb2_create(tree, mem_ctx, &io);
+        CHECK_STATUS(status, NT_STATUS_DUPLICATE_OBJECTID);
+        torture_wait_for_oplock_break(tctx);
+        CHECK_VAL(break_info.count, 0);
+        torture_reset_break_info(tctx, &break_info);
+
+        /*
+         * According to MS-SMB2 3.3.5.9.10 if Durable V2 Create is replayed and
+         * FileAttributes or CreateDisposition do not match the earlier Create
+         * request the Server fails request with
+         * NT_STATUS_INVALID_PARAMETER. But through this test we see that server
+         * does not really care about changed FileAttributes or
+         * CreateDisposition.
+         */
+        io.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
+        io.in.create_disposition = NTCREATEX_DISP_OPEN;
+        smb2cli_session_start_replay(tree->session->smbXcli);
+        status = smb2_create(tree, mem_ctx, &io);
+        smb2cli_session_stop_replay(tree->session->smbXcli);
+        CHECK_STATUS(status, NT_STATUS_OK);
+        torture_assert_u64_not_equal_goto(tctx,
+                io.out.file.handle.data[0],
+                ref1.out.file.handle.data[0],
+                ret, done, "data 0");
+        torture_assert_u64_not_equal_goto(tctx,
+                io.out.file.handle.data[1],
+                ref1.out.file.handle.data[1],
+                ret, done, "data 1");
+        torture_wait_for_oplock_break(tctx);
+        CHECK_VAL(break_info.count, 0);
+
+done:
+        if (h != NULL) {
+                smb2_util_close(tree, *h);
+        }
+
+        smb2_util_unlink(tree, fname);
+        smb2_deltree(tree, BASEDIR);
+
+        talloc_free(tree);
+        talloc_free(mem_ctx);
+
+        return ret;
+}
+
 struct torture_suite *torture_smb2_replay_init(void)
 {
@@ -1972 +2443 @@
         torture_suite_add_1smb2_test(suite, "replay-dhv2-lease3",  test_replay_dhv2_lease3);
         torture_suite_add_1smb2_test(suite, "replay-dhv2-lease-oplock",  test_replay_dhv2_lease_oplock);
+        torture_suite_add_1smb2_test(suite, "channel-sequence", test_channel_sequence);
         torture_suite_add_1smb2_test(suite, "replay3", test_replay3);
         torture_suite_add_1smb2_test(suite, "replay4", test_replay4);
         torture_suite_add_1smb2_test(suite, "replay5", test_replay5);
+        torture_suite_add_1smb2_test(suite, "replay6", test_replay6);
 
         suite->description = talloc_strdup(suite, "SMB2 REPLAY tests");

vendor/current/source4/torture/smb2/smb2.c

@@ -171 +171 @@
         torture_suite_add_suite(suite, torture_smb2_session_init());
         torture_suite_add_suite(suite, torture_smb2_replay_init());
+        torture_suite_add_simple_test(suite, "dosmode", torture_smb2_dosmode);
 
         torture_suite_add_suite(suite, torture_smb2_doc_init());

vendor/current/source4/torture/smb2/util.c

@@ -262 +262 @@
 }
 
+/*
+  get granted access of a file handle
+*/
+NTSTATUS torture_smb2_get_allinfo_access(struct smb2_tree *tree,
+                                         struct smb2_handle handle,
+                                         uint32_t *granted_access)
+{
+        NTSTATUS status;
+        TALLOC_CTX *tmp_ctx = talloc_new(tree);
+        union smb_fileinfo io;
+
+        io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
+        io.generic.in.file.handle = handle;
+
+        status = smb2_getinfo_file(tree, tmp_ctx, &io);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("getinfo failed - %s\n", nt_errstr(status)));
+                goto out;
+        }
+
+        *granted_access = io.all_info2.out.access_mask;
+
+out:
+        talloc_free(tmp_ctx);
+        return status;
+}
+
 /**
  * open a smb2 tree connect
@@ -429 +456 @@
 }
 
-
 /*
   create and return a handle to a test file
-*/
-NTSTATUS torture_smb2_testfile(struct smb2_tree *tree, const char *fname, 
-                               struct smb2_handle *handle)
+  with a specific access mask
+*/
+NTSTATUS torture_smb2_testfile_access(struct smb2_tree *tree, const char *fname,
+                                      struct smb2_handle *handle,
+                                      uint32_t desired_access)
 {
         struct smb2_create io;
@@ -441 +469 @@
         ZERO_STRUCT(io);
         io.in.oplock_level = 0;
-        io.in.desired_access = SEC_RIGHTS_FILE_ALL;
+        io.in.desired_access = desired_access;
         io.in.file_attributes   = FILE_ATTRIBUTE_NORMAL;
         io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
@@ -460 +488 @@
 
 /*
+  create and return a handle to a test file
+*/
+NTSTATUS torture_smb2_testfile(struct smb2_tree *tree, const char *fname,
+                               struct smb2_handle *handle)
+{
+        return torture_smb2_testfile_access(tree, fname, handle,
+                                            SEC_RIGHTS_FILE_ALL);
+}
+
+/*
   create and return a handle to a test directory
-*/
-NTSTATUS torture_smb2_testdir(struct smb2_tree *tree, const char *fname, 
-                              struct smb2_handle *handle)
+  with specific desired access
+*/
+NTSTATUS torture_smb2_testdir_access(struct smb2_tree *tree, const char *fname,
+                                     struct smb2_handle *handle,
+                                     uint32_t desired_access)
 {
         struct smb2_create io;
@@ -470 +510 @@
         ZERO_STRUCT(io);
         io.in.oplock_level = 0;
-        io.in.desired_access = SEC_RIGHTS_DIR_ALL;
+        io.in.desired_access = desired_access;
         io.in.file_attributes   = FILE_ATTRIBUTE_DIRECTORY;
         io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
@@ -485 +525 @@
 }
 
+/*
+  create and return a handle to a test directory
+*/
+NTSTATUS torture_smb2_testdir(struct smb2_tree *tree, const char *fname,
+                              struct smb2_handle *handle)
+{
+        return torture_smb2_testdir_access(tree, fname, handle,
+                                           SEC_RIGHTS_DIR_ALL);
+}
 
 /*

vendor/current/source4/torture/smb2/wscript_build

@@ -5 +5 @@
         smb2.c durable_open.c durable_v2_open.c oplock.c dir.c lease.c create.c
         acls.c read.c compound.c streams.c ioctl.c rename.c
-        session.c delete-on-close.c replay.c notify_disabled.c''',
+        session.c delete-on-close.c replay.c notify_disabled.c dosmode.c''',
         subsystem='smbtorture',
         deps='LIBCLI_SMB2 POPT_CREDENTIALS torture NDR_IOCTL',

vendor/current/source4/torture/vfs/vfs.c

@@ -108 +108 @@
 
         torture_suite_add_suite(suite, torture_vfs_fruit());
+        torture_suite_add_suite(suite, torture_acl_xattr());
 
         torture_register_suite(suite);

vendor/current/source4/torture/wscript_build

@@ -270 +270 @@
 
 bld.SAMBA_MODULE('TORTURE_VFS',
-        source='vfs/vfs.c vfs/fruit.c',
+        source='vfs/vfs.c vfs/fruit.c vfs/acl_xattr.c',
         subsystem='smbtorture',
         deps='LIBCLI_SMB POPT_CREDENTIALS TORTURE_UTIL smbclient-raw TORTURE_RAW',