Changeset 988 for vendor/current/source4/rpc_server

vendor/current/source4/rpc_server/backupkey/dcesrv_backupkey.c

-              r740
+              r988
    Copyright (C) Matthieu Patou <mat@samba.org> 2010
+   Copyright (C) Andreas Schneider <asn@samba.org> 2015
    This program is free software; you can redistribute it and/or modify
 …
 #include "param/param.h"
 #include "auth/session.h"
+#include "heimdal/lib/hx509/hx_locl.h"
+#include "heimdal/lib/hcrypto/rsa.h"
+#include "heimdal/lib/hcrypto/bn.h"
+#include "system/network.h"
 #include "../lib/tsocket/tsocket.h"
 #include "../libcli/security/security.h"
+#define BACKUPKEY_MIN_VERSION 2
+#define BACKUPKEY_MAX_VERSION 3
+static const unsigned rsa_with_var_num[] = { 1, 2, 840, 113549, 1, 1, 1 };
+/* Equivalent to asn1_oid_id_pkcs1_rsaEncryption*/
+static const AlgorithmIdentifier _hx509_signature_rsa_with_var_num = {
+        { 7, discard_const_p(unsigned, rsa_with_var_num) }, NULL
+};
+#include "librpc/gen_ndr/ndr_security.h"
+#include "libds/common/roles.h"
+#include <gnutls/gnutls.h>
+#include <gnutls/x509.h>
+#include <gnutls/crypto.h>
+#include <gnutls/abstract.h>
+#define DCESRV_INTERFACE_BACKUPKEY_BIND(call, iface) \
+        dcesrv_interface_backupkey_bind(call, iface)
+static NTSTATUS dcesrv_interface_backupkey_bind(struct dcesrv_call_state *dce_call,
+                                                const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_require_privacy(dce_call, iface);
+}
 static NTSTATUS set_lsa_secret(TALLOC_CTX *mem_ctx,
                                struct ldb_context *ldb,
                                const char *name,
                                const DATA_BLOB *secret)
+                               const DATA_BLOB *lsa_secret)
+{
         struct ldb_message *msg;
 …
                 return NT_STATUS_NO_MEMORY;
+        }
         val.data = secret->data;
         val.length = secret->length;
+        val.data = lsa_secret->data;
+        val.length = lsa_secret->length;
         ret = ldb_msg_add_value(msg, "currentValue", &val, NULL);
         if (ret != LDB_SUCCESS) {
 …
                                struct ldb_context *ldb,
                                const char *name,
                                DATA_BLOB *secret)
+                               DATA_BLOB *lsa_secret)
+{
         TALLOC_CTX *tmp_mem;
 …
         int ret;
         secret->data = NULL;
         secret->length = 0;
+        lsa_secret->data = NULL;
+        lsa_secret->length = 0;
         domain_dn = ldb_get_default_basedn(ldb);
 …
                            ldb_binary_encode_string(tmp_mem, name));
         if (ret != LDB_SUCCESS || res->count == 0) {
+        if (ret != LDB_SUCCESS) {
                 talloc_free(tmp_mem);
+                /*
+                 * Important NOT to use NT_STATUS_OBJECT_NAME_NOT_FOUND
+                 * as this return value is used to detect the case
+                 * when we have the secret but without the currentValue
+                 * (case RODC)
+                 */
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
+        if (res->count == 0) {
+                talloc_free(tmp_mem);
                 return NT_STATUS_RESOURCE_NAME_NOT_FOUND;
+        }
         if (res->count > 1) {
                 DEBUG(2, ("Secret %s collision\n", name));
 …
                  * The most common case is a RODC
                  */
+                *lsa_secret = data_blob_null;
                 talloc_free(tmp_mem);
                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+                return NT_STATUS_OK;
+        }
         data = val->data;
         secret->data = talloc_move(mem_ctx, &data);
         secret->length = val->length;
+        lsa_secret->data = talloc_move(mem_ctx, &data);
+        lsa_secret->length = val->length;
         talloc_free(tmp_mem);
 …
+}
+static DATA_BLOB *reverse_and_get_blob(TALLOC_CTX *mem_ctx, BIGNUM *bn)
+static int reverse_and_get_bignum(TALLOC_CTX *mem_ctx,
+                                  DATA_BLOB blob,
+                                  gnutls_datum_t *datum)
+{
-        DATA_BLOB blob;
-        DATA_BLOB *rev = talloc(mem_ctx, DATA_BLOB);
         uint32_t i;
+        blob.length = BN_num_bytes(bn);
+        blob.data = talloc_array(mem_ctx, uint8_t, blob.length);
+        if (blob.data == NULL) {
+                return NULL;
+        }
+        BN_bn2bin(bn, blob.data);
+        rev->data = talloc_array(mem_ctx, uint8_t, blob.length);
+        if (rev->data == NULL) {
+                return NULL;
+        }
+        for(i=0; i < blob.length; i++) {
+                rev->data[i] = blob.data[blob.length - i -1];
+        }
+        rev->length = blob.length;
+        talloc_free(blob.data);
+        return rev;
+}
+static BIGNUM *reverse_and_get_bignum(TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
+{
+        BIGNUM *ret;
+        DATA_BLOB rev;
+        uint32_t i;
+        rev.data = talloc_array(mem_ctx, uint8_t, blob->length);
+        if (rev.data == NULL) {
+                return NULL;
+        }
+        for(i=0; i < blob->length; i++) {
+                rev.data[i] = blob->data[blob->length - i -1];
+        }
+        rev.length = blob->length;
+        ret = BN_bin2bn(rev.data, rev.length, NULL);
+        talloc_free(rev.data);
+        return ret;
+        datum->data = talloc_array(mem_ctx, uint8_t, blob.length);
+        if (datum->data == NULL) {
+                return -1;
+        }
+        for(i = 0; i < blob.length; i++) {
+                datum->data[i] = blob.data[blob.length - i - 1];
+        }
+        datum->size = blob.length;
+        return 0;
+}
 static NTSTATUS get_pk_from_raw_keypair_params(TALLOC_CTX *ctx,
                                 struct bkrp_exported_RSA_key_pair *keypair,
                                 hx509_private_key *pk)
+                                gnutls_privkey_t *pk)
+{
+        hx509_context hctx;
+        RSA *rsa;
+        struct hx509_private_key_ops *ops;
+        hx509_context_init(&hctx);
+        ops = hx509_find_private_alg(&_hx509_signature_rsa_with_var_num.algorithm);
+        if (ops == NULL) {
+                DEBUG(2, ("Not supported algorithm\n"));
+        gnutls_x509_privkey_t x509_privkey = NULL;
+        gnutls_privkey_t privkey = NULL;
+        gnutls_datum_t m, e, d, p, q, u, e1, e2;
+        int rc;
+        rc = reverse_and_get_bignum(ctx, keypair->modulus, &m);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = reverse_and_get_bignum(ctx, keypair->public_exponent, &e);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = reverse_and_get_bignum(ctx, keypair->private_exponent, &d);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = reverse_and_get_bignum(ctx, keypair->prime1, &p);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = reverse_and_get_bignum(ctx, keypair->prime2, &q);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = reverse_and_get_bignum(ctx, keypair->coefficient, &u);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = reverse_and_get_bignum(ctx, keypair->exponent1, &e1);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = reverse_and_get_bignum(ctx, keypair->exponent2, &e2);
+        if (rc != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rc = gnutls_x509_privkey_init(&x509_privkey);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_privkey_init failed - %s\n",
+                        gnutls_strerror(rc));
                 return NT_STATUS_INTERNAL_ERROR;
+        }
+        if (hx509_private_key_init(pk, ops, NULL) != 0) {
+                hx509_context_free(&hctx);
+                return NT_STATUS_NO_MEMORY;
+        }
+        rsa = RSA_new();
+        if (rsa ==NULL) {
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->n = reverse_and_get_bignum(ctx, &(keypair->modulus));
+        if (rsa->n == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->d = reverse_and_get_bignum(ctx, &(keypair->private_exponent));
+        if (rsa->d == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->p = reverse_and_get_bignum(ctx, &(keypair->prime1));
+        if (rsa->p == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->q = reverse_and_get_bignum(ctx, &(keypair->prime2));
+        if (rsa->q == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->dmp1 = reverse_and_get_bignum(ctx, &(keypair->exponent1));
+        if (rsa->dmp1 == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->dmq1 = reverse_and_get_bignum(ctx, &(keypair->exponent2));
+        if (rsa->dmq1 == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->iqmp = reverse_and_get_bignum(ctx, &(keypair->coefficient));
+        if (rsa->iqmp == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        rsa->e = reverse_and_get_bignum(ctx, &(keypair->public_exponent));
+        if (rsa->e == NULL) {
+                RSA_free(rsa);
+                hx509_context_free(&hctx);
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        hx509_private_key_assign_rsa(*pk, rsa);
+        hx509_context_free(&hctx);
+        rc = gnutls_x509_privkey_import_rsa_raw2(x509_privkey,
+                                                 &m,
+                                                 &e,
+                                                 &d,
+                                                 &p,
+                                                 &q,
+                                                 &u,
+                                                 &e1,
+                                                 &e2);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_privkey_import_rsa_raw2 failed - %s\n",
+                        gnutls_strerror(rc));
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        rc = gnutls_privkey_init(&privkey);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_privkey_init failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_privkey_deinit(x509_privkey);
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        rc = gnutls_privkey_import_x509(privkey,
+                                        x509_privkey,
+                                        GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_privkey_import_x509 failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_privkey_deinit(x509_privkey);
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        *pk = privkey;
         return NT_STATUS_OK;
+}
 …
                                           uint8_t *access_check,
                                           uint32_t access_check_len,
                                           struct dom_sid **access_sid)
+                                          struct auth_session_info *session_info)
+{
+        heim_octet_string iv;
+        heim_octet_string access_check_os;
+        hx509_crypto crypto;
+        gnutls_cipher_hd_t cipher_handle = { 0 };
+        gnutls_cipher_algorithm_t cipher_algo;
         DATA_BLOB blob_us;
-        uint32_t key_len;
-        uint32_t iv_len;
-        int res;
         enum ndr_err_code ndr_err;
+        hx509_context hctx;
+        /* This one should not be freed */
+        const AlgorithmIdentifier *alg;
+        *access_sid = NULL;
+        gnutls_datum_t key;
+        gnutls_datum_t iv;
+        struct dom_sid *access_sid = NULL;
+        struct dom_sid *caller_sid = NULL;
+        int rc;
         switch (version) {
         case 2:
+                key_len = 24;
+                iv_len = 8;
+                alg = hx509_crypto_des_rsdi_ede3_cbc();
+                cipher_algo = GNUTLS_CIPHER_3DES_CBC;
                 break;
         case 3:
+                key_len = 32;
+                iv_len = 16;
+                alg =hx509_crypto_aes256_cbc();
+                cipher_algo = GNUTLS_CIPHER_AES_256_CBC;
                 break;
         default:
                 return WERR_INVALID_DATA;
+        }
+        hx509_context_init(&hctx);
+        res = hx509_crypto_init(hctx, NULL,
+                                &(alg->algorithm),
+                                &crypto);
+        hx509_context_free(&hctx);
+        if (res != 0) {
+        key.data = key_and_iv;
+        key.size = gnutls_cipher_get_key_size(cipher_algo);
+        iv.data = key_and_iv + key.size;
+        iv.size = gnutls_cipher_get_iv_size(cipher_algo);
+        /* Allocate data structure for the plaintext */
+        blob_us = data_blob_talloc_zero(sub_ctx, access_check_len);
+        if (blob_us.data == NULL) {
                 return WERR_INVALID_DATA;
+        }
         res = hx509_crypto_set_key_data(crypto, key_and_iv, key_len);
         iv.data = talloc_memdup(sub_ctx, key_len + key_and_iv, iv_len);
         iv.length = iv_len;
         if (res != 0) {
                 hx509_crypto_destroy(crypto);
+        rc = gnutls_cipher_init(&cipher_handle,
+                                cipher_algo,
+                                &key,
+                                &iv);
+        if (rc < 0) {
+                DBG_ERR("gnutls_cipher_init failed: %s\n",
+                        gnutls_strerror(rc));
                 return WERR_INVALID_DATA;
+        }
         hx509_crypto_set_padding(crypto, HX509_CRYPTO_PADDING_NONE);
         res = hx509_crypto_decrypt(crypto,
                 access_check,
                 access_check_len,
                 &iv,
                 &access_check_os);
         if (res != 0) {
                 hx509_crypto_destroy(crypto);
+        rc = gnutls_cipher_decrypt2(cipher_handle,
+                                    access_check,
+                                    access_check_len,
+                                    blob_us.data,
+                                    blob_us.length);
+        gnutls_cipher_deinit(cipher_handle);
+        if (rc < 0) {
+                DBG_ERR("gnutls_cipher_decrypt2 failed: %s\n",
+                        gnutls_strerror(rc));
                 return WERR_INVALID_DATA;
+        }
+        blob_us.data = access_check_os.data;
+        blob_us.length = access_check_os.length;
+        hx509_crypto_destroy(crypto);
+        if (version == 2) {
+        switch (version) {
+        case 2:
+        {
                 uint32_t hash_size = 20;
                 uint8_t hash[hash_size];
                 struct sha sctx;
+                gnutls_hash_hd_t dig_ctx;
                 struct bkrp_access_check_v2 uncrypted_accesscheckv2;
 …
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         /* Unable to unmarshall */
-                        der_free_octet_string(&access_check_os);
                         return WERR_INVALID_DATA;
+                }
                 if (uncrypted_accesscheckv2.magic != 0x1) {
                         /* wrong magic */
-                        der_free_octet_string(&access_check_os);
                         return WERR_INVALID_DATA;
+                }
+                SHA1_Init(&sctx);
+                SHA1_Update(&sctx, blob_us.data, blob_us.length - hash_size);
+                SHA1_Final(hash, &sctx);
+                der_free_octet_string(&access_check_os);
+                gnutls_hash_init(&dig_ctx, GNUTLS_DIG_SHA1);
+                gnutls_hash(dig_ctx,
+                            blob_us.data,
+                            blob_us.length - hash_size);
+                gnutls_hash_deinit(dig_ctx, hash);
                 /*
                  * We free it after the sha1 calculation because blob.data
 …
                         return WERR_INVALID_DATA;
+                }
+                *access_sid = dom_sid_dup(sub_ctx, &(uncrypted_accesscheckv2.sid));
+                if (*access_sid == NULL) {
+                        return WERR_NOMEM;
+                }
+                return WERR_OK;
+        }
+        if (version == 3) {
+                access_sid = &(uncrypted_accesscheckv2.sid);
+                break;
+        }
+        case 3:
+        {
                 uint32_t hash_size = 64;
                 uint8_t hash[hash_size];
                 struct hc_sha512state sctx;
+                gnutls_hash_hd_t dig_ctx;
                 struct bkrp_access_check_v3 uncrypted_accesscheckv3;
 …
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         /* Unable to unmarshall */
-                        der_free_octet_string(&access_check_os);
                         return WERR_INVALID_DATA;
+                }
                 if (uncrypted_accesscheckv3.magic != 0x1) {
                         /* wrong magic */
-                        der_free_octet_string(&access_check_os);
                         return WERR_INVALID_DATA;
+                }
+                SHA512_Init(&sctx);
+                SHA512_Update(&sctx, blob_us.data, blob_us.length - hash_size);
+                SHA512_Final(hash, &sctx);
+                der_free_octet_string(&access_check_os);
+                gnutls_hash_init(&dig_ctx, GNUTLS_DIG_SHA512);
+                gnutls_hash(dig_ctx,
+                            blob_us.data,
+                            blob_us.length - hash_size);
+                gnutls_hash_deinit(dig_ctx, hash);
                 /*
                  * We free it after the sha1 calculation because blob.data
 …
                         return WERR_INVALID_DATA;
+                }
+                *access_sid = dom_sid_dup(sub_ctx, &(uncrypted_accesscheckv3.sid));
+                if (*access_sid == NULL) {
+                        return WERR_NOMEM;
+                }
+                return WERR_OK;
+        }
+        /* Never reached normally as we filtered at the switch / case level */
+        return WERR_INVALID_DATA;
+                access_sid = &(uncrypted_accesscheckv3.sid);
+                break;
+        }
+        default:
+                /* Never reached normally as we filtered at the switch / case level */
+                return WERR_INVALID_DATA;
+        }
+        caller_sid = &session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
+        if (!dom_sid_equal(caller_sid, access_sid)) {
+                return WERR_INVALID_ACCESS;
+        }
+        return WERR_OK;
+}
+static WERROR bkrp_do_uncrypt_client_wrap_key(struct dcesrv_call_state *dce_call,
+                                              TALLOC_CTX *mem_ctx,
+                                              struct bkrp_BackupKey *r,
+                                              struct ldb_context *ldb_ctx)
+/*
+ * We have some data, such as saved website or IMAP passwords that the
+ * client has in profile on-disk.  This needs to be decrypted.  This
+ * version gives the server the data over the network (protected by
+ * the X.509 certificate and public key encryption, and asks that it
+ * be decrypted returned for short-term use, protected only by the
+ * negotiated transport encryption.
+ *
+ * The data is NOT stored in the LSA, but a X.509 certificate, public
+ * and private keys used to encrypt the data will be stored.  There is
+ * only one active encryption key pair and certificate per domain, it
+ * is pointed at with G$BCKUPKEY_PREFERRED in the LSA secrets store.
+ *
+ * The potentially multiple valid decrypting key pairs are in turn
+ * stored in the LSA secrets store as G$BCKUPKEY_keyGuidString.
+ *
+ */
+static WERROR bkrp_client_wrap_decrypt_data(struct dcesrv_call_state *dce_call,
+                                            TALLOC_CTX *mem_ctx,
+                                            struct bkrp_BackupKey *r,
+                                            struct ldb_context *ldb_ctx)
+{
         struct bkrp_client_side_wrapped uncrypt_request;
 …
         char *guid_string;
         char *cert_secret_name;
         DATA_BLOB secret;
         DATA_BLOB *uncrypted;
+        DATA_BLOB lsa_secret;
+        DATA_BLOB *uncrypted_data = NULL;
         NTSTATUS status;
+        uint32_t requested_version;
         blob.data = r->in.data_in;
         blob.length = r->in.data_in_len;
+        if (r->in.data_in_len == 0 || r->in.data_in == NULL) {
+                return WERR_INVALID_PARAM;
+        if (r->in.data_in_len < 4 || r->in.data_in == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        /*
+         * We check for the version here, so we can actually print the
+         * message as we are unlikely to parse it with NDR.
+         */
+        requested_version = IVAL(r->in.data_in, 0);
+        if ((requested_version != BACKUPKEY_CLIENT_WRAP_VERSION2)
+            && (requested_version != BACKUPKEY_CLIENT_WRAP_VERSION3)) {
+                DEBUG(1, ("Request for unknown BackupKey sub-protocol %d\n", requested_version));
+                return WERR_INVALID_PARAMETER;
+        }
 …
+        }
+        if (uncrypt_request.version < BACKUPKEY_MIN_VERSION) {
+                return WERR_INVALID_PARAMETER;
+        }
+        if (uncrypt_request.version > BACKUPKEY_MAX_VERSION) {
+        if ((uncrypt_request.version != BACKUPKEY_CLIENT_WRAP_VERSION2)
+            && (uncrypt_request.version != BACKUPKEY_CLIENT_WRAP_VERSION3)) {
+                DEBUG(1, ("Request for unknown BackupKey sub-protocol %d\n", uncrypt_request.version));
                 return WERR_INVALID_PARAMETER;
+        }
 …
                                 ldb_ctx,
                                 cert_secret_name,
                                 &secret);
+                                &lsa_secret);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(10, ("Error while fetching secret %s\n", cert_secret_name));
+                if (NT_STATUS_EQUAL(status,NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                        /* we do not have the real secret attribute */
+                        return WERR_INVALID_PARAMETER;
+                } else {
+                        return WERR_FILE_NOT_FOUND;
+                }
+        }
+        if (secret.length != 0) {
+                hx509_context hctx;
+                return WERR_INVALID_DATA;
+        } else if (lsa_secret.length == 0) {
+                /* we do not have the real secret attribute, like if we are an RODC */
+                return WERR_INVALID_PARAMETER;
+        } else {
                 struct bkrp_exported_RSA_key_pair keypair;
+                hx509_private_key pk;
+                uint32_t i, res;
+                struct dom_sid *access_sid = NULL;
+                heim_octet_string reversed_secret;
+                heim_octet_string uncrypted_secret;
+                AlgorithmIdentifier alg;
+                struct dom_sid *caller_sid;
+                gnutls_privkey_t privkey = NULL;
+                gnutls_datum_t reversed_secret;
+                gnutls_datum_t uncrypted_secret;
+                uint32_t i;
                 DATA_BLOB blob_us;
                 WERROR werr;
+                ndr_err = ndr_pull_struct_blob(&secret, mem_ctx, &keypair, (ndr_pull_flags_fn_t)ndr_pull_bkrp_exported_RSA_key_pair);
+                int rc;
+                ndr_err = ndr_pull_struct_blob(&lsa_secret, mem_ctx, &keypair, (ndr_pull_flags_fn_t)ndr_pull_bkrp_exported_RSA_key_pair);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         DEBUG(2, ("Unable to parse the ndr encoded cert in key %s\n", cert_secret_name));
 …
+                }
+                status = get_pk_from_raw_keypair_params(mem_ctx, &keypair, &pk);
+                status = get_pk_from_raw_keypair_params(mem_ctx,
+                                                        &keypair,
+                                                        &privkey);
                 if (!NT_STATUS_IS_OK(status)) {
                         return WERR_INTERNAL_ERROR;
 …
                                                     uncrypt_request.encrypted_secret_len);
                 if (reversed_secret.data == NULL) {
                         hx509_private_key_free(&pk);
+                        gnutls_privkey_deinit(privkey);
                         return WERR_NOMEM;
+                }
 …
                         reversed[i] = uncrypt[uncrypt_request.encrypted_secret_len - 1 - i];
+                }
                 reversed_secret.length = uncrypt_request.encrypted_secret_len;
+                reversed_secret.size = uncrypt_request.encrypted_secret_len;
                 /*
 …
                  * we have the private key ...
                  */
+                hx509_context_init(&hctx);
+                res = hx509_private_key_private_decrypt(hctx, &reversed_secret,
+                                                         &alg.algorithm, pk,
+                                                         &uncrypted_secret);
+                hx509_context_free(&hctx);
+                hx509_private_key_free(&pk);
+                if (res != 0) {
+                rc = gnutls_privkey_decrypt_data(privkey,
+,
+                                                 &reversed_secret,
+                                                 &uncrypted_secret);
+                gnutls_privkey_deinit(privkey);
+                if (rc != GNUTLS_E_SUCCESS) {
                         /* We are not able to decrypt the secret, looks like something is wrong */
                         return WERR_INVALID_DATA;
+                        return WERR_INVALID_PARAMETER;
+                }
                 blob_us.data = uncrypted_secret.data;
                 blob_us.length = uncrypted_secret.length;
+                blob_us.length = uncrypted_secret.size;
                 if (uncrypt_request.version == 2) {
 …
                         ndr_err = ndr_pull_struct_blob(&blob_us, mem_ctx, &uncrypted_secretv2,
                                         (ndr_pull_flags_fn_t)ndr_pull_bkrp_encrypted_secret_v2);
                         der_free_octet_string(&uncrypted_secret);
+                        gnutls_free(uncrypted_secret.data);
                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                                 /* Unable to unmarshall */
 …
                                                            uncrypt_request.access_check,
                                                            uncrypt_request.access_check_len,
                                                            &access_sid);
+                                                           dce_call->conn->auth_state.session_info);
                         if (!W_ERROR_IS_OK(werr)) {
                                 return werr;
+                        }
                         uncrypted = talloc(mem_ctx, DATA_BLOB);
                         if (uncrypted == NULL) {
+                        uncrypted_data = talloc(mem_ctx, DATA_BLOB);
+                        if (uncrypted_data == NULL) {
                                 return WERR_INVALID_DATA;
+                        }
                         uncrypted->data = uncrypted_secretv2.secret;
                         uncrypted->length = uncrypted_secretv2.secret_len;
+                        uncrypted_data->data = uncrypted_secretv2.secret;
+                        uncrypted_data->length = uncrypted_secretv2.secret_len;
+                }
                 if (uncrypt_request.version == 3) {
 …
                         ndr_err = ndr_pull_struct_blob(&blob_us, mem_ctx, &uncrypted_secretv3,
                                         (ndr_pull_flags_fn_t)ndr_pull_bkrp_encrypted_secret_v3);
+                        der_free_octet_string(&uncrypted_secret);
+                        gnutls_free(uncrypted_secret.data);
                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                                 /* Unable to unmarshall */
 …
+                        }
+                        /*
+                         * Confirm that the caller is permitted to
+                         * read this particular data.  Because one key
+                         * pair is used per domain, the caller could
+                         * have stolen the profile data on-disk and
+                         * would otherwise be able to read the
+                         * passwords.
+                         */
                         werr = get_and_verify_access_check(mem_ctx, 3,
                                                            uncrypted_secretv3.payload_key,
                                                            uncrypt_request.access_check,
                                                            uncrypt_request.access_check_len,
                                                            &access_sid);
+                                                           dce_call->conn->auth_state.session_info);
                         if (!W_ERROR_IS_OK(werr)) {
                                 return werr;
+                        }
                         uncrypted = talloc(mem_ctx, DATA_BLOB);
                         if (uncrypted == NULL) {
+                        uncrypted_data = talloc(mem_ctx, DATA_BLOB);
+                        if (uncrypted_data == NULL) {
                                 return WERR_INVALID_DATA;
+                        }
+                        uncrypted->data = uncrypted_secretv3.secret;
+                        uncrypted->length = uncrypted_secretv3.secret_len;
+                }
+                caller_sid = &dce_call->conn->auth_state.session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
+                if (!dom_sid_equal(caller_sid, access_sid)) {
+                        talloc_free(uncrypted);
+                        return WERR_INVALID_ACCESS;
+                        uncrypted_data->data = uncrypted_secretv3.secret;
+                        uncrypted_data->length = uncrypted_secretv3.secret_len;
+                }
 …
+        }
         if (uncrypted->data == NULL) {
+        if (uncrypted_data->data == NULL) {
                 return WERR_INVALID_DATA;
+        }
 …
          * work just prepending 4 bytes
          */
         *(r->out.data_out) = talloc_zero_array(mem_ctx, uint8_t, uncrypted->length + 4);
+        *(r->out.data_out) = talloc_zero_array(mem_ctx, uint8_t, uncrypted_data->length + 4);
         W_ERROR_HAVE_NO_MEMORY(*(r->out.data_out));
         memcpy(4+*(r->out.data_out), uncrypted->data, uncrypted->length);
         *(r->out.data_out_len) = uncrypted->length + 4;
+        memcpy(4+*(r->out.data_out), uncrypted_data->data, uncrypted_data->length);
+        *(r->out.data_out_len) = uncrypted_data->length + 4;
         return WERR_OK;
+}
 static WERROR create_heimdal_rsa_key(TALLOC_CTX *ctx, hx509_context *hctx,
                                      hx509_private_key *pk, RSA **_rsa)
+static DATA_BLOB *reverse_and_get_blob(TALLOC_CTX *mem_ctx,
+                                       gnutls_datum_t *datum)
+{
+        BIGNUM *pub_expo;
+        RSA *rsa;
+        int ret;
+        uint8_t *p0, *p;
+        size_t len;
+        DATA_BLOB *blob;
+        size_t i;
+        blob = talloc(mem_ctx, DATA_BLOB);
+        if (blob == NULL) {
+                return NULL;
+        }
+        blob->length = datum->size;
+        if (datum->data[0] == '\0') {
+                /* The datum has a leading byte zero, skip it */
+                blob->length = datum->size - 1;
+        }
+        blob->data = talloc_zero_array(mem_ctx, uint8_t, blob->length);
+        if (blob->data == NULL) {
+                talloc_free(blob);
+                return NULL;
+        }
+        for (i = 0; i < blob->length; i++) {
+                blob->data[i] = datum->data[datum->size - i - 1];
+        }
+        return blob;
+}
+static WERROR create_privkey_rsa(gnutls_privkey_t *pk)
+{
         int bits = 2048;
+        *_rsa = NULL;
+        pub_expo = BN_new();
+        if(pub_expo == NULL) {
+        gnutls_x509_privkey_t x509_privkey = NULL;
+        gnutls_privkey_t privkey = NULL;
+        int rc;
+        rc = gnutls_x509_privkey_init(&x509_privkey);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_privkey_init failed - %s\n",
+                        gnutls_strerror(rc));
                 return WERR_INTERNAL_ERROR;
+        }
+        /* set the public expo to 65537 like everyone */
+        BN_set_word(pub_expo, 0x10001);
+        rsa = RSA_new();
+        if(rsa == NULL) {
+                BN_free(pub_expo);
+        rc = gnutls_x509_privkey_generate(x509_privkey,
+                                          GNUTLS_PK_RSA,
+                                          bits,
+);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_privkey_generate failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_privkey_deinit(x509_privkey);
                 return WERR_INTERNAL_ERROR;
+        }
+        ret = RSA_generate_key_ex(rsa, bits, pub_expo, NULL);
+        if(ret != 1) {
+                RSA_free(rsa);
+                BN_free(pub_expo);
+        rc = gnutls_privkey_init(&privkey);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_privkey_init failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_privkey_deinit(x509_privkey);
                 return WERR_INTERNAL_ERROR;
+        }
+        BN_free(pub_expo);
+        len = i2d_RSAPrivateKey(rsa, NULL);
+        if (len < 1) {
+                RSA_free(rsa);
+        rc = gnutls_privkey_import_x509(privkey,
+                                        x509_privkey,
+                                        GNUTLS_PRIVKEY_IMPORT_AUTO_RELEASE);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_privkey_import_x509 failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_privkey_deinit(x509_privkey);
                 return WERR_INTERNAL_ERROR;
+        }
+        p0 = p = talloc_array(ctx, uint8_t, len);
+        if (p == NULL) {
+                RSA_free(rsa);
+                return WERR_INTERNAL_ERROR;
+        }
+        len = i2d_RSAPrivateKey(rsa, &p);
+        if (len < 1) {
+                RSA_free(rsa);
+                talloc_free(p0);
+                return WERR_INTERNAL_ERROR;
+        }
+        /*
+         * To dump the key we can use :
+         * rk_dumpdata("h5lkey", p0, len);
+         */
+        ret = hx509_parse_private_key(*hctx, &_hx509_signature_rsa_with_var_num ,
+                                       p0, len, HX509_KEY_FORMAT_DER, pk);
+        memset(p0, 0, len);
+        talloc_free(p0);
+        if (ret !=0) {
+                RSA_free(rsa);
+                return WERR_INTERNAL_ERROR;
+        }
+        *_rsa = rsa;
+        *pk = privkey;
         return WERR_OK;
+}
+static WERROR self_sign_cert(TALLOC_CTX *ctx, hx509_context *hctx, hx509_request *req,
+                                time_t lifetime, hx509_private_key *private_key,
+                                hx509_cert *cert, DATA_BLOB *guidblob)
+static WERROR self_sign_cert(TALLOC_CTX *mem_ctx,
+                             time_t lifetime,
+                             const char *dn,
+                             gnutls_privkey_t issuer_privkey,
+                             gnutls_x509_crt_t *certificate,
+                             DATA_BLOB *guidblob)
+{
+        SubjectPublicKeyInfo spki;
+        hx509_name subject = NULL;
+        hx509_ca_tbs tbs;
+        struct heim_bit_string uniqueid;
+        int ret;
+        uniqueid.data = talloc_memdup(ctx, guidblob->data, guidblob->length);
+        /* uniqueid is a bit string in which each byte represent 1 bit (1 or 0)
+         * so as 1 byte is 8 bits we need to provision 8 times more space as in the
+         * blob
+         */
+        uniqueid.length = 8 * guidblob->length;
+        memset(&spki, 0, sizeof(spki));
+        ret = hx509_request_get_name(*hctx, *req, &subject);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_request_get_SubjectPublicKeyInfo(*hctx, *req, &spki);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_ca_tbs_init(*hctx, &tbs);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                free_SubjectPublicKeyInfo(&spki);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_ca_tbs_set_spki(*hctx, tbs, &spki);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                free_SubjectPublicKeyInfo(&spki);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_ca_tbs_set_subject(*hctx, tbs, subject);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                free_SubjectPublicKeyInfo(&spki);
+                hx509_ca_tbs_free(&tbs);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_ca_tbs_set_ca(*hctx, tbs, 1);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                free_SubjectPublicKeyInfo(&spki);
+                hx509_ca_tbs_free(&tbs);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_ca_tbs_set_notAfter_lifetime(*hctx, tbs, lifetime);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                free_SubjectPublicKeyInfo(&spki);
+                hx509_ca_tbs_free(&tbs);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_ca_tbs_set_unique(*hctx, tbs, &uniqueid, &uniqueid);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                free_SubjectPublicKeyInfo(&spki);
+                hx509_ca_tbs_free(&tbs);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_ca_sign_self(*hctx, tbs, *private_key, cert);
+        if (ret !=0) {
+                talloc_free(uniqueid.data);
+                hx509_name_free(&subject);
+                free_SubjectPublicKeyInfo(&spki);
+                hx509_ca_tbs_free(&tbs);
+                return WERR_INTERNAL_ERROR;
+        }
+        hx509_name_free(&subject);
+        free_SubjectPublicKeyInfo(&spki);
+        hx509_ca_tbs_free(&tbs);
+        gnutls_datum_t unique_id;
+        gnutls_datum_t serial_number;
+        gnutls_x509_crt_t issuer_cert;
+        gnutls_x509_privkey_t x509_issuer_privkey;
+        time_t activation = time(NULL);
+        time_t expiry = activation + lifetime;
+        const char *error_string;
+        uint8_t *reversed;
+        size_t i;
+        int rc;
+        unique_id.size = guidblob->length;
+        unique_id.data = talloc_memdup(mem_ctx,
+                                       guidblob->data,
+                                       guidblob->length);
+        if (unique_id.data == NULL) {
+                return WERR_NOMEM;
+        }
+        reversed = talloc_array(mem_ctx, uint8_t, guidblob->length);
+        if (reversed == NULL) {
+                talloc_free(unique_id.data);
+                return WERR_NOMEM;
+        }
+        /* Native AD generates certificates with serialnumber in reversed notation */
+        for (i = 0; i < guidblob->length; i++) {
+                uint8_t *uncrypt = guidblob->data;
+                reversed[i] = uncrypt[guidblob->length - i - 1];
+        }
+        serial_number.size = guidblob->length;
+        serial_number.data = reversed;
+        /* Create certificate to sign */
+        rc = gnutls_x509_crt_init(&issuer_cert);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_init failed - %s\n",
+                        gnutls_strerror(rc));
+                return WERR_NOMEM;
+        }
+        rc = gnutls_x509_crt_set_dn(issuer_cert, dn, &error_string);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_dn failed - %s (%s)\n",
+                        gnutls_strerror(rc),
+                        error_string);
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_set_issuer_dn(issuer_cert, dn, &error_string);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_issuer_dn failed - %s (%s)\n",
+                        gnutls_strerror(rc),
+                        error_string);
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        /* Get x509 privkey for subjectPublicKeyInfo */
+        rc = gnutls_x509_privkey_init(&x509_issuer_privkey);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_privkey_init failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_privkey_export_x509(issuer_privkey,
+                                        &x509_issuer_privkey);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_privkey_init failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_privkey_deinit(x509_issuer_privkey);
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        /* Set subjectPublicKeyInfo */
+        rc = gnutls_x509_crt_set_key(issuer_cert, x509_issuer_privkey);
+        gnutls_x509_privkey_deinit(x509_issuer_privkey);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_pubkey failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_set_activation_time(issuer_cert, activation);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_activation_time failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_set_expiration_time(issuer_cert, expiry);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_expiration_time failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_set_version(issuer_cert, 3);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_version failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_set_subject_unique_id(issuer_cert,
+                                                   unique_id.data,
+                                                   unique_id.size);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_subject_key_id failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_set_issuer_unique_id(issuer_cert,
+                                                  unique_id.data,
+                                                  unique_id.size);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_issuer_unique_id failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_set_serial(issuer_cert,
+                                        serial_number.data,
+                                        serial_number.size);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_set_serial failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_x509_crt_deinit(issuer_cert);
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_x509_crt_privkey_sign(issuer_cert,
+                                          issuer_cert,
+                                          issuer_privkey,
+                                          GNUTLS_DIG_SHA1,
+);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_privkey_sign failed - %s\n",
+                        gnutls_strerror(rc));
+                return WERR_INVALID_PARAM;
+        }
+        *certificate = issuer_cert;
         return WERR_OK;
+}
+static WERROR create_req(TALLOC_CTX *ctx, hx509_context *hctx, hx509_request *req,
+                         hx509_private_key *signer,RSA **rsa, const char *dn)
+/* Return an error when we fail to generate a certificate */
+static WERROR generate_bkrp_cert(TALLOC_CTX *mem_ctx,
+                                 struct dcesrv_call_state *dce_call,
+                                 struct ldb_context *ldb_ctx,
+                                 const char *dn)
+{
+        int ret;
+        SubjectPublicKeyInfo key;
+        hx509_name name;
+        WERROR w_err;
+        w_err = create_heimdal_rsa_key(ctx, hctx, signer, rsa);
+        if (!W_ERROR_IS_OK(w_err)) {
+                return w_err;
+        }
+        hx509_request_init(*hctx, req);
+        ret = hx509_parse_name(*hctx, dn, &name);
+        if (ret != 0) {
+                RSA_free(*rsa);
+                hx509_private_key_free(signer);
+                hx509_request_free(req);
+                hx509_name_free(&name);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_request_set_name(*hctx, *req, name);
+        if (ret != 0) {
+                RSA_free(*rsa);
+                hx509_private_key_free(signer);
+                hx509_request_free(req);
+                hx509_name_free(&name);
+                return WERR_INTERNAL_ERROR;
+        }
+        hx509_name_free(&name);
+        ret = hx509_private_key2SPKI(*hctx, *signer, &key);
+        if (ret != 0) {
+                RSA_free(*rsa);
+                hx509_private_key_free(signer);
+                hx509_request_free(req);
+                return WERR_INTERNAL_ERROR;
+        }
+        ret = hx509_request_set_SubjectPublicKeyInfo(*hctx, *req, &key);
+        if (ret != 0) {
+                RSA_free(*rsa);
+                hx509_private_key_free(signer);
+                free_SubjectPublicKeyInfo(&key);
+                hx509_request_free(req);
+                return WERR_INTERNAL_ERROR;
+        }
+        free_SubjectPublicKeyInfo(&key);
+        return WERR_OK;
+}
+/* Return an error when we fail to generate a certificate */
+static WERROR generate_bkrp_cert(TALLOC_CTX *ctx, struct dcesrv_call_state *dce_call, struct ldb_context *ldb_ctx, const char *dn)
+{
+        struct heim_octet_string data;
+        WERROR w_err;
+        RSA *rsa;
+        hx509_context hctx;
+        hx509_private_key pk;
+        hx509_request req;
+        hx509_cert cert;
+        WERROR werr;
+        gnutls_privkey_t issuer_privkey = NULL;
+        gnutls_x509_crt_t cert = NULL;
+        gnutls_datum_t cert_blob;
+        gnutls_datum_t m, e, d, p, q, u, e1, e2;
         DATA_BLOB blob;
         DATA_BLOB blobkeypair;
         DATA_BLOB *tmp;
-        int ret;
         bool ok = true;
         struct GUID guid = GUID_random();
 …
         struct bkrp_exported_RSA_key_pair keypair;
         enum ndr_err_code ndr_err;
+        uint32_t nb_days_validity = 365;
+        time_t nb_seconds_validity = 3600 * 24 * 365;
+        int rc;
         DEBUG(6, ("Trying to generate a certificate\n"));
+        hx509_context_init(&hctx);
+        w_err = create_req(ctx, &hctx, &req, &pk, &rsa, dn);
+        if (!W_ERROR_IS_OK(w_err)) {
+                hx509_context_free(&hctx);
+                return w_err;
+        }
+        status = GUID_to_ndr_blob(&guid, ctx, &blob);
+        werr = create_privkey_rsa(&issuer_privkey);
+        if (!W_ERROR_IS_OK(werr)) {
+                return werr;
+        }
+        status = GUID_to_ndr_blob(&guid, mem_ctx, &blob);
         if (!NT_STATUS_IS_OK(status)) {
+                hx509_context_free(&hctx);
+                hx509_private_key_free(&pk);
+                RSA_free(rsa);
+                gnutls_privkey_deinit(issuer_privkey);
                 return WERR_INVALID_DATA;
+        }
+        w_err = self_sign_cert(ctx, &hctx, &req, nb_days_validity, &pk, &cert, &blob);
+        if (!W_ERROR_IS_OK(w_err)) {
+                hx509_private_key_free(&pk);
+                hx509_context_free(&hctx);
+        werr = self_sign_cert(mem_ctx,
+                              nb_seconds_validity,
+                              dn,
+                              issuer_privkey,
+                              &cert,
+                              &blob);
+        if (!W_ERROR_IS_OK(werr)) {
+                gnutls_privkey_deinit(issuer_privkey);
                 return WERR_INVALID_DATA;
+        }
+        ret = hx509_cert_binary(hctx, cert, &data);
+        if (ret !=0) {
+                hx509_cert_free(cert);
+                hx509_private_key_free(&pk);
+                hx509_context_free(&hctx);
+        rc = gnutls_x509_crt_export2(cert, GNUTLS_X509_FMT_DER, &cert_blob);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_x509_crt_export2 failed - %s\n",
+                        gnutls_strerror(rc));
+                gnutls_privkey_deinit(issuer_privkey);
+                gnutls_x509_crt_deinit(cert);
                 return WERR_INVALID_DATA;
+        }
+        keypair.cert.data = talloc_memdup(ctx, data.data, data.length);
+        keypair.cert.length = data.length;
+        keypair.cert.length = cert_blob.size;
+        keypair.cert.data = talloc_memdup(mem_ctx, cert_blob.data, cert_blob.size);
+        gnutls_x509_crt_deinit(cert);
+        gnutls_free(cert_blob.data);
+        if (keypair.cert.data == NULL) {
+                gnutls_privkey_deinit(issuer_privkey);
+                return WERR_NOMEM;
+        }
+        rc = gnutls_privkey_export_rsa_raw(issuer_privkey,
+                                           &m,
+                                           &e,
+                                           &d,
+                                           &p,
+                                           &q,
+                                           &u,
+                                           &e1,
+                                           &e2);
+        if (rc != GNUTLS_E_SUCCESS) {
+                gnutls_privkey_deinit(issuer_privkey);
+                return WERR_INVALID_DATA;
+        }
         /*
 …
          * so we reverse the buffer to make it work
          */
         tmp = reverse_and_get_blob(ctx, rsa->e);
+        tmp = reverse_and_get_blob(mem_ctx, &e);
         if (tmp == NULL) {
                 ok = false;
         } else {
+                SMB_ASSERT(tmp->length <= 4);
                 keypair.public_exponent = *tmp;
+                SMB_ASSERT(tmp->length <= 4);
+                /*
+                 * The value is now in little endian but if can happen that the length is
+                 * less than 4 bytes.
+                 * So if we have less than 4 bytes we pad with zeros so that it correctly
+                 * fit into the structure.
+                 */
+                if (tmp->length < 4) {
+                        /*
+                         * We need the expo to fit 4 bytes
+                         */
+                        keypair.public_exponent.data = talloc_zero_array(ctx, uint8_t, 4);
+                        memcpy(keypair.public_exponent.data, tmp->data, tmp->length);
+                        keypair.public_exponent.length = 4;
+                }
+        }
+        tmp = reverse_and_get_blob(ctx,rsa->d);
+        }
+        tmp = reverse_and_get_blob(mem_ctx, &d);
         if (tmp == NULL) {
                 ok = false;
 …
+        }
         tmp = reverse_and_get_blob(ctx,rsa->n);
+        tmp = reverse_and_get_blob(mem_ctx, &m);
         if (tmp == NULL) {
                 ok = false;
 …
+        }
         tmp = reverse_and_get_blob(ctx,rsa->p);
+        tmp = reverse_and_get_blob(mem_ctx, &p);
         if (tmp == NULL) {
                 ok = false;
 …
+        }
         tmp = reverse_and_get_blob(ctx,rsa->q);
+        tmp = reverse_and_get_blob(mem_ctx, &q);
         if (tmp == NULL) {
                 ok = false;
 …
+        }
         tmp = reverse_and_get_blob(ctx,rsa->dmp1);
+        tmp = reverse_and_get_blob(mem_ctx, &e1);
         if (tmp == NULL) {
                 ok = false;
 …
+        }
         tmp = reverse_and_get_blob(ctx,rsa->dmq1);
+        tmp = reverse_and_get_blob(mem_ctx, &e2);
         if (tmp == NULL) {
                 ok = false;
 …
+        }
         tmp = reverse_and_get_blob(ctx,rsa->iqmp);
+        tmp = reverse_and_get_blob(mem_ctx, &u);
         if (tmp == NULL) {
                 ok = false;
 …
         /* One of the keypair allocation was wrong */
         if (ok == false) {
+                der_free_octet_string(&data);
+                hx509_cert_free(cert);
+                hx509_private_key_free(&pk);
+                hx509_context_free(&hctx);
+                RSA_free(rsa);
+                gnutls_privkey_deinit(issuer_privkey);
                 return WERR_INVALID_DATA;
+        }
         keypair.certificate_len = keypair.cert.length;
+        ndr_err = ndr_push_struct_blob(&blobkeypair, ctx, &keypair, (ndr_push_flags_fn_t)ndr_push_bkrp_exported_RSA_key_pair);
+        ndr_err = ndr_push_struct_blob(&blobkeypair,
+                                       mem_ctx,
+                                       &keypair,
+                                       (ndr_push_flags_fn_t)ndr_push_bkrp_exported_RSA_key_pair);
+        gnutls_privkey_deinit(issuer_privkey);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                der_free_octet_string(&data);
-                hx509_cert_free(cert);
-                hx509_private_key_free(&pk);
-                hx509_context_free(&hctx);
-                RSA_free(rsa);
                 return WERR_INVALID_DATA;
+        }
         secret_name = talloc_asprintf(ctx, "BCKUPKEY_%s", GUID_string(ctx, &guid));
+        secret_name = talloc_asprintf(mem_ctx, "BCKUPKEY_%s", GUID_string(mem_ctx, &guid));
         if (secret_name == NULL) {
-                der_free_octet_string(&data);
-                hx509_cert_free(cert);
-                hx509_private_key_free(&pk);
-                hx509_context_free(&hctx);
-                RSA_free(rsa);
                 return WERR_OUTOFMEMORY;
+        }
         status = set_lsa_secret(ctx, ldb_ctx, secret_name, &blobkeypair);
+        status = set_lsa_secret(mem_ctx, ldb_ctx, secret_name, &blobkeypair);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(2, ("Failed to save the secret %s\n", secret_name));
 …
         talloc_free(secret_name);
         GUID_to_ndr_blob(&guid, ctx, &blob);
         status = set_lsa_secret(ctx, ldb_ctx, "BCKUPKEY_PREFERRED", &blob);
+        GUID_to_ndr_blob(&guid, mem_ctx, &blob);
+        status = set_lsa_secret(mem_ctx, ldb_ctx, "BCKUPKEY_PREFERRED", &blob);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(2, ("Failed to save the secret BCKUPKEY_PREFERRED\n"));
+        }
-        der_free_octet_string(&data);
-        hx509_cert_free(cert);
-        hx509_private_key_free(&pk);
-        hx509_context_free(&hctx);
-        RSA_free(rsa);
         return WERR_OK;
+}
 static WERROR bkrp_do_retreive_client_wrap_key(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                 struct bkrp_BackupKey *r ,struct ldb_context *ldb_ctx)
+static WERROR bkrp_retrieve_client_wrap_key(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                                            struct bkrp_BackupKey *r, struct ldb_context *ldb_ctx)
+{
         struct GUID guid;
         char *guid_string;
         DATA_BLOB secret;
+        DATA_BLOB lsa_secret;
         enum ndr_err_code ndr_err;
         NTSTATUS status;
 …
                                 ldb_ctx,
                                 "BCKUPKEY_PREFERRED",
+                                &secret);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(10, ("Error while fetching secret BCKUPKEY_PREFERRED\n"));
+                if (!NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                        /* Ok we can be in this case if there was no certs */
+                        struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+                        char *dn = talloc_asprintf(mem_ctx, "CN=%s.%s",
+                                                        lpcfg_netbios_name(lp_ctx),
+                                                        lpcfg_realm(lp_ctx));
+                        WERROR werr =  generate_bkrp_cert(mem_ctx, dce_call, ldb_ctx, dn);
+                        if (!W_ERROR_IS_OK(werr)) {
+                                return WERR_INVALID_PARAMETER;
+                        }
+                        status = get_lsa_secret(mem_ctx,
+                                &lsa_secret);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_RESOURCE_NAME_NOT_FOUND)) {
+                /* Ok we can be in this case if there was no certs */
+                struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+                char *dn = talloc_asprintf(mem_ctx, "CN=%s",
+                                           lpcfg_realm(lp_ctx));
+                WERROR werr =  generate_bkrp_cert(mem_ctx, dce_call, ldb_ctx, dn);
+                if (!W_ERROR_IS_OK(werr)) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                status = get_lsa_secret(mem_ctx,
                                         ldb_ctx,
                                         "BCKUPKEY_PREFERRED",
+                                        &secret);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                /* Ok we really don't manage to get this certs ...*/
+                                DEBUG(2, ("Unable to locate BCKUPKEY_PREFERRED after cert generation\n"));
+                                return WERR_FILE_NOT_FOUND;
+                        }
+                } else {
+                        /* In theory we should NEVER reach this point as it
+                           should only appear in a rodc server */
+                        /* we do not have the real secret attribute */
+                        return WERR_INVALID_PARAMETER;
+                }
+        }
+        if (secret.length != 0) {
+                                        &lsa_secret);
+                if (!NT_STATUS_IS_OK(status)) {
+                        /* Ok we really don't manage to get this certs ...*/
+                        DEBUG(2, ("Unable to locate BCKUPKEY_PREFERRED after cert generation\n"));
+                        return WERR_FILE_NOT_FOUND;
+                }
+        } else if (!NT_STATUS_IS_OK(status)) {
+                return WERR_INTERNAL_ERROR;
+        }
+        if (lsa_secret.length == 0) {
+                DEBUG(1, ("No secret in BCKUPKEY_PREFERRED, are we an undetected RODC?\n"));
+                return WERR_INTERNAL_ERROR;
+        } else {
                 char *cert_secret_name;
                 status = GUID_from_ndr_blob(&secret, &guid);
+                status = GUID_from_ndr_blob(&lsa_secret, &guid);
                 if (!NT_STATUS_IS_OK(status)) {
                         return WERR_FILE_NOT_FOUND;
 …
                         return WERR_FILE_NOT_FOUND;
+                }
                 cert_secret_name = talloc_asprintf(mem_ctx,
                                                         "BCKUPKEY_%s",
 …
                                         ldb_ctx,
                                         cert_secret_name,
                                         &secret);
+                                        &lsa_secret);
                 if (!NT_STATUS_IS_OK(status)) {
                         return WERR_FILE_NOT_FOUND;
+                }
                 if (secret.length != 0) {
+                if (lsa_secret.length != 0) {
                         struct bkrp_exported_RSA_key_pair keypair;
                         ndr_err = ndr_pull_struct_blob(&secret, mem_ctx, &keypair,
+                        ndr_err = ndr_pull_struct_blob(&lsa_secret, mem_ctx, &keypair,
                                         (ndr_pull_flags_fn_t)ndr_pull_bkrp_exported_RSA_key_pair);
                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 …
                         return WERR_OK;
                 } else {
+                        DEBUG(10, ("No or broken secret called %s\n", cert_secret_name));
+                        return WERR_FILE_NOT_FOUND;
+                }
+        } else {
+                DEBUG(10, ("No secret BCKUPKEY_PREFERRED\n"));
+                        DEBUG(1, ("No or broken secret called %s\n", cert_secret_name));
+                        return WERR_INTERNAL_ERROR;
+                }
+        }
+        return WERR_NOT_SUPPORTED;
+}
+static WERROR generate_bkrp_server_wrap_key(TALLOC_CTX *ctx, struct ldb_context *ldb_ctx)
+{
+        struct GUID guid = GUID_random();
+        enum ndr_err_code ndr_err;
+        DATA_BLOB blob_wrap_key, guid_blob;
+        struct bkrp_dc_serverwrap_key wrap_key;
+        NTSTATUS status;
+        char *secret_name;
+        TALLOC_CTX *frame = talloc_stackframe();
+        generate_random_buffer(wrap_key.key, sizeof(wrap_key.key));
+        ndr_err = ndr_push_struct_blob(&blob_wrap_key, ctx, &wrap_key, (ndr_push_flags_fn_t)ndr_push_bkrp_dc_serverwrap_key);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                TALLOC_FREE(frame);
+                return WERR_INVALID_DATA;
+        }
+        secret_name = talloc_asprintf(frame, "BCKUPKEY_%s", GUID_string(ctx, &guid));
+        if (secret_name == NULL) {
+                TALLOC_FREE(frame);
+                return WERR_NOMEM;
+        }
+        status = set_lsa_secret(frame, ldb_ctx, secret_name, &blob_wrap_key);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(2, ("Failed to save the secret %s\n", secret_name));
+                TALLOC_FREE(frame);
+                return WERR_INTERNAL_ERROR;
+        }
+        status = GUID_to_ndr_blob(&guid, frame, &guid_blob);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(2, ("Failed to save the secret %s\n", secret_name));
+                TALLOC_FREE(frame);
+        }
+        status = set_lsa_secret(frame, ldb_ctx, "BCKUPKEY_P", &guid_blob);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(2, ("Failed to save the secret %s\n", secret_name));
+                TALLOC_FREE(frame);
+                return WERR_INTERNAL_ERROR;
+        }
+        TALLOC_FREE(frame);
+        return WERR_OK;
+}
+/*
+ * Find the specified decryption keys from the LSA secrets store as
+ * G$BCKUPKEY_keyGuidString.
+ */
+static WERROR bkrp_do_retrieve_server_wrap_key(TALLOC_CTX *mem_ctx, struct ldb_context *ldb_ctx,
+                                               struct bkrp_dc_serverwrap_key *server_key,
+                                               struct GUID *guid)
+{
+        NTSTATUS status;
+        DATA_BLOB lsa_secret;
+        char *secret_name;
+        char *guid_string;
+        enum ndr_err_code ndr_err;
+        guid_string = GUID_string(mem_ctx, guid);
+        if (guid_string == NULL) {
+                /* We return file not found because the client
+                 * expect this error
+                 */
                 return WERR_FILE_NOT_FOUND;
+        }
+        return WERR_NOT_SUPPORTED;
+        secret_name = talloc_asprintf(mem_ctx, "BCKUPKEY_%s", guid_string);
+        if (secret_name == NULL) {
+                return WERR_NOMEM;
+        }
+        status = get_lsa_secret(mem_ctx, ldb_ctx, secret_name, &lsa_secret);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(10, ("Error while fetching secret %s\n", secret_name));
+                return WERR_INVALID_DATA;
+        }
+        if (lsa_secret.length == 0) {
+                /* RODC case, we do not have secrets locally */
+                DEBUG(1, ("Unable to fetch value for secret %s, are we an undetected RODC?\n",
+                          secret_name));
+                return WERR_INTERNAL_ERROR;
+        }
+        ndr_err = ndr_pull_struct_blob(&lsa_secret, mem_ctx, server_key,
+                                       (ndr_pull_flags_fn_t)ndr_pull_bkrp_dc_serverwrap_key);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                DEBUG(2, ("Unable to parse the ndr encoded server wrap key %s\n", secret_name));
+                return WERR_INVALID_DATA;
+        }
+        return WERR_OK;
+}
+/*
+ * Find the current, preferred ServerWrap Key by looking at
+ * G$BCKUPKEY_P in the LSA secrets store.
+ *
+ * Then find the current decryption keys from the LSA secrets store as
+ * G$BCKUPKEY_keyGuidString.
+ */
+static WERROR bkrp_do_retrieve_default_server_wrap_key(TALLOC_CTX *mem_ctx,
+                                                       struct ldb_context *ldb_ctx,
+                                                       struct bkrp_dc_serverwrap_key *server_key,
+                                                       struct GUID *returned_guid)
+{
+        NTSTATUS status;
+        DATA_BLOB guid_binary;
+        status = get_lsa_secret(mem_ctx, ldb_ctx, "BCKUPKEY_P", &guid_binary);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(10, ("Error while fetching secret BCKUPKEY_P to find current GUID\n"));
+                return WERR_FILE_NOT_FOUND;
+        } else if (guid_binary.length == 0) {
+                /* RODC case, we do not have secrets locally */
+                DEBUG(1, ("Unable to fetch value for secret BCKUPKEY_P, are we an undetected RODC?\n"));
+                return WERR_INTERNAL_ERROR;
+        }
+        status = GUID_from_ndr_blob(&guid_binary, returned_guid);
+        if (!NT_STATUS_IS_OK(status)) {
+                return WERR_FILE_NOT_FOUND;
+        }
+        return bkrp_do_retrieve_server_wrap_key(mem_ctx, ldb_ctx,
+                                                server_key, returned_guid);
+}
+static WERROR bkrp_server_wrap_decrypt_data(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                                            struct bkrp_BackupKey *r ,struct ldb_context *ldb_ctx)
+{
+        WERROR werr;
+        struct bkrp_server_side_wrapped decrypt_request;
+        DATA_BLOB sid_blob, encrypted_blob;
+        DATA_BLOB blob;
+        enum ndr_err_code ndr_err;
+        struct bkrp_dc_serverwrap_key server_key;
+        struct bkrp_rc4encryptedpayload rc4payload;
+        struct dom_sid *caller_sid;
+        uint8_t symkey[20]; /* SHA-1 hash len */
+        uint8_t mackey[20]; /* SHA-1 hash len */
+        uint8_t mac[20]; /* SHA-1 hash len */
+        gnutls_hmac_hd_t hmac_hnd;
+        gnutls_cipher_hd_t cipher_hnd;
+        gnutls_datum_t cipher_key;
+        int rc;
+        blob.data = r->in.data_in;
+        blob.length = r->in.data_in_len;
+        if (r->in.data_in_len == 0 || r->in.data_in == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        ndr_err = ndr_pull_struct_blob_all(&blob, mem_ctx, &decrypt_request,
+                                           (ndr_pull_flags_fn_t)ndr_pull_bkrp_server_side_wrapped);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return WERR_INVALID_PARAM;
+        }
+        if (decrypt_request.magic != BACKUPKEY_SERVER_WRAP_VERSION) {
+                return WERR_INVALID_PARAM;
+        }
+        werr = bkrp_do_retrieve_server_wrap_key(mem_ctx, ldb_ctx, &server_key,
+                                                &decrypt_request.guid);
+        if (!W_ERROR_IS_OK(werr)) {
+                return werr;
+        }
+        dump_data_pw("server_key: \n", server_key.key, sizeof(server_key.key));
+        dump_data_pw("r2: \n", decrypt_request.r2, sizeof(decrypt_request.r2));
+        /*
+         * This is *not* the leading 64 bytes, as indicated in MS-BKRP 3.1.4.1.1
+         * BACKUPKEY_BACKUP_GUID, it really is the whole key
+         */
+        gnutls_hmac_init(&hmac_hnd,
+                         GNUTLS_MAC_SHA1,
+                         server_key.key,
+                         sizeof(server_key.key));
+        gnutls_hmac(hmac_hnd,
+                    decrypt_request.r2,
+                    sizeof(decrypt_request.r2));
+        gnutls_hmac_output(hmac_hnd, symkey);
+        dump_data_pw("symkey: \n", symkey, sizeof(symkey));
+        /* rc4 decrypt sid and secret using sym key */
+        cipher_key.data = symkey;
+        cipher_key.size = sizeof(symkey);
+        encrypted_blob = data_blob_const(decrypt_request.rc4encryptedpayload,
+                                         decrypt_request.ciphertext_length);
+        rc = gnutls_cipher_init(&cipher_hnd,
+                                GNUTLS_CIPHER_ARCFOUR_128,
+                                &cipher_key,
+                                NULL);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_cipher_init failed - %s\n",
+                        gnutls_strerror(rc));
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_cipher_encrypt2(cipher_hnd,
+                                    encrypted_blob.data,
+                                    encrypted_blob.length,
+                                    encrypted_blob.data,
+                                    encrypted_blob.length);
+        gnutls_cipher_deinit(cipher_hnd);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_cipher_encrypt2 failed - %s\n",
+                        gnutls_strerror(rc));
+                return WERR_INVALID_PARAM;
+        }
+        ndr_err = ndr_pull_struct_blob_all(&encrypted_blob, mem_ctx, &rc4payload,
+                                           (ndr_pull_flags_fn_t)ndr_pull_bkrp_rc4encryptedpayload);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return WERR_INVALID_PARAM;
+        }
+        if (decrypt_request.payload_length != rc4payload.secret_data.length) {
+                return WERR_INVALID_PARAM;
+        }
+        dump_data_pw("r3: \n", rc4payload.r3, sizeof(rc4payload.r3));
+        /*
+         * This is *not* the leading 64 bytes, as indicated in MS-BKRP 3.1.4.1.1
+         * BACKUPKEY_BACKUP_GUID, it really is the whole key
+         */
+        gnutls_hmac(hmac_hnd,
+                    rc4payload.r3,
+                    sizeof(rc4payload.r3));
+        gnutls_hmac_deinit(hmac_hnd, mackey);
+        dump_data_pw("mackey: \n", mackey, sizeof(mackey));
+        ndr_err = ndr_push_struct_blob(&sid_blob, mem_ctx, &rc4payload.sid,
+                                       (ndr_push_flags_fn_t)ndr_push_dom_sid);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return WERR_INTERNAL_ERROR;
+        }
+        gnutls_hmac_init(&hmac_hnd,
+                         GNUTLS_MAC_SHA1,
+                         mackey,
+                         sizeof(mackey));
+        /* SID field */
+        gnutls_hmac(hmac_hnd,
+                    sid_blob.data,
+                    sid_blob.length);
+        /* Secret field */
+        gnutls_hmac(hmac_hnd,
+                    rc4payload.secret_data.data,
+                    rc4payload.secret_data.length);
+        gnutls_hmac_deinit(hmac_hnd, mac);
+        dump_data_pw("mac: \n", mac, sizeof(mac));
+        dump_data_pw("rc4payload.mac: \n", rc4payload.mac, sizeof(rc4payload.mac));
+        if (memcmp(mac, rc4payload.mac, sizeof(mac)) != 0) {
+                return WERR_INVALID_ACCESS;
+        }
+        caller_sid = &dce_call->conn->auth_state.session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
+        if (!dom_sid_equal(&rc4payload.sid, caller_sid)) {
+                return WERR_INVALID_ACCESS;
+        }
+        *(r->out.data_out) = rc4payload.secret_data.data;
+        *(r->out.data_out_len) = rc4payload.secret_data.length;
+        return WERR_OK;
+}
+/*
+ * For BACKUPKEY_RESTORE_GUID we need to check the first 4 bytes to
+ * determine what type of restore is wanted.
+ *
+ * See MS-BKRP 3.1.4.1.4 BACKUPKEY_RESTORE_GUID point 1.
+ */
+static WERROR bkrp_generic_decrypt_data(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                                        struct bkrp_BackupKey *r, struct ldb_context *ldb_ctx)
+{
+        if (r->in.data_in_len < 4 || r->in.data_in == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        if (IVAL(r->in.data_in, 0) == BACKUPKEY_SERVER_WRAP_VERSION) {
+                return bkrp_server_wrap_decrypt_data(dce_call, mem_ctx, r, ldb_ctx);
+        }
+        return bkrp_client_wrap_decrypt_data(dce_call, mem_ctx, r, ldb_ctx);
+}
+/*
+ * We have some data, such as saved website or IMAP passwords that the
+ * client would like to put into the profile on-disk.  This needs to
+ * be encrypted.  This version gives the server the data over the
+ * network (protected only by the negotiated transport encryption),
+ * and asks that it be encrypted and returned for long-term storage.
+ *
+ * The data is NOT stored in the LSA, but a key to encrypt the data
+ * will be stored.  There is only one active encryption key per domain,
+ * it is pointed at with G$BCKUPKEY_P in the LSA secrets store.
+ *
+ * The potentially multiple valid decryptiong keys (and the encryption
+ * key) are in turn stored in the LSA secrets store as
+ * G$BCKUPKEY_keyGuidString.
+ *
+ */
+static WERROR bkrp_server_wrap_encrypt_data(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                                            struct bkrp_BackupKey *r ,struct ldb_context *ldb_ctx)
+{
+        DATA_BLOB sid_blob, encrypted_blob, server_wrapped_blob;
+        WERROR werr;
+        struct dom_sid *caller_sid;
+        uint8_t symkey[20]; /* SHA-1 hash len */
+        uint8_t mackey[20]; /* SHA-1 hash len */
+        struct bkrp_rc4encryptedpayload rc4payload;
+        gnutls_hmac_hd_t hmac_hnd;
+        struct bkrp_dc_serverwrap_key server_key;
+        enum ndr_err_code ndr_err;
+        struct bkrp_server_side_wrapped server_side_wrapped;
+        struct GUID guid;
+        gnutls_cipher_hd_t cipher_hnd;
+        gnutls_datum_t cipher_key;
+        int rc;
+        if (r->in.data_in_len == 0 || r->in.data_in == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        werr = bkrp_do_retrieve_default_server_wrap_key(mem_ctx,
+                                                        ldb_ctx, &server_key,
+                                                        &guid);
+        if (!W_ERROR_IS_OK(werr)) {
+                if (W_ERROR_EQUAL(werr, WERR_FILE_NOT_FOUND)) {
+                        /* Generate the server wrap key since one wasn't found */
+                        werr =  generate_bkrp_server_wrap_key(mem_ctx,
+                                                              ldb_ctx);
+                        if (!W_ERROR_IS_OK(werr)) {
+                                return WERR_INVALID_PARAMETER;
+                        }
+                        werr = bkrp_do_retrieve_default_server_wrap_key(mem_ctx,
+                                                                        ldb_ctx,
+                                                                        &server_key,
+                                                                        &guid);
+                        if (W_ERROR_EQUAL(werr, WERR_FILE_NOT_FOUND)) {
+                                /* Ok we really don't manage to get this secret ...*/
+                                return WERR_FILE_NOT_FOUND;
+                        }
+                } else {
+                        /* In theory we should NEVER reach this point as it
+                           should only appear in a rodc server */
+                        /* we do not have the real secret attribute */
+                        return WERR_INVALID_PARAMETER;
+                }
+        }
+        caller_sid = &dce_call->conn->auth_state.session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
+        dump_data_pw("server_key: \n", server_key.key, sizeof(server_key.key));
+        /*
+         * This is the key derivation step, so that the HMAC and RC4
+         * operations over the user-supplied data are not able to
+         * disclose the master key.  By using random data, the symkey
+         * and mackey values are unique for this operation, and
+         * discovering these (by reversing the RC4 over the
+         * attacker-controlled data) does not return something able to
+         * be used to decyrpt the encrypted data of other users
+         */
+        generate_random_buffer(server_side_wrapped.r2, sizeof(server_side_wrapped.r2));
+        dump_data_pw("r2: \n", server_side_wrapped.r2, sizeof(server_side_wrapped.r2));
+        generate_random_buffer(rc4payload.r3, sizeof(rc4payload.r3));
+        dump_data_pw("r3: \n", rc4payload.r3, sizeof(rc4payload.r3));
+        /*
+         * This is *not* the leading 64 bytes, as indicated in MS-BKRP 3.1.4.1.1
+         * BACKUPKEY_BACKUP_GUID, it really is the whole key
+         */
+        gnutls_hmac_init(&hmac_hnd,
+                         GNUTLS_MAC_SHA1,
+                         server_key.key,
+                         sizeof(server_key.key));
+        gnutls_hmac(hmac_hnd,
+                    server_side_wrapped.r2,
+                    sizeof(server_side_wrapped.r2));
+        gnutls_hmac_output(hmac_hnd, symkey);
+        dump_data_pw("symkey: \n", symkey, sizeof(symkey));
+        /*
+         * This is *not* the leading 64 bytes, as indicated in MS-BKRP 3.1.4.1.1
+         * BACKUPKEY_BACKUP_GUID, it really is the whole key
+         */
+        gnutls_hmac(hmac_hnd,
+                    rc4payload.r3,
+                    sizeof(rc4payload.r3));
+        gnutls_hmac_deinit(hmac_hnd, mackey);
+        dump_data_pw("mackey: \n", mackey, sizeof(mackey));
+        ndr_err = ndr_push_struct_blob(&sid_blob, mem_ctx, caller_sid,
+                                       (ndr_push_flags_fn_t)ndr_push_dom_sid);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return WERR_INTERNAL_ERROR;
+        }
+        rc4payload.secret_data.data = r->in.data_in;
+        rc4payload.secret_data.length = r->in.data_in_len;
+        gnutls_hmac_init(&hmac_hnd,
+                         GNUTLS_MAC_SHA1,
+                         mackey,
+                         sizeof(mackey));
+        /* SID field */
+        gnutls_hmac(hmac_hnd,
+                    sid_blob.data,
+                    sid_blob.length);
+        /* Secret field */
+        gnutls_hmac(hmac_hnd,
+                    rc4payload.secret_data.data,
+                    rc4payload.secret_data.length);
+        gnutls_hmac_deinit(hmac_hnd, rc4payload.mac);
+        dump_data_pw("rc4payload.mac: \n", rc4payload.mac, sizeof(rc4payload.mac));
+        rc4payload.sid = *caller_sid;
+        ndr_err = ndr_push_struct_blob(&encrypted_blob, mem_ctx, &rc4payload,
+                                       (ndr_push_flags_fn_t)ndr_push_bkrp_rc4encryptedpayload);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return WERR_INTERNAL_ERROR;
+        }
+        /* rc4 encrypt sid and secret using sym key */
+        cipher_key.data = symkey;
+        cipher_key.size = sizeof(symkey);
+        rc = gnutls_cipher_init(&cipher_hnd,
+                                GNUTLS_CIPHER_ARCFOUR_128,
+                                &cipher_key,
+                                NULL);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_cipher_init failed - %s\n",
+                        gnutls_strerror(rc));
+                return WERR_INVALID_PARAM;
+        }
+        rc = gnutls_cipher_encrypt2(cipher_hnd,
+                                    encrypted_blob.data,
+                                    encrypted_blob.length,
+                                    encrypted_blob.data,
+                                    encrypted_blob.length);
+        gnutls_cipher_deinit(cipher_hnd);
+        if (rc != GNUTLS_E_SUCCESS) {
+                DBG_ERR("gnutls_cipher_encrypt2 failed - %s\n",
+                        gnutls_strerror(rc));
+                return WERR_INVALID_PARAM;
+        }
+        /* create server wrap structure */
+        server_side_wrapped.payload_length = rc4payload.secret_data.length;
+        server_side_wrapped.ciphertext_length = encrypted_blob.length;
+        server_side_wrapped.guid = guid;
+        server_side_wrapped.rc4encryptedpayload = encrypted_blob.data;
+        ndr_err = ndr_push_struct_blob(&server_wrapped_blob, mem_ctx, &server_side_wrapped,
+                                       (ndr_push_flags_fn_t)ndr_push_bkrp_server_side_wrapped);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return WERR_INTERNAL_ERROR;
+        }
+        *(r->out.data_out) = server_wrapped_blob.data;
+        *(r->out.data_out_len) = server_wrapped_blob.length;
+        return WERR_OK;
+}
 …
         const int debuglevel = 4;
+        gnutls_global_init();
         if (DEBUGLVL(debuglevel)) {
                 const struct tsocket_address *remote_address;
 …
+        }
         if (lpcfg_server_role(dce_call->conn->dce_ctx->lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
+        if (lpcfg_server_role(dce_call->conn->dce_ctx->lp_ctx) != ROLE_ACTIVE_DIRECTORY_DC) {
                 return WERR_NOT_SUPPORTED;
+        }
-        if (!dce_call->conn->auth_state.auth_info ||
-                dce_call->conn->auth_state.auth_info->auth_level != DCERPC_AUTH_LEVEL_PRIVACY) {
-                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
 …
                 if(strncasecmp(GUID_string(mem_ctx, r->in.guidActionAgent),
                         BACKUPKEY_RESTORE_GUID, strlen(BACKUPKEY_RESTORE_GUID)) == 0) {
                         DEBUG(debuglevel, ("Client %s requested to decrypt a client side wrapped secret\n", addr));
                         error = bkrp_do_uncrypt_client_wrap_key(dce_call, mem_ctx, r, ldb_ctx);
+                        DEBUG(debuglevel, ("Client %s requested to decrypt a wrapped secret\n", addr));
+                        error = bkrp_generic_decrypt_data(dce_call, mem_ctx, r, ldb_ctx);
+                }
 …
                         BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID, strlen(BACKUPKEY_RETRIEVE_BACKUP_KEY_GUID)) == 0) {
                         DEBUG(debuglevel, ("Client %s requested certificate for client wrapped secret\n", addr));
+                        error = bkrp_do_retreive_client_wrap_key(dce_call, mem_ctx, r, ldb_ctx);
+                        error = bkrp_retrieve_client_wrap_key(dce_call, mem_ctx, r, ldb_ctx);
+                }
+                if (strncasecmp(GUID_string(mem_ctx, r->in.guidActionAgent),
+                        BACKUPKEY_RESTORE_GUID_WIN2K, strlen(BACKUPKEY_RESTORE_GUID_WIN2K)) == 0) {
+                        DEBUG(debuglevel, ("Client %s requested to decrypt a server side wrapped secret\n", addr));
+                        error = bkrp_server_wrap_decrypt_data(dce_call, mem_ctx, r, ldb_ctx);
+                }
+                if (strncasecmp(GUID_string(mem_ctx, r->in.guidActionAgent),
+                        BACKUPKEY_BACKUP_GUID, strlen(BACKUPKEY_BACKUP_GUID)) == 0) {
+                        DEBUG(debuglevel, ("Client %s requested a server wrapped secret\n", addr));
+                        error = bkrp_server_wrap_encrypt_data(dce_call, mem_ctx, r, ldb_ctx);
+                }
+        }
         /*else: I am a RODC so I don't handle backup key protocol */
+        gnutls_global_deinit();
         talloc_unlink(mem_ctx, ldb_ctx);
         return error;

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

-              r740
+              r988
                 break;
         case DCESRV_LIST_CALL_LIST:
                 DLIST_ADD_END(call->conn->call_list, call, struct dcesrv_call_state *);
+                DLIST_ADD_END(call->conn->call_list, call);
                 break;
         case DCESRV_LIST_FRAGMENTED_CALL_LIST:
                 DLIST_ADD_END(call->conn->incoming_fragmented_call_list, call, struct dcesrv_call_state *);
+                DLIST_ADD_END(call->conn->incoming_fragmented_call_list, call);
                 break;
         case DCESRV_LIST_PENDING_CALL_LIST:
                 DLIST_ADD_END(call->conn->pending_call_list, call, struct dcesrv_call_state *);
+                DLIST_ADD_END(call->conn->pending_call_list, call);
                 break;
+        }
 …
   return a dcerpc fault
 */
+NTSTATUS dcesrv_fault(struct dcesrv_call_state *call, uint32_t fault_code)
+NTSTATUS dcesrv_fault_with_flags(struct dcesrv_call_state *call,
+                                 uint32_t fault_code,
+                                 uint8_t extra_flags)
+{
         struct ncacn_packet pkt;
         struct data_blob_list_item *rep;
         uint8_t zeros[4];
+        static const uint8_t zeros[4] = { 0, };
         NTSTATUS status;
         /* setup a bind_ack */
+        /* setup a fault */
         dcesrv_init_hdr(&pkt, lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
         pkt.auth_length = 0;
         pkt.call_id = call->pkt.call_id;
         pkt.ptype = DCERPC_PKT_FAULT;
+        pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
+        pkt.u.fault.alloc_hint = 0;
+        pkt.u.fault.context_id = 0;
+        pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST | extra_flags;
+        pkt.u.fault.alloc_hint = 24;
+        switch (call->pkt.ptype) {
+        case DCERPC_PKT_REQUEST:
+                pkt.u.fault.context_id = call->pkt.u.request.context_id;
+                break;
+        default:
+                pkt.u.fault.context_id = 0;
+                break;
+        }
+        if (fault_code == DCERPC_NCA_S_PROTO_ERROR) {
+                /*
+                 * context_id = 0 is forced on protocol errors.
+                 */
+                pkt.u.fault.context_id = 0;
+        }
         pkt.u.fault.cancel_count = 0;
         pkt.u.fault.status = fault_code;
-        ZERO_STRUCT(zeros);
         pkt.u.fault._pad = data_blob_const(zeros, sizeof(zeros));
         rep = talloc(call, struct data_blob_list_item);
+        rep = talloc_zero(call, struct data_blob_list_item);
         if (!rep) {
                 return NT_STATUS_NO_MEMORY;
 …
         dcerpc_set_frag_length(&rep->blob, rep->blob.length);
         DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
+        DLIST_ADD_END(call->replies, rep);
         dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
 …
+}
+NTSTATUS dcesrv_fault(struct dcesrv_call_state *call, uint32_t fault_code)
+{
+        return dcesrv_fault_with_flags(call, fault_code, 0);
+}
 _PUBLIC_ NTSTATUS dcesrv_reply(struct dcesrv_call_state *call)
 …
         /* we can write a full max_recv_frag size, minus the dcerpc
            request header size */
         chunk_size = call->conn->cli_max_recv_frag;
+        chunk_size = call->conn->max_xmit_frag;
         chunk_size -= DCERPC_REQUEST_LENGTH;
         if (call->conn->auth_state.auth_info &&
+        if (call->conn->auth_state.auth_finished &&
             call->conn->auth_state.gensec_security) {
+                size_t max_payload = chunk_size;
+                max_payload -= DCERPC_AUTH_TRAILER_LENGTH;
+                max_payload -= (max_payload % DCERPC_AUTH_PAD_ALIGNMENT);
                 sig_size = gensec_sig_size(call->conn->auth_state.gensec_security,
                                            call->conn->cli_max_recv_frag);
+                                           max_payload);
                 if (sig_size) {
                         chunk_size -= DCERPC_AUTH_TRAILER_LENGTH;
 …
+                }
+        }
         chunk_size -= (chunk_size % 16);
+        chunk_size -= (chunk_size % DCERPC_AUTH_PAD_ALIGNMENT);
         do {
 …
                 struct ncacn_packet pkt;
                 rep = talloc(call, struct data_blob_list_item);
+                rep = talloc_zero(call, struct data_blob_list_item);
                 NT_STATUS_HAVE_NO_MEMORY(rep);
 …
                 dcerpc_set_frag_length(&rep->blob, rep->blob.length);
                 DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
+                DLIST_ADD_END(call->replies, rep);
                 stub.data += length;
 …
                                     DATA_BLOB *session_key)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(c->endpoint->ep_description);
+        if (transport != NCALRPC && transport != NCACN_UNIX_STREAM) {
+                return NT_STATUS_NO_USER_SESSION_KEY;
+        }
         return dcerpc_generic_session_key(NULL, session_key);
+}

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

-              r740
+              r988
 #include "auth/auth.h"
 #include "param/param.h"
+#include "rpc_server/common/common.h"
+#include "rpc_server/common/share.h"
+#include "libds/common/roles.h"
 /*
 …
         default_server_announce |= SV_TYPE_SERVER_UNIX;
+        switch (lpcfg_announce_as(dce_ctx->lp_ctx)) {
+                case ANNOUNCE_AS_NT_SERVER:
+                        default_server_announce |= SV_TYPE_SERVER_NT;
+                        /* fall through... */
+                case ANNOUNCE_AS_NT_WORKSTATION:
+                        default_server_announce |= SV_TYPE_NT;
+                        break;
+                case ANNOUNCE_AS_WIN95:
+                        default_server_announce |= SV_TYPE_WIN95_PLUS;
+                        break;
+                case ANNOUNCE_AS_WFW:
+                        default_server_announce |= SV_TYPE_WFW;
+                        break;
+                default:
+                        break;
+        }
+        default_server_announce |= SV_TYPE_SERVER_NT;
+        default_server_announce |= SV_TYPE_NT;
         switch (lpcfg_server_role(dce_ctx->lp_ctx)) {
 …
                         default_server_announce |= SV_TYPE_DOMAIN_MEMBER;
                         break;
                 case ROLE_DOMAIN_CONTROLLER:
+                case ROLE_ACTIVE_DIRECTORY_DC:
+                {
                         struct ldb_context *samctx;

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

-              r414
+              r988
 #include "librpc/gen_ndr/srvsvc.h"
 #include "rpc_server/dcerpc_server.h"
+#include "rpc_server/common/share.h"
 /*
 …
          */
         enum srvsvc_ShareType share_type = 0;
         const char *sharetype;
+        char *sharetype;
         if (!share_bool_option(scfg, SHARE_BROWSEABLE, SHARE_BROWSEABLE_DEFAULT)) {
 …
+        }
         sharetype = share_string_option(scfg, SHARE_TYPE, SHARE_TYPE_DEFAULT);
+        sharetype = share_string_option(mem_ctx, scfg, SHARE_TYPE, SHARE_TYPE_DEFAULT);
         if (sharetype && strcasecmp(sharetype, "IPC") == 0) {
                 share_type |= STYPE_IPC;
+                TALLOC_FREE(sharetype);
                 return share_type;
+        }
 …
         if (sharetype && strcasecmp(sharetype, "PRINTER") == 0) {
                 share_type |= STYPE_PRINTQ;
+                TALLOC_FREE(sharetype);
                 return share_type;
+        }
+        TALLOC_FREE(sharetype);
         share_type |= STYPE_DISKTREE;
 …
 const char *dcesrv_common_get_share_path(TALLOC_CTX *mem_ctx, struct dcesrv_context *dce_ctx, struct share_config *scfg)
+{
         const char *sharetype;
+        char *sharetype;
         char *p;
+        sharetype = share_string_option(scfg, SHARE_TYPE, SHARE_TYPE_DEFAULT);
+        char *path;
+        sharetype = share_string_option(mem_ctx, scfg, SHARE_TYPE, SHARE_TYPE_DEFAULT);
         if (sharetype && strcasecmp(sharetype, "IPC") == 0) {
+                TALLOC_FREE(sharetype);
                 return talloc_strdup(mem_ctx, "");
+        }
+        p = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PATH, ""));
+        TALLOC_FREE(sharetype);
+        p = share_string_option(mem_ctx, scfg, SHARE_PATH, "");
         if (!p) {
                 return NULL;
 …
         all_string_sub(p, "/", "\\", 0);
+        return talloc_asprintf(mem_ctx, "C:%s", p);
+        path = talloc_asprintf(mem_ctx, "C:%s", p);
+        TALLOC_FREE(p);
+        return path;
+}

vendor/current/source4/rpc_server/dcerpc_server.c

-              r740
+              r988
 #include "lib/messaging/irpc.h"
 #include "librpc/rpc/rpc_common.h"
+/* this is only used when the client asks for an unknown interface */
+#define DUMMY_ASSOC_GROUP 0x0FFFFFFF
+#include "lib/util/samba_modules.h"
+#include "librpc/gen_ndr/ndr_dcerpc.h"
 extern const struct dcesrv_interface dcesrv_mgmt_interface;
 …
         assoc_group = dcesrv_assoc_group_find(dce_ctx, id);
         if (assoc_group == NULL) {
                 DEBUG(0,(__location__ ": Failed to find assoc_group 0x%08x\n", id));
+                DEBUG(2,(__location__ ": Failed to find assoc_group 0x%08x\n", id));
                 return NULL;
+        }
 …
                             const struct dcerpc_binding *ep2)
+{
+        if (ep1->transport != ep2->transport) {
+        enum dcerpc_transport_t t1;
+        enum dcerpc_transport_t t2;
+        const char *e1;
+        const char *e2;
+        t1 = dcerpc_binding_get_transport(ep1);
+        t2 = dcerpc_binding_get_transport(ep2);
+        e1 = dcerpc_binding_get_string_option(ep1, "endpoint");
+        e2 = dcerpc_binding_get_string_option(ep2, "endpoint");
+        if (t1 != t2) {
                 return false;
+        }
         if (!ep1->endpoint || !ep2->endpoint) {
                 return ep1->endpoint == ep2->endpoint;
+        }
         if (strcasecmp(ep1->endpoint, ep2->endpoint) != 0)
+        if (!e1 || !e2) {
+                return e1 == e2;
+        }
+        if (strcasecmp(e1, e2) != 0) {
                 return false;
+        }
         return true;
 …
          */
         if ((ep=find_endpoint(dce_ctx, binding))==NULL) {
                 ep = talloc(dce_ctx, struct dcesrv_endpoint);
+                ep = talloc_zero(dce_ctx, struct dcesrv_endpoint);
                 if (!ep) {
                         return NT_STATUS_NO_MEMORY;
+                }
                 ZERO_STRUCTP(ep);
                 ep->ep_description = talloc_reference(ep, binding);
+                ep->ep_description = talloc_move(ep, &binding);
                 add_ep = true;
                 /* add mgmt interface */
                 ifl = talloc(dce_ctx, struct dcesrv_if_list);
+                ifl = talloc_zero(ep, struct dcesrv_if_list);
                 if (!ifl) {
                         return NT_STATUS_NO_MEMORY;
 …
         /* talloc a new interface list element */
         ifl = talloc(dce_ctx, struct dcesrv_if_list);
+        ifl = talloc_zero(ep, struct dcesrv_if_list);
         if (!ifl) {
                 return NT_STATUS_NO_MEMORY;
 …
                  */
                 if (ep->sd == NULL) {
                         ep->sd = security_descriptor_copy(dce_ctx, sd);
+                        ep->sd = security_descriptor_copy(ep, sd);
+                }
 …
                                  struct auth_session_info *session_info,
                                  struct tevent_context *event_ctx,
                                  struct messaging_context *msg_ctx,
+                                 struct imessaging_context *msg_ctx,
                                  struct server_id server_id,
                                  uint32_t state_flags,
 …
+        }
         p = talloc(mem_ctx, struct dcesrv_connection);
+        p = talloc_zero(mem_ctx, struct dcesrv_connection);
         NT_STATUS_HAVE_NO_MEMORY(p);
 …
         p->dce_ctx = dce_ctx;
         p->endpoint = ep;
+        p->contexts = NULL;
+        p->call_list = NULL;
+        p->packet_log_dir = lpcfg_lockdir(dce_ctx->lp_ctx);
+        p->incoming_fragmented_call_list = NULL;
+        p->pending_call_list = NULL;
+        p->cli_max_recv_frag = 0;
+        p->partial_input = data_blob(NULL, 0);
+        p->auth_state.auth_info = NULL;
+        p->auth_state.gensec_security = NULL;
+        p->packet_log_dir = lpcfg_lock_directory(dce_ctx->lp_ctx);
         p->auth_state.session_info = session_info;
         p->auth_state.session_key = dcesrv_generic_session_key;
 …
         p->msg_ctx = msg_ctx;
         p->server_id = server_id;
-        p->processing = false;
         p->state_flags = state_flags;
+        ZERO_STRUCT(p->transport);
+        p->allow_bind = true;
+        p->max_recv_frag = 5840;
+        p->max_xmit_frag = 5840;
         *_p = p;
 …
                 break;
         case DCESRV_LIST_CALL_LIST:
                 DLIST_ADD_END(call->conn->call_list, call, struct dcesrv_call_state *);
+                DLIST_ADD_END(call->conn->call_list, call);
                 break;
         case DCESRV_LIST_FRAGMENTED_CALL_LIST:
                 DLIST_ADD_END(call->conn->incoming_fragmented_call_list, call, struct dcesrv_call_state *);
+                DLIST_ADD_END(call->conn->incoming_fragmented_call_list, call);
                 break;
         case DCESRV_LIST_PENDING_CALL_LIST:
                 DLIST_ADD_END(call->conn->pending_call_list, call, struct dcesrv_call_state *);
+                DLIST_ADD_END(call->conn->pending_call_list, call);
                 break;
+        }
+}
+static void dcesrv_call_disconnect_after(struct dcesrv_call_state *call,
+                                         const char *reason)
+{
+        if (call->conn->terminate != NULL) {
+                return;
+        }
+        call->conn->allow_bind = false;
+        call->conn->allow_alter = false;
+        call->conn->allow_auth3 = false;
+        call->conn->allow_request = false;
+        call->terminate_reason = talloc_strdup(call, reason);
+        if (call->terminate_reason == NULL) {
+                call->terminate_reason = __location__;
+        }
+}
 /*
 …
+{
         struct ncacn_packet pkt;
+        struct dcerpc_bind_nak_version version;
         struct data_blob_list_item *rep;
         NTSTATUS status;
+        static const uint8_t _pad[3] = { 0, };
+        /*
+         * We add the call to the pending_call_list
+         * in order to defer the termination.
+         */
+        dcesrv_call_disconnect_after(call, "dcesrv_bind_nak");
         /* setup a bind_nak */
 …
         pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
         pkt.u.bind_nak.reject_reason = reason;
+        if (pkt.u.bind_nak.reject_reason == DECRPC_BIND_PROTOCOL_VERSION_NOT_SUPPORTED) {
+                pkt.u.bind_nak.versions.v.num_versions = 0;
+        }
+        rep = talloc(call, struct data_blob_list_item);
+        version.rpc_vers = 5;
+        version.rpc_vers_minor = 0;
+        pkt.u.bind_nak.num_versions = 1;
+        pkt.u.bind_nak.versions = &version;
+        pkt.u.bind_nak._pad = data_blob_const(_pad, sizeof(_pad));
+        rep = talloc_zero(call, struct data_blob_list_item);
         if (!rep) {
                 return NT_STATUS_NO_MEMORY;
 …
         dcerpc_set_frag_length(&rep->blob, rep->blob.length);
         DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
+        DLIST_ADD_END(call->replies, rep);
         dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
 …
+}
+static NTSTATUS dcesrv_fault_disconnect(struct dcesrv_call_state *call,
+                                 uint32_t fault_code)
+{
+        /*
+         * We add the call to the pending_call_list
+         * in order to defer the termination.
+         */
+        dcesrv_call_disconnect_after(call, "dcesrv_fault_disconnect");
+        return dcesrv_fault_with_flags(call, fault_code,
+                                       DCERPC_PFC_FLAG_DID_NOT_EXECUTE);
+}
 static int dcesrv_connection_context_destructor(struct dcesrv_connection_context *c)
+{
 …
         if (c->iface && c->iface->unbind) {
                 c->iface->unbind(c, c->iface);
+                c->iface = NULL;
+        }
         return 0;
+}
+static void dcesrv_prepare_context_auth(struct dcesrv_call_state *dce_call)
+{
+        struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        const struct dcesrv_endpoint *endpoint = dce_call->conn->endpoint;
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(endpoint->ep_description);
+        struct dcesrv_connection_context *context = dce_call->context;
+        const struct dcesrv_interface *iface = context->iface;
+        context->min_auth_level = DCERPC_AUTH_LEVEL_NONE;
+        if (transport == NCALRPC) {
+                context->allow_connect = true;
+                return;
+        }
+        /*
+         * allow overwrite per interface
+         * allow dcerpc auth level connect:<interface>
+         */
+        context->allow_connect = lpcfg_allow_dcerpc_auth_level_connect(lp_ctx);
+        context->allow_connect = lpcfg_parm_bool(lp_ctx, NULL,
+                                        "allow dcerpc auth level connect",
+                                        iface->name,
+                                        context->allow_connect);
+}
+NTSTATUS dcesrv_interface_bind_require_integrity(struct dcesrv_call_state *dce_call,
+                                                 const struct dcesrv_interface *iface)
+{
+        if (dce_call->context == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        dce_call->context->min_auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
+        return NT_STATUS_OK;
+}
+NTSTATUS dcesrv_interface_bind_require_privacy(struct dcesrv_call_state *dce_call,
+                                               const struct dcesrv_interface *iface)
+{
+        if (dce_call->context == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        dce_call->context->min_auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
+        return NT_STATUS_OK;
+}
+_PUBLIC_ NTSTATUS dcesrv_interface_bind_reject_connect(struct dcesrv_call_state *dce_call,
+                                                       const struct dcesrv_interface *iface)
+{
+        struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        const struct dcesrv_endpoint *endpoint = dce_call->conn->endpoint;
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(endpoint->ep_description);
+        struct dcesrv_connection_context *context = dce_call->context;
+        if (context == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        if (transport == NCALRPC) {
+                context->allow_connect = true;
+                return NT_STATUS_OK;
+        }
+        /*
+         * allow overwrite per interface
+         * allow dcerpc auth level connect:<interface>
+         */
+        context->allow_connect = false;
+        context->allow_connect = lpcfg_parm_bool(lp_ctx, NULL,
+                                        "allow dcerpc auth level connect",
+                                        iface->name,
+                                        context->allow_connect);
+        return NT_STATUS_OK;
+}
+_PUBLIC_ NTSTATUS dcesrv_interface_bind_allow_connect(struct dcesrv_call_state *dce_call,
+                                                      const struct dcesrv_interface *iface)
+{
+        struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        const struct dcesrv_endpoint *endpoint = dce_call->conn->endpoint;
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(endpoint->ep_description);
+        struct dcesrv_connection_context *context = dce_call->context;
+        if (context == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        if (transport == NCALRPC) {
+                context->allow_connect = true;
+                return NT_STATUS_OK;
+        }
+        /*
+         * allow overwrite per interface
+         * allow dcerpc auth level connect:<interface>
+         */
+        context->allow_connect = true;
+        context->allow_connect = lpcfg_parm_bool(lp_ctx, NULL,
+                                        "allow dcerpc auth level connect",
+                                        iface->name,
+                                        context->allow_connect);
+        return NT_STATUS_OK;
+}
 …
         const struct dcesrv_interface *iface;
         uint32_t extra_flags = 0;
+        uint16_t max_req = 0;
+        uint16_t max_rep = 0;
+        const char *ep_prefix = "";
+        const char *endpoint = NULL;
+        status = dcerpc_verify_ncacn_packet_header(&call->pkt,
+                        DCERPC_PKT_BIND,
+                        call->pkt.u.bind.auth_info.length,
+, /* required flags */
+                        DCERPC_PFC_FLAG_FIRST |
+                        DCERPC_PFC_FLAG_LAST |
+                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
+x08 | /* this is not defined, but should be ignored */
+                        DCERPC_PFC_FLAG_CONC_MPX |
+                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
+                        DCERPC_PFC_FLAG_MAYBE |
+                        DCERPC_PFC_FLAG_OBJECT_UUID);
+        if (!NT_STATUS_IS_OK(status)) {
+                return dcesrv_bind_nak(call,
+                        DCERPC_BIND_NAK_REASON_PROTOCOL_VERSION_NOT_SUPPORTED);
+        }
+        /* max_recv_frag and max_xmit_frag result always in the same value! */
+        max_req = MIN(call->pkt.u.bind.max_xmit_frag,
+                      call->pkt.u.bind.max_recv_frag);
+        /*
+         * The values are between 2048 and 5840 tested against Windows 2012R2
+         * via ncacn_ip_tcp on port 135.
+         */
+        max_req = MAX(2048, max_req);
+        max_rep = MIN(max_req, call->conn->max_recv_frag);
+        /* They are truncated to an 8 byte boundary. */
+        max_rep &= 0xFFF8;
+        /* max_recv_frag and max_xmit_frag result always in the same value! */
+        call->conn->max_recv_frag = max_rep;
+        call->conn->max_xmit_frag = max_rep;
         /*
           if provided, check the assoc_group is valid
          */
+        if (call->pkt.u.bind.assoc_group_id != 0 &&
+            lpcfg_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
+            dcesrv_assoc_group_find(call->conn->dce_ctx, call->pkt.u.bind.assoc_group_id) == NULL) {
+                return dcesrv_bind_nak(call, 0);
+        if (call->pkt.u.bind.assoc_group_id != 0) {
+                call->conn->assoc_group = dcesrv_assoc_group_reference(call->conn,
+                                                                       call->conn->dce_ctx,
+                                                                       call->pkt.u.bind.assoc_group_id);
+        } else {
+                call->conn->assoc_group = dcesrv_assoc_group_new(call->conn,
+                                                                 call->conn->dce_ctx);
+        }
+        if (call->conn->assoc_group == NULL) {
+                return dcesrv_bind_nak(call, 0);
+        }
 …
         context_id = call->pkt.u.bind.ctx_list[0].context_id;
-        /* you can't bind twice on one context */
-        if (dcesrv_find_context(call->conn, context_id) != NULL) {
-                return dcesrv_bind_nak(call, 0);
+        }
         if_version = call->pkt.u.bind.ctx_list[0].abstract_syntax.if_version;
         uuid = call->pkt.u.bind.ctx_list[0].abstract_syntax.uuid;
 …
         transfer_syntax_version = call->pkt.u.bind.ctx_list[0].transfer_syntaxes[0].if_version;
         transfer_syntax_uuid = &call->pkt.u.bind.ctx_list[0].transfer_syntaxes[0].uuid;
         if (!GUID_equal(&ndr_transfer_syntax.uuid, transfer_syntax_uuid) != 0 ||
             ndr_transfer_syntax.if_version != transfer_syntax_version) {
+        if (!GUID_equal(&ndr_transfer_syntax_ndr.uuid, transfer_syntax_uuid) != 0 ||
+            ndr_transfer_syntax_ndr.if_version != transfer_syntax_version) {
                 char *uuid_str = GUID_string(call, transfer_syntax_uuid);
                 /* we only do NDR encoded dcerpc */
 …
         if (iface) {
                 /* add this context to the list of available context_ids */
                 struct dcesrv_connection_context *context = talloc(call->conn,
+                struct dcesrv_connection_context *context = talloc_zero(call->conn,
                                                                    struct dcesrv_connection_context);
                 if (context == NULL) {
 …
                 context->iface = iface;
                 context->context_id = context_id;
+                if (call->pkt.u.bind.assoc_group_id != 0) {
+                        context->assoc_group = dcesrv_assoc_group_reference(context,
+                                                                            call->conn->dce_ctx,
+                                                                            call->pkt.u.bind.assoc_group_id);
+                } else {
+                        context->assoc_group = dcesrv_assoc_group_new(context, call->conn->dce_ctx);
+                }
+                if (context->assoc_group == NULL) {
+                        talloc_free(context);
+                        return dcesrv_bind_nak(call, 0);
+                }
+                /* legacy for openchange dcesrv_mapiproxy.c */
+                context->assoc_group = call->conn->assoc_group;
                 context->private_data = NULL;
                 DLIST_ADD(call->conn->contexts, context);
                 call->context = context;
                 talloc_set_destructor(context, dcesrv_connection_context_destructor);
+                dcesrv_prepare_context_auth(call);
                 status = iface->bind(call, iface, if_version);
 …
+        }
         if (call->conn->cli_max_recv_frag == 0) {
                 call->conn->cli_max_recv_frag = MIN(0x2000, call->pkt.u.bind.max_recv_frag);
+        }
         if ((call->pkt.pfc_flags & DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN) &&
+            lpcfg_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","header signing", false)) {
                 call->conn->state_flags |= DCESRV_CALL_STATE_FLAG_HEADER_SIGNING;
                 extra_flags |= DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN;
+        if ((call->pkt.pfc_flags & DCERPC_PFC_FLAG_CONC_MPX) &&
+            (call->state_flags & DCESRV_CALL_STATE_FLAG_MULTIPLEXED)) {
+                call->context->conn->state_flags |= DCESRV_CALL_STATE_FLAG_MULTIPLEXED;
+                extra_flags |= DCERPC_PFC_FLAG_CONC_MPX;
+        }
+        if (call->state_flags & DCESRV_CALL_STATE_FLAG_PROCESS_PENDING_CALL) {
+                call->context->conn->state_flags |= DCESRV_CALL_STATE_FLAG_PROCESS_PENDING_CALL;
+        }
         /* handle any authentication that is being requested */
         if (!dcesrv_auth_bind(call)) {
+                talloc_free(call->context);
+                call->context = NULL;
+                return dcesrv_bind_nak(call, DCERPC_BIND_REASON_INVALID_AUTH_TYPE);
+                struct dcesrv_auth *auth = &call->conn->auth_state;
+                TALLOC_FREE(call->context);
+                if (auth->auth_level != DCERPC_AUTH_LEVEL_NONE) {
+                        /*
+                         * We only give INVALID_AUTH_TYPE if the auth_level was
+                         * valid.
+                         */
+                        return dcesrv_bind_nak(call,
+                                        DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE);
+                }
+                return dcesrv_bind_nak(call,
+                                        DCERPC_BIND_NAK_REASON_NOT_SPECIFIED);
+        }
 …
         pkt.ptype = DCERPC_PKT_BIND_ACK;
         pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST | extra_flags;
+        pkt.u.bind_ack.max_xmit_frag = call->conn->cli_max_recv_frag;
+        pkt.u.bind_ack.max_recv_frag = 0x2000;
+        /*
+          make it possible for iface->bind() to specify the assoc_group_id
+          This helps the openchange mapiproxy plugin to work correctly.
+          metze
+        */
+        if (call->context) {
+                pkt.u.bind_ack.assoc_group_id = call->context->assoc_group->id;
+        } else {
+                pkt.u.bind_ack.assoc_group_id = DUMMY_ASSOC_GROUP;
+        }
+        pkt.u.bind_ack.max_xmit_frag = call->conn->max_xmit_frag;
+        pkt.u.bind_ack.max_recv_frag = call->conn->max_recv_frag;
+        pkt.u.bind_ack.assoc_group_id = call->conn->assoc_group->id;
         if (iface) {
+                /* FIXME: Use pipe name as specified by endpoint instead of interface name */
+                pkt.u.bind_ack.secondary_address = talloc_asprintf(call, "\\PIPE\\%s", iface->name);
+        } else {
+                pkt.u.bind_ack.secondary_address = "";
+                endpoint = dcerpc_binding_get_string_option(
+                                call->conn->endpoint->ep_description,
+                                "endpoint");
+        }
+        if (endpoint == NULL) {
+                endpoint = "";
+        }
+        if (strncasecmp(endpoint, "\\pipe\\", 6) == 0) {
+                /*
+                 * TODO: check if this is really needed
+                 *
+                 * Or if we should fix this in our idl files.
+                 */
+                ep_prefix = "\\PIPE\\";
+                endpoint += 6;
+        }
+        pkt.u.bind_ack.secondary_address = talloc_asprintf(call, "%s%s",
+                                                           ep_prefix,
+                                                           endpoint);
+        if (pkt.u.bind_ack.secondary_address == NULL) {
+                TALLOC_FREE(call->context);
+                return NT_STATUS_NO_MEMORY;
+        }
         pkt.u.bind_ack.num_results = 1;
         pkt.u.bind_ack.ctx_list = talloc(call, struct dcerpc_ack_ctx);
+        pkt.u.bind_ack.ctx_list = talloc_zero(call, struct dcerpc_ack_ctx);
         if (!pkt.u.bind_ack.ctx_list) {
                 talloc_free(call->context);
 …
+        }
         pkt.u.bind_ack.ctx_list[0].result = result;
         pkt.u.bind_ack.ctx_list[0].reason = reason;
         pkt.u.bind_ack.ctx_list[0].syntax = ndr_transfer_syntax;
+        pkt.u.bind_ack.ctx_list[0].reason.value = reason;
+        pkt.u.bind_ack.ctx_list[0].syntax = ndr_transfer_syntax_ndr;
         pkt.u.bind_ack.auth_info = data_blob(NULL, 0);
 …
+        }
         rep = talloc(call, struct data_blob_list_item);
+        rep = talloc_zero(call, struct data_blob_list_item);
         if (!rep) {
                 talloc_free(call->context);
 …
         status = ncacn_push_auth(&rep->blob, call, &pkt,
                                                          call->conn->auth_state.auth_info);
+                                 call->out_auth_info);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(call->context);
 …
         dcerpc_set_frag_length(&rep->blob, rep->blob.length);
         DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
+        DLIST_ADD_END(call->replies, rep);
         dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
 …
 static NTSTATUS dcesrv_auth3(struct dcesrv_call_state *call)
+{
+        NTSTATUS status;
+        if (!call->conn->allow_auth3) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
+        if (call->conn->auth_state.auth_finished) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
+        status = dcerpc_verify_ncacn_packet_header(&call->pkt,
+                        DCERPC_PKT_AUTH3,
+                        call->pkt.u.auth3.auth_info.length,
+, /* required flags */
+                        DCERPC_PFC_FLAG_FIRST |
+                        DCERPC_PFC_FLAG_LAST |
+                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
+x08 | /* this is not defined, but should be ignored */
+                        DCERPC_PFC_FLAG_CONC_MPX |
+                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
+                        DCERPC_PFC_FLAG_MAYBE |
+                        DCERPC_PFC_FLAG_OBJECT_UUID);
+        if (!NT_STATUS_IS_OK(status)) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
         /* handle the auth3 in the auth code */
         if (!dcesrv_auth_auth3(call)) {
                 return dcesrv_fault(call, DCERPC_FAULT_OTHER);
+                call->conn->auth_state.auth_invalid = true;
+        }
 …
         transfer_syntax_version = call->pkt.u.alter.ctx_list[0].transfer_syntaxes[0].if_version;
         transfer_syntax_uuid = &call->pkt.u.alter.ctx_list[0].transfer_syntaxes[0].uuid;
         if (!GUID_equal(transfer_syntax_uuid, &ndr_transfer_syntax.uuid) ||
             ndr_transfer_syntax.if_version != transfer_syntax_version) {
+        if (!GUID_equal(transfer_syntax_uuid, &ndr_transfer_syntax_ndr.uuid) ||
+            ndr_transfer_syntax_ndr.if_version != transfer_syntax_version) {
                 /* we only do NDR encoded dcerpc */
                 return NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED;
 …
         /* add this context to the list of available context_ids */
         context = talloc(call->conn, struct dcesrv_connection_context);
+        context = talloc_zero(call->conn, struct dcesrv_connection_context);
         if (context == NULL) {
                 return NT_STATUS_NO_MEMORY;
 …
         context->iface = iface;
         context->context_id = context_id;
+        if (call->pkt.u.alter.assoc_group_id != 0) {
+                context->assoc_group = dcesrv_assoc_group_reference(context,
+                                                                    call->conn->dce_ctx,
+                                                                    call->pkt.u.alter.assoc_group_id);
+        } else {
+                context->assoc_group = dcesrv_assoc_group_new(context, call->conn->dce_ctx);
+        }
+        if (context->assoc_group == NULL) {
+                talloc_free(context);
+                call->context = NULL;
+                return NT_STATUS_NO_MEMORY;
+        }
+        /* legacy for openchange dcesrv_mapiproxy.c */
+        context->assoc_group = call->conn->assoc_group;
         context->private_data = NULL;
         DLIST_ADD(call->conn->contexts, context);
         call->context = context;
         talloc_set_destructor(context, dcesrv_connection_context_destructor);
+        dcesrv_prepare_context_auth(call);
         status = iface->bind(call, iface, if_version);
 …
+}
+/*
+  handle a alter context request
+*/
+static NTSTATUS dcesrv_alter(struct dcesrv_call_state *call)
+/* setup and send an alter_resp */
+static NTSTATUS dcesrv_alter_resp(struct dcesrv_call_state *call,
+                                uint32_t result,
+                                uint32_t reason)
+{
         struct ncacn_packet pkt;
+        struct data_blob_list_item *rep;
+        uint32_t extra_flags = 0;
+        struct data_blob_list_item *rep = NULL;
         NTSTATUS status;
+        uint32_t result=0, reason=0;
+        uint32_t context_id;
+        /* handle any authentication that is being requested */
+        if (!dcesrv_auth_alter(call)) {
+                /* TODO: work out the right reject code */
+                result = DCERPC_BIND_PROVIDER_REJECT;
+                reason = DCERPC_BIND_REASON_ASYNTAX;
+        }
+        context_id = call->pkt.u.alter.ctx_list[0].context_id;
+        /* see if they are asking for a new interface */
+        if (result == 0) {
+                call->context = dcesrv_find_context(call->conn, context_id);
+                if (!call->context) {
+                        status = dcesrv_alter_new_context(call, context_id);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                result = DCERPC_BIND_PROVIDER_REJECT;
+                                reason = DCERPC_BIND_REASON_ASYNTAX;
+                        }
+                }
+        }
+        if (result == 0 &&
+            call->pkt.u.alter.assoc_group_id != 0 &&
+            lpcfg_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","assoc group checking", true) &&
+            call->pkt.u.alter.assoc_group_id != call->context->assoc_group->id) {
+                DEBUG(0,(__location__ ": Failed attempt to use new assoc_group in alter context (0x%08x 0x%08x)\n",
+                         call->context->assoc_group->id, call->pkt.u.alter.assoc_group_id));
+                /* TODO: can they ask for a new association group? */
+                result = DCERPC_BIND_PROVIDER_REJECT;
+                reason = DCERPC_BIND_REASON_ASYNTAX;
+        }
+        /* setup a alter_resp */
         dcesrv_init_hdr(&pkt, lpcfg_rpc_big_endian(call->conn->dce_ctx->lp_ctx));
         pkt.auth_length = 0;
         pkt.call_id = call->pkt.call_id;
         pkt.ptype = DCERPC_PKT_ALTER_RESP;
-        pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST;
-        pkt.u.alter_resp.max_xmit_frag = 0x2000;
-        pkt.u.alter_resp.max_recv_frag = 0x2000;
         if (result == 0) {
+                pkt.u.alter_resp.assoc_group_id = call->context->assoc_group->id;
+        } else {
+                pkt.u.alter_resp.assoc_group_id = 0;
+        }
+                if ((call->pkt.pfc_flags & DCERPC_PFC_FLAG_CONC_MPX) &&
+                                call->context->conn->state_flags &
+                                        DCESRV_CALL_STATE_FLAG_MULTIPLEXED) {
+                        extra_flags |= DCERPC_PFC_FLAG_CONC_MPX;
+                }
+                if (call->state_flags & DCESRV_CALL_STATE_FLAG_PROCESS_PENDING_CALL) {
+                        call->context->conn->state_flags |=
+                                DCESRV_CALL_STATE_FLAG_PROCESS_PENDING_CALL;
+                }
+        }
+        pkt.pfc_flags = DCERPC_PFC_FLAG_FIRST | DCERPC_PFC_FLAG_LAST | extra_flags;
+        pkt.u.alter_resp.max_xmit_frag = call->conn->max_xmit_frag;
+        pkt.u.alter_resp.max_recv_frag = call->conn->max_recv_frag;
+        pkt.u.alter_resp.assoc_group_id = call->conn->assoc_group->id;
         pkt.u.alter_resp.num_results = 1;
         pkt.u.alter_resp.ctx_list = talloc_array(call, struct dcerpc_ack_ctx, 1);
+        pkt.u.alter_resp.ctx_list = talloc_zero(call, struct dcerpc_ack_ctx);
         if (!pkt.u.alter_resp.ctx_list) {
                 return NT_STATUS_NO_MEMORY;
+        }
         pkt.u.alter_resp.ctx_list[0].result = result;
         pkt.u.alter_resp.ctx_list[0].reason = reason;
         pkt.u.alter_resp.ctx_list[0].syntax = ndr_transfer_syntax;
+        pkt.u.alter_resp.ctx_list[0].reason.value = reason;
+        pkt.u.alter_resp.ctx_list[0].syntax = ndr_transfer_syntax_ndr;
         pkt.u.alter_resp.auth_info = data_blob(NULL, 0);
         pkt.u.alter_resp.secondary_address = "";
 …
         status = dcesrv_auth_alter_ack(call, &pkt);
         if (!NT_STATUS_IS_OK(status)) {
+                if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)
+                    || NT_STATUS_EQUAL(status, NT_STATUS_LOGON_FAILURE)
+                    || NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER)
+                    || NT_STATUS_EQUAL(status, NT_STATUS_WRONG_PASSWORD)) {
+                        return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
+                }
+                return dcesrv_fault(call, 0);
+        }
+        rep = talloc(call, struct data_blob_list_item);
+                return dcesrv_fault_disconnect(call, DCERPC_FAULT_SEC_PKG_ERROR);
+        }
+        rep = talloc_zero(call, struct data_blob_list_item);
         if (!rep) {
                 return NT_STATUS_NO_MEMORY;
+        }
         status = ncacn_push_auth(&rep->blob, call, &pkt, call->conn->auth_state.auth_info);
+        status = ncacn_push_auth(&rep->blob, call, &pkt, call->out_auth_info);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
         dcerpc_set_frag_length(&rep->blob, rep->blob.length);
         DLIST_ADD_END(call->replies, rep, struct data_blob_list_item *);
+        DLIST_ADD_END(call->replies, rep);
         dcesrv_call_set_list(call, DCESRV_LIST_CALL_LIST);
 …
         return NT_STATUS_OK;
+}
+/*
+  handle a alter context request
+*/
+static NTSTATUS dcesrv_alter(struct dcesrv_call_state *call)
+{
+        NTSTATUS status;
+        const struct dcerpc_ctx_list *ctx = NULL;
+        bool auth_ok = false;
+        if (!call->conn->allow_alter) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
+        status = dcerpc_verify_ncacn_packet_header(&call->pkt,
+                        DCERPC_PKT_ALTER,
+                        call->pkt.u.alter.auth_info.length,
+, /* required flags */
+                        DCERPC_PFC_FLAG_FIRST |
+                        DCERPC_PFC_FLAG_LAST |
+                        DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN |
+x08 | /* this is not defined, but should be ignored */
+                        DCERPC_PFC_FLAG_CONC_MPX |
+                        DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
+                        DCERPC_PFC_FLAG_MAYBE |
+                        DCERPC_PFC_FLAG_OBJECT_UUID);
+        if (!NT_STATUS_IS_OK(status)) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
+        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->pkt.u.alter.num_contexts < 1) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
+        ctx = &call->pkt.u.alter.ctx_list[0];
+        if (ctx->num_transfer_syntaxes < 1) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
+        /* see if they are asking for a new interface */
+        call->context = dcesrv_find_context(call->conn, ctx->context_id);
+        if (!call->context) {
+                status = dcesrv_alter_new_context(call, ctx->context_id);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return dcesrv_alter_resp(call,
+                                DCERPC_BIND_PROVIDER_REJECT,
+                                DCERPC_BIND_REASON_ASYNTAX);
+                }
+        } else {
+                bool ok;
+                ok = ndr_syntax_id_equal(&ctx->abstract_syntax,
+                                         &call->context->iface->syntax_id);
+                if (!ok) {
+                        return dcesrv_fault_disconnect(call,
+                                        DCERPC_NCA_S_PROTO_ERROR);
+                }
+                if (ctx->num_transfer_syntaxes != 1) {
+                        return dcesrv_fault_disconnect(call,
+                                        DCERPC_NCA_S_PROTO_ERROR);
+                }
+                ok = ndr_syntax_id_equal(&ctx->transfer_syntaxes[0],
+                                         &ndr_transfer_syntax_ndr);
+                if (!ok) {
+                        return dcesrv_fault_disconnect(call,
+                                        DCERPC_NCA_S_PROTO_ERROR);
+                }
+        }
+        /* handle any authentication that is being requested */
+        if (!auth_ok) {
+                if (call->in_auth_info.auth_type !=
+                    call->conn->auth_state.auth_type)
+                {
+                        return dcesrv_fault_disconnect(call,
+                                        DCERPC_FAULT_SEC_PKG_ERROR);
+                }
+                return dcesrv_fault_disconnect(call, DCERPC_FAULT_ACCESS_DENIED);
+        }
+        return dcesrv_alter_resp(call,
+                                DCERPC_BIND_ACK_RESULT_ACCEPTANCE,
+                                DCERPC_BIND_ACK_REASON_NOT_SPECIFIED);
+}
 …
+}
+static NTSTATUS dcesrv_check_verification_trailer(struct dcesrv_call_state *call)
+{
+        TALLOC_CTX *frame = talloc_stackframe();
+        const uint32_t bitmask1 = call->conn->auth_state.client_hdr_signing ?
+                DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING : 0;
+        const struct dcerpc_sec_vt_pcontext pcontext = {
+                .abstract_syntax = call->context->iface->syntax_id,
+                .transfer_syntax = ndr_transfer_syntax_ndr,
+        };
+        const struct dcerpc_sec_vt_header2 header2 =
+                dcerpc_sec_vt_header2_from_ncacn_packet(&call->pkt);
+        enum ndr_err_code ndr_err;
+        struct dcerpc_sec_verification_trailer *vt = NULL;
+        NTSTATUS status = NT_STATUS_OK;
+        bool ok;
+        SMB_ASSERT(call->pkt.ptype == DCERPC_PKT_REQUEST);
+        ndr_err = ndr_pop_dcerpc_sec_verification_trailer(call->ndr_pull,
+                                                          frame, &vt);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                status = ndr_map_error2ntstatus(ndr_err);
+                goto done;
+        }
+        ok = dcerpc_sec_verification_trailer_check(vt, &bitmask1,
+                                                   &pcontext, &header2);
+        if (!ok) {
+                status = NT_STATUS_ACCESS_DENIED;
+                goto done;
+        }
+done:
+        TALLOC_FREE(frame);
+        return status;
+}
 /*
   handle a dcerpc request packet
 …
 static NTSTATUS dcesrv_request(struct dcesrv_call_state *call)
+{
+        const struct dcesrv_endpoint *endpoint = call->conn->endpoint;
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(endpoint->ep_description);
         struct ndr_pull *pull;
         NTSTATUS status;
         struct dcesrv_connection_context *context;
+        if (!call->conn->allow_request) {
+                return dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
+        }
         /* if authenticated, and the mech we use can't do async replies, don't use them... */
 …
+        }
+        switch (call->conn->auth_state.auth_level) {
+        case DCERPC_AUTH_LEVEL_NONE:
+        case DCERPC_AUTH_LEVEL_INTEGRITY:
+        case DCERPC_AUTH_LEVEL_PRIVACY:
+                break;
+        default:
+                if (!context->allow_connect) {
+                        char *addr;
+                        addr = tsocket_address_string(call->conn->remote_address,
+                                                      call);
+                        DEBUG(2, ("%s: restrict auth_level_connect access "
+                                  "to [%s] with auth[type=0x%x,level=0x%x] "
+                                  "on [%s] from [%s]\n",
+                                  __func__, context->iface->name,
+                                  call->conn->auth_state.auth_type,
+                                  call->conn->auth_state.auth_level,
+                                  derpc_transport_string_by_transport(transport),
+                                  addr));
+                        return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
+                }
+                break;
+        }
+        if (call->conn->auth_state.auth_level < context->min_auth_level) {
+                char *addr;
+                addr = tsocket_address_string(call->conn->remote_address, call);
+                DEBUG(2, ("%s: restrict access by min_auth_level[0x%x] "
+                          "to [%s] with auth[type=0x%x,level=0x%x] "
+                          "on [%s] from [%s]\n",
+                          __func__,
+                          context->min_auth_level,
+                          context->iface->name,
+                          call->conn->auth_state.auth_type,
+                          call->conn->auth_state.auth_level,
+                          derpc_transport_string_by_transport(transport),
+                          addr));
+                return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
+        }
         pull = ndr_pull_init_blob(&call->pkt.u.request.stub_and_verifier, call);
         NT_STATUS_HAVE_NO_MEMORY(pull);
 …
         if (!(call->pkt.drep[0] & DCERPC_DREP_LE)) {
                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
+        }
+        status = dcesrv_check_verification_trailer(call);
+        if (!NT_STATUS_IS_OK(status)) {
+                uint32_t faultcode = DCERPC_FAULT_OTHER;
+                if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
+                        faultcode = DCERPC_FAULT_ACCESS_DENIED;
+                }
+                DEBUG(10, ("dcesrv_check_verification_trailer failed: %s\n",
+                           nt_errstr(status)));
+                return dcesrv_fault(call, faultcode);
+        }
 …
   process some input to a dcerpc endpoint server.
 */
 NTSTATUS dcesrv_process_ncacn_packet(struct dcesrv_connection *dce_conn,
                                      struct ncacn_packet *pkt,
                                      DATA_BLOB blob)
+static NTSTATUS dcesrv_process_ncacn_packet(struct dcesrv_connection *dce_conn,
+                                            struct ncacn_packet *pkt,
+                                            DATA_BLOB blob)
+{
         NTSTATUS status;
         struct dcesrv_call_state *call;
+        struct dcesrv_call_state *existing = NULL;
         call = talloc_zero(dce_conn, struct dcesrv_call_state);
 …
         talloc_set_destructor(call, dcesrv_call_dequeue);
+        if (call->conn->allow_bind) {
+                /*
+                 * Only one bind is possible per connection
+                 */
+                call->conn->allow_bind = false;
+                return dcesrv_bind(call);
+        }
         /* we have to check the signing here, before combining the
            pdus */
+        if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
+            !dcesrv_auth_request(call, &blob)) {
+                return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
+        if (call->pkt.ptype == DCERPC_PKT_REQUEST) {
+                if (!call->conn->allow_request) {
+                        return dcesrv_fault_disconnect(call,
+                                        DCERPC_NCA_S_PROTO_ERROR);
+                }
+                status = dcerpc_verify_ncacn_packet_header(&call->pkt,
+                                DCERPC_PKT_REQUEST,
+                                call->pkt.u.request.stub_and_verifier.length,
+, /* required_flags */
+                                DCERPC_PFC_FLAG_FIRST |
+                                DCERPC_PFC_FLAG_LAST |
+                                DCERPC_PFC_FLAG_PENDING_CANCEL |
+x08 | /* this is not defined, but should be ignored */
+                                DCERPC_PFC_FLAG_CONC_MPX |
+                                DCERPC_PFC_FLAG_DID_NOT_EXECUTE |
+                                DCERPC_PFC_FLAG_MAYBE |
+                                DCERPC_PFC_FLAG_OBJECT_UUID);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return dcesrv_fault_disconnect(call,
+                                        DCERPC_NCA_S_PROTO_ERROR);
+                }
+                if (call->pkt.frag_length > DCERPC_FRAG_MAX_SIZE) {
+                        /*
+                         * We don't use dcesrv_fault_disconnect()
+                         * here, because we don't want to set
+                         * DCERPC_PFC_FLAG_DID_NOT_EXECUTE
+                         *
+                         * Note that we don't check against the negotiated
+                         * max_recv_frag, but a hard coded value.
+                         */
+                        dcesrv_call_disconnect_after(call,
+                                "dcesrv_auth_request - frag_length too large");
+                        return dcesrv_fault(call,
+                                        DCERPC_NCA_S_PROTO_ERROR);
+                }
+                if (call->pkt.pfc_flags & DCERPC_PFC_FLAG_FIRST) {
+                        /* only one request is possible in the fragmented list */
+                        if (dce_conn->incoming_fragmented_call_list != NULL) {
+                                TALLOC_FREE(call);
+                                call = dce_conn->incoming_fragmented_call_list;
+                                dcesrv_call_disconnect_after(call,
+                                        "dcesrv_auth_request - "
+                                        "existing fragmented call");
+                                return dcesrv_fault(call,
+                                                DCERPC_NCA_S_PROTO_ERROR);
+                        }
+                        if (call->pkt.pfc_flags & DCERPC_PFC_FLAG_PENDING_CANCEL) {
+                                return dcesrv_fault_disconnect(call,
+                                                DCERPC_FAULT_NO_CALL_ACTIVE);
+                        }
+                } else {
+                        const struct dcerpc_request *nr = &call->pkt.u.request;
+                        const struct dcerpc_request *er = NULL;
+                        int cmp;
+                        existing = dcesrv_find_fragmented_call(dce_conn,
+                                                        call->pkt.call_id);
+                        if (existing == NULL) {
+                                dcesrv_call_disconnect_after(call,
+                                        "dcesrv_auth_request - "
+                                        "no existing fragmented call");
+                                return dcesrv_fault(call,
+                                                DCERPC_NCA_S_PROTO_ERROR);
+                        }
+                        er = &existing->pkt.u.request;
+                        if (call->pkt.ptype != existing->pkt.ptype) {
+                                /* trying to play silly buggers are we? */
+                                return dcesrv_fault_disconnect(existing,
+                                                DCERPC_NCA_S_PROTO_ERROR);
+                        }
+                        cmp = memcmp(call->pkt.drep, existing->pkt.drep,
+                                     sizeof(pkt->drep));
+                        if (cmp != 0) {
+                                return dcesrv_fault_disconnect(existing,
+                                                DCERPC_NCA_S_PROTO_ERROR);
+                        }
+                        if (nr->context_id != er->context_id)  {
+                                return dcesrv_fault_disconnect(existing,
+                                                DCERPC_NCA_S_PROTO_ERROR);
+                        }
+                        if (nr->opnum != er->opnum)  {
+                                return dcesrv_fault_disconnect(existing,
+                                                DCERPC_NCA_S_PROTO_ERROR);
+                        }
+                }
+                if (!dcesrv_auth_request(call, &blob)) {
+                        /*
+                         * We don't use dcesrv_fault_disconnect()
+                         * here, because we don't want to set
+                         * DCERPC_PFC_FLAG_DID_NOT_EXECUTE
+                         */
+                        dcesrv_call_disconnect_after(call,
+                                                "dcesrv_auth_request - failed");
+                        return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
+                }
+        }
         /* see if this is a continued packet */
+        if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
+            !(call->pkt.pfc_flags & DCERPC_PFC_FLAG_FIRST)) {
+                struct dcesrv_call_state *call2 = call;
+                uint32_t alloc_size;
+                /* we only allow fragmented requests, no other packet types */
+                if (call->pkt.ptype != DCERPC_PKT_REQUEST) {
+                        return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
+                }
+                /* this is a continuation of an existing call - find the call
+                   then tack it on the end */
+                call = dcesrv_find_fragmented_call(dce_conn, call2->pkt.call_id);
+                if (!call) {
+                        return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
+                }
+                if (call->pkt.ptype != call2->pkt.ptype) {
+                        /* trying to play silly buggers are we? */
+                        return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
+                }
+                alloc_size = call->pkt.u.request.stub_and_verifier.length +
+                        call2->pkt.u.request.stub_and_verifier.length;
+                if (call->pkt.u.request.alloc_hint > alloc_size) {
+                        alloc_size = call->pkt.u.request.alloc_hint;
+                }
+                call->pkt.u.request.stub_and_verifier.data =
+                        talloc_realloc(call,
+                                       call->pkt.u.request.stub_and_verifier.data,
+        if (existing != NULL) {
+                struct dcerpc_request *er = &existing->pkt.u.request;
+                const struct dcerpc_request *nr = &call->pkt.u.request;
+                size_t available;
+                size_t alloc_size;
+                size_t alloc_hint;
+                /*
+                 * Up to 4 MByte are allowed by all fragments
+                 */
+                available = DCERPC_NCACN_PAYLOAD_MAX_SIZE;
+                if (er->stub_and_verifier.length > available) {
+                        dcesrv_call_disconnect_after(existing,
+                                "dcesrv_auth_request - existing payload too large");
+                        return dcesrv_fault(existing, DCERPC_FAULT_ACCESS_DENIED);
+                }
+                available -= er->stub_and_verifier.length;
+                if (nr->alloc_hint > available) {
+                        dcesrv_call_disconnect_after(existing,
+                                "dcesrv_auth_request - alloc hint too large");
+                        return dcesrv_fault(existing, DCERPC_FAULT_ACCESS_DENIED);
+                }
+                if (nr->stub_and_verifier.length > available) {
+                        dcesrv_call_disconnect_after(existing,
+                                "dcesrv_auth_request - new payload too large");
+                        return dcesrv_fault(existing, DCERPC_FAULT_ACCESS_DENIED);
+                }
+                alloc_hint = er->stub_and_verifier.length + nr->alloc_hint;
+                /* allocate at least 1 byte */
+                alloc_hint = MAX(alloc_hint, 1);
+                alloc_size = er->stub_and_verifier.length +
+                             nr->stub_and_verifier.length;
+                alloc_size = MAX(alloc_size, alloc_hint);
+                er->stub_and_verifier.data =
+                        talloc_realloc(existing,
+                                       er->stub_and_verifier.data,
                                        uint8_t, alloc_size);
+                if (!call->pkt.u.request.stub_and_verifier.data) {
+                        return dcesrv_fault(call2, DCERPC_FAULT_OTHER);
+                }
+                memcpy(call->pkt.u.request.stub_and_verifier.data +
+                       call->pkt.u.request.stub_and_verifier.length,
+                       call2->pkt.u.request.stub_and_verifier.data,
+                       call2->pkt.u.request.stub_and_verifier.length);
+                call->pkt.u.request.stub_and_verifier.length +=
+                        call2->pkt.u.request.stub_and_verifier.length;
+                call->pkt.pfc_flags |= (call2->pkt.pfc_flags & DCERPC_PFC_FLAG_LAST);
+                talloc_free(call2);
+                if (er->stub_and_verifier.data == NULL) {
+                        TALLOC_FREE(call);
+                        return dcesrv_fault_with_flags(existing,
+                                                       DCERPC_FAULT_OUT_OF_RESOURCES,
+                                                       DCERPC_PFC_FLAG_DID_NOT_EXECUTE);
+                }
+                memcpy(er->stub_and_verifier.data +
+                       er->stub_and_verifier.length,
+                       nr->stub_and_verifier.data,
+                       nr->stub_and_verifier.length);
+                er->stub_and_verifier.length += nr->stub_and_verifier.length;
+                existing->pkt.pfc_flags |= (call->pkt.pfc_flags & DCERPC_PFC_FLAG_LAST);
+                TALLOC_FREE(call);
+                call = existing;
+        }
 …
         if (call->pkt.ptype == DCERPC_PKT_REQUEST &&
             !(call->pkt.pfc_flags & DCERPC_PFC_FLAG_LAST)) {
+                /*
+                 * Up to 4 MByte are allowed by all fragments
+                 */
+                if (call->pkt.u.request.alloc_hint > DCERPC_NCACN_PAYLOAD_MAX_SIZE) {
+                        dcesrv_call_disconnect_after(call,
+                                "dcesrv_auth_request - initial alloc hint too large");
+                        return dcesrv_fault(call, DCERPC_FAULT_ACCESS_DENIED);
+                }
                 dcesrv_call_set_list(call, DCESRV_LIST_FRAGMENTED_CALL_LIST);
                 return NT_STATUS_OK;
 …
         switch (call->pkt.ptype) {
         case DCERPC_PKT_BIND:
+                status = dcesrv_bind(call);
+                status = dcesrv_bind_nak(call,
+                        DCERPC_BIND_NAK_REASON_NOT_SPECIFIED);
                 break;
         case DCERPC_PKT_AUTH3:
 …
                 break;
         default:
                 status = NT_STATUS_INVALID_PARAMETER;
+                status = dcesrv_fault_disconnect(call, DCERPC_NCA_S_PROTO_ERROR);
                 break;
+        }
 …
+        }
         dce_ctx = talloc(mem_ctx, struct dcesrv_context);
+        dce_ctx = talloc_zero(mem_ctx, struct dcesrv_context);
         NT_STATUS_HAVE_NO_MEMORY(dce_ctx);
+        if (uid_wrapper_enabled()) {
+                setenv("UID_WRAPPER_MYUID", "1", 1);
+        }
+        dce_ctx->initial_euid = geteuid();
+        if (uid_wrapper_enabled()) {
+                unsetenv("UID_WRAPPER_MYUID");
+        }
         dce_ctx->endpoint_list  = NULL;
         dce_ctx->lp_ctx = lp_ctx;
         dce_ctx->assoc_groups_idr = idr_init(dce_ctx);
         NT_STATUS_HAVE_NO_MEMORY(dce_ctx->assoc_groups_idr);
+        dce_ctx->broken_connections = NULL;
         for (i=0;endpoint_servers[i];i++) {
 …
         initialized = true;
         shared_init = load_samba_modules(NULL, lp_ctx, "dcerpc_server");
+        shared_init = load_samba_modules(NULL, "dcerpc_server");
         run_init_functions(static_init);
 …
 static void dcesrv_terminate_connection(struct dcesrv_connection *dce_conn, const char *reason)
+{
+        struct dcesrv_context *dce_ctx = dce_conn->dce_ctx;
         struct stream_connection *srv_conn;
         srv_conn = talloc_get_type(dce_conn->transport.private_data,
                                    struct stream_connection);
+        stream_terminate_connection(srv_conn, reason);
+}
+        dce_conn->allow_bind = false;
+        dce_conn->allow_auth3 = false;
+        dce_conn->allow_alter = false;
+        dce_conn->allow_request = false;
+        if (dce_conn->pending_call_list == NULL) {
+                char *full_reason = talloc_asprintf(dce_conn, "dcesrv: %s", reason);
+                DLIST_REMOVE(dce_ctx->broken_connections, dce_conn);
+                stream_terminate_connection(srv_conn, full_reason ? full_reason : reason);
+                return;
+        }
+        if (dce_conn->terminate != NULL) {
+                return;
+        }
+        DEBUG(3,("dcesrv: terminating connection due to '%s' defered due to pending calls\n",
+                 reason));
+        dce_conn->terminate = talloc_strdup(dce_conn, reason);
+        if (dce_conn->terminate == NULL) {
+                dce_conn->terminate = "dcesrv: defered terminating connection - no memory";
+        }
+        DLIST_ADD_END(dce_ctx->broken_connections, dce_conn);
+}
+static void dcesrv_cleanup_broken_connections(struct dcesrv_context *dce_ctx)
+{
+        struct dcesrv_connection *cur, *next;
+        next = dce_ctx->broken_connections;
+        while (next != NULL) {
+                cur = next;
+                next = cur->next;
+                if (cur->state_flags & DCESRV_CALL_STATE_FLAG_PROCESS_PENDING_CALL) {
+                        struct dcesrv_connection_context *context_cur, *context_next;
+                        context_next = cur->contexts;
+                        while (context_next != NULL) {
+                                context_cur = context_next;
+                                context_next = context_cur->next;
+                                dcesrv_connection_context_destructor(context_cur);
+                        }
+                }
+                dcesrv_terminate_connection(cur, cur->terminate);
+        }
+}
 /* We need this include to be able to compile on some plateforms
  * (ie. freebsd 7.2) as it seems that <sys/uio.h> is not included
 …
 static void dcesrv_sock_reply_done(struct tevent_req *subreq);
+static void dcesrv_call_terminate_step1(struct tevent_req *subreq);
 static void dcesrv_sock_report_output_data(struct dcesrv_connection *dce_conn)
 …
                 struct tevent_req *subreq;
                 substate = talloc(call, struct dcesrv_sock_reply_state);
+                substate = talloc_zero(call, struct dcesrv_sock_reply_state);
                 if (!substate) {
                         dcesrv_terminate_connection(dce_conn, "no memory");
 …
                 DLIST_REMOVE(call->replies, rep);
                 if (call->replies == NULL) {
+                if (call->replies == NULL && call->terminate_reason == NULL) {
                         substate->call = call;
+                }
 …
+        }
+        if (call->terminate_reason != NULL) {
+                struct tevent_req *subreq;
+                subreq = tevent_queue_wait_send(call,
+                                                dce_conn->event_ctx,
+                                                dce_conn->send_queue);
+                if (!subreq) {
+                        dcesrv_terminate_connection(dce_conn, __location__);
+                        return;
+                }
+                tevent_req_set_callback(subreq, dcesrv_call_terminate_step1,
+                                        call);
+        }
         DLIST_REMOVE(call->conn->call_list, call);
         call->list = DCESRV_LIST_NONE;
 …
         TALLOC_FREE(subreq);
         if (ret == -1) {
                 status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 dcesrv_terminate_connection(substate->dce_conn, nt_errstr(status));
                 return;
 …
+}
+static void dcesrv_call_terminate_step2(struct tevent_req *subreq);
+static void dcesrv_call_terminate_step1(struct tevent_req *subreq)
+{
+        struct dcesrv_call_state *call = tevent_req_callback_data(subreq,
+                                                struct dcesrv_call_state);
+        bool ok;
+        struct timeval tv;
+        /* make sure we stop send queue before removing subreq */
+        tevent_queue_stop(call->conn->send_queue);
+        ok = tevent_queue_wait_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (!ok) {
+                dcesrv_terminate_connection(call->conn, __location__);
+                return;
+        }
+        /* disconnect after 200 usecs */
+        tv = timeval_current_ofs_usec(200);
+        subreq = tevent_wakeup_send(call, call->conn->event_ctx, tv);
+        if (subreq == NULL) {
+                dcesrv_terminate_connection(call->conn, __location__);
+                return;
+        }
+        tevent_req_set_callback(subreq, dcesrv_call_terminate_step2,
+                                call);
+}
+static void dcesrv_call_terminate_step2(struct tevent_req *subreq)
+{
+        struct dcesrv_call_state *call = tevent_req_callback_data(subreq,
+                                                struct dcesrv_call_state);
+        bool ok;
+        ok = tevent_wakeup_recv(subreq);
+        TALLOC_FREE(subreq);
+        if (!ok) {
+                dcesrv_terminate_connection(call->conn, __location__);
+                return;
+        }
+        dcesrv_terminate_connection(call->conn, call->terminate_reason);
+}
 struct dcesrv_socket_context {
 …
         struct dcesrv_socket_context *dcesrv_sock =
                 talloc_get_type(srv_conn->private_data, struct dcesrv_socket_context);
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dcesrv_sock->endpoint->ep_description);
         struct dcesrv_connection *dcesrv_conn = NULL;
         int ret;
         struct tevent_req *subreq;
         struct loadparm_context *lp_ctx = dcesrv_sock->dcesrv_ctx->lp_ctx;
+        dcesrv_cleanup_broken_connections(dcesrv_sock->dcesrv_ctx);
         if (!srv_conn->session_info) {
 …
+        }
         if (dcesrv_sock->endpoint->ep_description->transport == NCACN_NP) {
+        if (transport == NCACN_NP) {
                 dcesrv_conn->auth_state.session_key = dcesrv_inherited_session_key;
                 dcesrv_conn->stream = talloc_move(dcesrv_conn,
 …
                                                   &dcesrv_conn->stream);
                 if (ret == -1) {
                         status = map_nt_error_from_unix(errno);
+                        status = map_nt_error_from_unix_common(errno);
                         DEBUG(0, ("dcesrv_sock_accept: "
                                   "failed to setup tstream: %s\n",
 …
         dcesrv_conn->local_address = srv_conn->local_address;
         dcesrv_conn->remote_address = srv_conn->remote_address;
+        if (transport == NCALRPC) {
+                uid_t uid;
+                gid_t gid;
+                ret = getpeereid(socket_get_fd(srv_conn->socket), &uid, &gid);
+                if (ret == -1) {
+                        status = map_nt_error_from_unix_common(errno);
+                        DEBUG(0, ("dcesrv_sock_accept: "
+                                  "getpeereid() failed for NCALRPC: %s\n",
+                                  nt_errstr(status)));
+                        stream_terminate_connection(srv_conn, nt_errstr(status));
+                        return;
+                }
+                if (uid == dcesrv_conn->dce_ctx->initial_euid) {
+                        struct tsocket_address *r = NULL;
+                        ret = tsocket_address_unix_from_path(dcesrv_conn,
+                                                             "/root/ncalrpc_as_system",
+                                                             &r);
+                        if (ret == -1) {
+                                status = map_nt_error_from_unix_common(errno);
+                                DEBUG(0, ("dcesrv_sock_accept: "
+                                          "tsocket_address_unix_from_path() failed for NCALRPC: %s\n",
+                                          nt_errstr(status)));
+                                stream_terminate_connection(srv_conn, nt_errstr(status));
+                                return;
+                        }
+                        dcesrv_conn->remote_address = r;
+                }
+        }
         srv_conn->private_data = dcesrv_conn;
 …
         struct dcesrv_connection *dce_conn = tevent_req_callback_data(subreq,
                                              struct dcesrv_connection);
+        struct dcesrv_context *dce_ctx = dce_conn->dce_ctx;
         struct ncacn_packet *pkt;
         DATA_BLOB buffer;
         NTSTATUS status;
+        if (dce_conn->terminate) {
+                /*
+                 * if the current connection is broken
+                 * we need to clean it up before any other connection
+                 */
+                dcesrv_terminate_connection(dce_conn, dce_conn->terminate);
+                dcesrv_cleanup_broken_connections(dce_ctx);
+                return;
+        }
+        dcesrv_cleanup_broken_connections(dce_ctx);
         status = dcerpc_read_ncacn_packet_recv(subreq, dce_conn,
 …
         uint16_t port = 1;
         NTSTATUS status;
+        dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
+        const char *endpoint;
+        dcesrv_sock = talloc_zero(event_ctx, struct dcesrv_socket_context);
         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
 …
         dcesrv_sock->dcesrv_ctx         = talloc_reference(dcesrv_sock, dce_ctx);
+        endpoint = dcerpc_binding_get_string_option(e->ep_description, "endpoint");
         status = stream_setup_socket(dcesrv_sock, event_ctx, lp_ctx,
                                      model_ops, &dcesrv_stream_ops,
                                      "unix", e->ep_description->endpoint, &port,
+                                     "unix", endpoint, &port,
                                      lpcfg_socket_options(lp_ctx),
                                      dcesrv_sock);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("service_setup_stream_socket(path=%s) failed - %s\n",
                          e->ep_description->endpoint, nt_errstr(status)));
+                         endpoint, nt_errstr(status)));
+        }
 …
         char *full_path;
         NTSTATUS status;
+        if (!e->ep_description->endpoint) {
+                /* No identifier specified: use DEFAULT.
+                 * DO NOT hardcode this value anywhere else. Rather, specify
+                 * no endpoint and let the epmapper worry about it. */
+                e->ep_description->endpoint = talloc_strdup(dce_ctx, "DEFAULT");
+        const char *endpoint;
+        endpoint = dcerpc_binding_get_string_option(e->ep_description, "endpoint");
+        if (endpoint == NULL) {
+                /*
+                 * No identifier specified: use DEFAULT.
+                 *
+                 * TODO: DO NOT hardcode this value anywhere else. Rather, specify
+                 * no endpoint and let the epmapper worry about it.
+                 */
+                endpoint = "DEFAULT";
+                status = dcerpc_binding_set_string_option(e->ep_description,
+                                                          "endpoint",
+                                                          endpoint);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0,("dcerpc_binding_set_string_option() failed - %s\n",
+                                  nt_errstr(status)));
+                        return status;
+                }
+        }
         full_path = talloc_asprintf(dce_ctx, "%s/%s", lpcfg_ncalrpc_dir(lp_ctx),
                                     e->ep_description->endpoint);
         dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
+                                    endpoint);
+        dcesrv_sock = talloc_zero(event_ctx, struct dcesrv_socket_context);
         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
 …
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("service_setup_stream_socket(identifier=%s,path=%s) failed - %s\n",
                          e->ep_description->endpoint, full_path, nt_errstr(status)));
+                         endpoint, full_path, nt_errstr(status)));
+        }
         return status;
 …
         struct dcesrv_socket_context *dcesrv_sock;
         NTSTATUS status;
+        if (e->ep_description->endpoint == NULL) {
+        const char *endpoint;
+        endpoint = dcerpc_binding_get_string_option(e->ep_description, "endpoint");
+        if (endpoint == NULL) {
                 DEBUG(0, ("Endpoint mandatory for named pipes\n"));
                 return NT_STATUS_INVALID_PARAMETER;
+        }
         dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
+        dcesrv_sock = talloc_zero(event_ctx, struct dcesrv_socket_context);
         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
 …
         status = tstream_setup_named_pipe(dce_ctx, event_ctx, lp_ctx,
                                           model_ops, &dcesrv_stream_ops,
                                           e->ep_description->endpoint,
+                                          endpoint,
                                           dcesrv_sock);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("stream_setup_named_pipe(pipe=%s) failed - %s\n",
                          e->ep_description->endpoint, nt_errstr(status)));
+                         endpoint, nt_errstr(status)));
                 return status;
+        }
 …
         uint16_t port = 0;
         NTSTATUS status;
+        if (e->ep_description->endpoint) {
+                port = atoi(e->ep_description->endpoint);
+        }
+        dcesrv_sock = talloc(event_ctx, struct dcesrv_socket_context);
+        const char *endpoint;
+        char port_str[6];
+        endpoint = dcerpc_binding_get_string_option(e->ep_description, "endpoint");
+        if (endpoint != NULL) {
+                port = atoi(endpoint);
+        }
+        dcesrv_sock = talloc_zero(event_ctx, struct dcesrv_socket_context);
         NT_STATUS_HAVE_NO_MEMORY(dcesrv_sock);
 …
         status = stream_setup_socket(dcesrv_sock, event_ctx, dce_ctx->lp_ctx,
                                      model_ops, &dcesrv_stream_ops,
                                      "ipv4", address, &port,
+                                     "ip", address, &port,
                                      lpcfg_socket_options(dce_ctx->lp_ctx),
                                      dcesrv_sock);
 …
                 DEBUG(0,("service_setup_stream_socket(address=%s,port=%u) failed - %s\n",
                          address, port, nt_errstr(status)));
+        }
+        if (e->ep_description->endpoint == NULL) {
+                e->ep_description->endpoint = talloc_asprintf(dce_ctx, "%d", port);
+        }
+        return status;
+                return status;
+        }
+        snprintf(port_str, sizeof(port_str), "%u", port);
+        status = dcerpc_binding_set_string_option(e->ep_description,
+                                                  "endpoint", port_str);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,("dcerpc_binding_set_string_option(endpoint, %s) failed - %s\n",
+                         port_str, nt_errstr(status)));
+                return status;
+        }
+        return NT_STATUS_OK;
+}
 …
                 struct interface *ifaces;
                 load_interfaces(dce_ctx, lpcfg_interfaces(lp_ctx), &ifaces);
                 num_interfaces = iface_count(ifaces);
+                load_interface_list(dce_ctx, lp_ctx, &ifaces);
+                num_interfaces = iface_list_count(ifaces);
                 for(i = 0; i < num_interfaces; i++) {
                         const char *address = iface_n_ip(ifaces, i);
+                        const char *address = iface_list_n_ip(ifaces, i);
                         status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, address);
                         NT_STATUS_NOT_OK_RETURN(status);
+                }
         } else {
+                status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops,
+                                                  lpcfg_socket_address(lp_ctx));
+                NT_STATUS_NOT_OK_RETURN(status);
+                char **wcard;
+                int i;
+                int num_binds = 0;
+                wcard = iface_list_wildcard(dce_ctx);
+                NT_STATUS_HAVE_NO_MEMORY(wcard);
+                for (i=0; wcard[i]; i++) {
+                        status = add_socket_rpc_tcp_iface(dce_ctx, e, event_ctx, model_ops, wcard[i]);
+                        if (NT_STATUS_IS_OK(status)) {
+                                num_binds++;
+                        }
+                }
+                talloc_free(wcard);
+                if (num_binds == 0) {
+                        return NT_STATUS_INVALID_PARAMETER_MIX;
+                }
+        }
 …
                        const struct model_ops *model_ops)
+{
+        switch (e->ep_description->transport) {
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(e->ep_description);
+        switch (transport) {
         case NCACN_UNIX_STREAM:
                 return dcesrv_add_ep_unix(dce_ctx, lp_ctx, e, event_ctx, model_ops);

vendor/current/source4/rpc_server/dcerpc_server.h

-              r740
+              r988
 #define SAMBA_DCERPC_SERVER_H
 #include "librpc/gen_ndr/server_id4.h"
+#include "librpc/gen_ndr/server_id.h"
 #include "librpc/rpc/dcerpc.h"
 #include "librpc/ndr/libndr.h"
 …
 #define DCESRV_CALL_STATE_FLAG_ASYNC (1<<0)
 #define DCESRV_CALL_STATE_FLAG_MAY_ASYNC (1<<1)
+#define DCESRV_CALL_STATE_FLAG_HEADER_SIGNING (1<<2)
+#define DCESRV_CALL_STATE_FLAG_MULTIPLEXED (1<<3)
+#define DCESRV_CALL_STATE_FLAG_PROCESS_PENDING_CALL (1<<4)
         uint32_t state_flags;
 …
         /* the message_context that will be used for async replies */
         struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
         /* this is the pointer to the allocated function struct */
 …
         /* this is used by the boilerplate code to generate DCERPC faults */
         uint32_t fault_code;
+        /* the reason why we terminate the connection after sending a response */
+        const char *terminate_reason;
+        /* temporary auth_info fields */
+        struct dcerpc_auth in_auth_info;
+        struct dcerpc_auth _out_auth_info;
+        struct dcerpc_auth *out_auth_info;
 };
 …
 /* hold the authentication state information */
 struct dcesrv_auth {
+        struct dcerpc_auth *auth_info;
+        enum dcerpc_AuthType auth_type;
+        enum dcerpc_AuthLevel auth_level;
+        uint32_t auth_context_id;
         struct gensec_security *gensec_security;
         struct auth_session_info *session_info;
         NTSTATUS (*session_key)(struct dcesrv_connection *, DATA_BLOB *session_key);
+        bool client_hdr_signing;
+        bool hdr_signing;
+        bool auth_finished;
+        bool auth_invalid;
 };
 …
         uint32_t context_id;
+        /* TODO: remove this legacy (for openchange) in master */
         struct dcesrv_assoc_group *assoc_group;
 …
         /* private data for the interface implementation */
         void *private_data;
+        /*
+         * the minimum required auth level for this interface
+         */
+        enum dcerpc_AuthLevel min_auth_level;
+        bool allow_connect;
 };
 …
 /* the state associated with a dcerpc server connection */
 struct dcesrv_connection {
+        /* for the broken_connections DLIST */
+        struct dcesrv_connection *prev, *next;
         /* the top level context for this server */
         struct dcesrv_context *dce_ctx;
 …
         /* the maximum size the client wants to receive */
+        uint32_t cli_max_recv_frag;
+        uint16_t max_recv_frag;
+        uint16_t max_xmit_frag;
         DATA_BLOB partial_input;
+        /* the current authentication state */
+        struct dcesrv_auth auth_state;
+        /* This can be removed in master... */
+        struct  {
+                struct dcerpc_auth *auth_info;
+                struct gensec_security *gensec_security;
+                struct auth_session_info *session_info;
+                NTSTATUS (*session_key)(struct dcesrv_connection *, DATA_BLOB *session_key);
+                bool client_hdr_signing;
+                bool hdr_signing;
+        } _unused_auth_state;
         /* the event_context that will be used for this connection */
 …
         /* the message_context that will be used for this connection */
         struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
         /* the server_id that will be used for this connection */
 …
         DATA_BLOB transport_session_key;
+        bool processing;
+        /* is this connection pending termination?  If so, why? */
+        const char *terminate;
         const char *packet_log_dir;
 …
         const struct tsocket_address *local_address;
         const struct tsocket_address *remote_address;
+        /* the current authentication state */
+        struct dcesrv_auth auth_state;
+        /*
+         * remember which pdu types are allowed
+         */
+        bool allow_bind;
+        bool allow_auth3;
+        bool allow_alter;
+        bool allow_request;
+        /* the association group the connection belongs to */
+        struct dcesrv_assoc_group *assoc_group;
 };
 …
 /* server-wide context information for the dcerpc server */
 struct dcesrv_context {
+        /*
+         * The euid at startup time.
+         *
+         * This is required for DCERPC_AUTH_TYPE_NCALRPC_AS_SYSTEM
+         */
+        uid_t initial_euid;
         /* the list of endpoints that have registered
          * by the configured endpoint servers
 …
         struct idr_context *assoc_groups_idr;
+        struct dcesrv_connection *broken_connections;
 };
 …
                                  struct auth_session_info *session_info,
                                  struct tevent_context *event_ctx,
                                  struct messaging_context *msg_ctx,
+                                 struct imessaging_context *msg_ctx,
                                  struct server_id server_id,
                                  uint32_t state_flags,
 …
 _PUBLIC_ const char *dcesrv_call_account_name(struct dcesrv_call_state *dce_call);
+_PUBLIC_ NTSTATUS dcesrv_interface_bind_require_integrity(struct dcesrv_call_state *dce_call,
+                                                          const struct dcesrv_interface *iface);
+_PUBLIC_ NTSTATUS dcesrv_interface_bind_require_privacy(struct dcesrv_call_state *dce_call,
+                                                        const struct dcesrv_interface *iface);
+_PUBLIC_ NTSTATUS dcesrv_interface_bind_reject_connect(struct dcesrv_call_state *dce_call,
+                                                       const struct dcesrv_interface *iface);
+_PUBLIC_ NTSTATUS dcesrv_interface_bind_allow_connect(struct dcesrv_call_state *dce_call,
+                                                      const struct dcesrv_interface *iface);
 #endif /* SAMBA_DCERPC_SERVER_H */

vendor/current/source4/rpc_server/dcerpc_server.pc.in

r740	r988
3	3	libdir=@libdir@
4	4	includedir=@includedir@
	5	modulesdir=@modulesdir@/dcerpc_server
5	6
6	7	Name: dcerpc_server

vendor/current/source4/rpc_server/dcesrv_auth.c

-              r919
+              r988
 bool dcesrv_auth_bind(struct dcesrv_call_state *call)
+{
         struct cli_credentials *server_credentials;
+        struct cli_credentials *server_credentials = NULL;
         struct ncacn_packet *pkt = &call->pkt;
         struct dcesrv_connection *dce_conn = call->conn;
 …
         if (pkt->auth_length == 0) {
+                dce_conn->auth_state.auth_info = NULL;
+                auth->auth_type = DCERPC_AUTH_TYPE_NONE;
+                auth->auth_level = DCERPC_AUTH_LEVEL_NONE;
+                auth->auth_context_id = 0;
                 return true;
+        }
-        dce_conn->auth_state.auth_info = talloc(dce_conn, struct dcerpc_auth);
-        if (!dce_conn->auth_state.auth_info) {
-                return false;
+        }
         status = dcerpc_pull_auth_trailer(pkt, call, &pkt->u.bind.auth_info,
                                           dce_conn->auth_state.auth_info,
+                                          &call->in_auth_info,
                                           &auth_length, false);
+        if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        switch (call->in_auth_info.auth_level) {
+        case DCERPC_AUTH_LEVEL_CONNECT:
+        case DCERPC_AUTH_LEVEL_CALL:
+        case DCERPC_AUTH_LEVEL_PACKET:
+        case DCERPC_AUTH_LEVEL_INTEGRITY:
+        case DCERPC_AUTH_LEVEL_PRIVACY:
+                /*
+                 * We evaluate auth_type only if auth_level was valid
+                 */
+                break;
+        default:
+                /*
+                 * Setting DCERPC_AUTH_LEVEL_NONE,
+                 * gives the caller a chance to decide what
+                 * reject_reason to use
+                 *
+                 * Note: DCERPC_AUTH_LEVEL_NONE == 1
+                 */
+                auth->auth_type = DCERPC_AUTH_TYPE_NONE;
+                auth->auth_level = DCERPC_AUTH_LEVEL_NONE;
+                auth->auth_context_id = 0;
+                return false;
+        }
+        auth->auth_type = call->in_auth_info.auth_type;
+        auth->auth_level = call->in_auth_info.auth_level;
+        auth->auth_context_id = call->in_auth_info.auth_context_id;
         server_credentials
                 = cli_credentials_init(call);
 …
         status = cli_credentials_set_machine_account(server_credentials, call->conn->dce_ctx->lp_ctx);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(10, ("Failed to obtain server credentials, perhaps a standalone server?: %s\n", nt_errstr(status)));
                 talloc_free(server_credentials);
                 server_credentials = NULL;
+                DEBUG(1, ("Failed to obtain server credentials: %s\n",
+                          nt_errstr(status)));
+                return false;
+        }
 …
                                            NULL,
                                            &auth->gensec_security);
+        status = gensec_start_mech_by_authtype(auth->gensec_security, auth->auth_info->auth_type,
+                                               auth->auth_info->auth_level);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("Failed to call samba_server_gensec_start %s\n",
+                          nt_errstr(status)));
+                return false;
+        }
+        if (call->conn->remote_address != NULL) {
+                status = gensec_set_remote_address(auth->gensec_security,
+                                                call->conn->remote_address);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(1, ("Failed to call gensec_set_remote_address() %s\n",
+                                  nt_errstr(status)));
+                        return false;
+                }
+        }
+        status = gensec_start_mech_by_authtype(auth->gensec_security, auth->auth_type,
+                                               auth->auth_level);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(3, ("Failed to start GENSEC mechanism for DCERPC server: auth_type=%d, auth_level=%d: %s\n",
                           (int)auth->auth_info->auth_type,
                           (int)auth->auth_info->auth_level,
+                          (int)auth->auth_type,
+                          (int)auth->auth_level,
                           nt_errstr(status)));
                 return false;
+        }
-        if (call->conn->state_flags & DCESRV_CALL_STATE_FLAG_HEADER_SIGNING) {
-                gensec_want_feature(auth->gensec_security, GENSEC_FEATURE_SIGN_PKT_HEADER);
+        }
 …
         struct dcesrv_connection *dce_conn = call->conn;
         NTSTATUS status;
+        bool want_header_signing = false;
+        dce_conn->allow_alter = true;
+        dce_conn->allow_auth3 = true;
         if (call->pkt.auth_length == 0) {
+                dce_conn->auth_state.auth_finished = true;
+                dce_conn->allow_request = true;
                 return NT_STATUS_OK;
+        }
+        status = gensec_update(dce_conn->auth_state.gensec_security,
+                               call,
+                               dce_conn->auth_state.auth_info->credentials,
+                               &dce_conn->auth_state.auth_info->credentials);
+        /* We can't work without an existing gensec state */
+        if (!call->conn->auth_state.gensec_security) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        if (call->pkt.pfc_flags & DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN) {
+                dce_conn->auth_state.client_hdr_signing = true;
+                want_header_signing = true;
+        }
+        if (!lpcfg_parm_bool(call->conn->dce_ctx->lp_ctx, NULL, "dcesrv","header signing", true)) {
+                want_header_signing = false;
+        }
+        call->_out_auth_info = (struct dcerpc_auth) {
+                .auth_type = dce_conn->auth_state.auth_type,
+                .auth_level = dce_conn->auth_state.auth_level,
+                .auth_context_id = dce_conn->auth_state.auth_context_id,
+        };
+        call->out_auth_info = &call->_out_auth_info;
+        status = gensec_update_ev(dce_conn->auth_state.gensec_security,
+                               call, call->event_ctx,
+                               call->in_auth_info.credentials,
+                               &call->out_auth_info->credentials);
         if (NT_STATUS_IS_OK(status)) {
                 status = gensec_session_info(dce_conn->auth_state.gensec_security,
+                                             dce_conn,
                                              &dce_conn->auth_state.session_info);
                 if (!NT_STATUS_IS_OK(status)) {
 …
                         return status;
+                }
+                if (dce_conn->state_flags & DCESRV_CALL_STATE_FLAG_HEADER_SIGNING) {
+                dce_conn->auth_state.auth_finished = true;
+                dce_conn->allow_request = true;
+                if (!gensec_have_feature(dce_conn->auth_state.gensec_security,
+                                         GENSEC_FEATURE_SIGN_PKT_HEADER))
+                {
+                        want_header_signing = false;
+                }
+                if (want_header_signing) {
                         gensec_want_feature(dce_conn->auth_state.gensec_security,
                                             GENSEC_FEATURE_SIGN_PKT_HEADER);
+                        dce_conn->auth_state.hdr_signing = true;
+                        pkt->pfc_flags |= DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN;
+                }
 …
                 return NT_STATUS_OK;
         } else if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+                dce_conn->auth_state.auth_info->auth_pad_length = 0;
+                dce_conn->auth_state.auth_info->auth_reserved = 0;
+                if (!gensec_have_feature(dce_conn->auth_state.gensec_security,
+                                         GENSEC_FEATURE_SIGN_PKT_HEADER))
+                {
+                        want_header_signing = false;
+                }
+                if (want_header_signing) {
+                        gensec_want_feature(dce_conn->auth_state.gensec_security,
+                                            GENSEC_FEATURE_SIGN_PKT_HEADER);
+                        dce_conn->auth_state.hdr_signing = true;
+                        pkt->pfc_flags |= DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN;
+                }
                 return NT_STATUS_OK;
         } else {
 …
+        }
         if (!dce_conn->auth_state.auth_info) {
+        if (dce_conn->auth_state.auth_finished) {
                 return false;
+        }
 …
         status = dcerpc_pull_auth_trailer(pkt, call, &pkt->u.auth3.auth_info,
+                                          dce_conn->auth_state.auth_info, &auth_length, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+                                          &call->in_auth_info, &auth_length, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        if (call->in_auth_info.auth_type != dce_conn->auth_state.auth_type) {
+                return false;
+        }
+        if (call->in_auth_info.auth_level != dce_conn->auth_state.auth_level) {
+                return false;
+        }
+        if (call->in_auth_info.auth_context_id != dce_conn->auth_state.auth_context_id) {
+                return false;
+        }
+        call->_out_auth_info = (struct dcerpc_auth) {
+                .auth_type = dce_conn->auth_state.auth_type,
+                .auth_level = dce_conn->auth_state.auth_level,
+                .auth_context_id = dce_conn->auth_state.auth_context_id,
+        };
+        call->out_auth_info = &call->_out_auth_info;
         /* Pass the extra data we got from the client down to gensec for processing */
         status = gensec_update(dce_conn->auth_state.gensec_security,
                                call,
                                dce_conn->auth_state.auth_info->credentials,
                                &dce_conn->auth_state.auth_info->credentials);
+        status = gensec_update_ev(dce_conn->auth_state.gensec_security,
+                               call, call->event_ctx,
+                               call->in_auth_info.credentials,
+                               &call->out_auth_info->credentials);
         if (NT_STATUS_IS_OK(status)) {
                 status = gensec_session_info(dce_conn->auth_state.gensec_security,
+                                             dce_conn,
                                              &dce_conn->auth_state.session_info);
                 if (!NT_STATUS_IS_OK(status)) {
 …
                         return false;
+                }
+                dce_conn->auth_state.auth_finished = true;
+                dce_conn->allow_request = true;
                 /* Now that we are authenticated, go back to the generic session key... */
                 dce_conn->auth_state.session_key = dcesrv_generic_session_key;
+                if (call->out_auth_info->credentials.length != 0) {
+                        DEBUG(4, ("GENSEC produced output token (len=%u) at bind_auth3\n",
+                                  (unsigned)call->out_auth_info->credentials.length));
+                        return false;
+                }
                 return true;
         } else {
 …
         /* on a pure interface change there is no auth blob */
         if (pkt->auth_length == 0) {
+                if (!dce_conn->auth_state.auth_finished) {
+                        return false;
+                }
                 return true;
+        }
+        if (dce_conn->auth_state.auth_finished) {
+                return false;
+        }
 …
+        }
-        dce_conn->auth_state.auth_info = talloc(dce_conn, struct dcerpc_auth);
-        if (!dce_conn->auth_state.auth_info) {
-                return false;
+        }
         status = dcerpc_pull_auth_trailer(pkt, call, &pkt->u.alter.auth_info,
+                                          dce_conn->auth_state.auth_info,
+                                          &auth_length, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                                          &call->in_auth_info, &auth_length, true);
+        if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        if (call->in_auth_info.auth_type != dce_conn->auth_state.auth_type) {
+                return false;
+        }
+        if (call->in_auth_info.auth_level != dce_conn->auth_state.auth_level) {
+                return false;
+        }
+        if (call->in_auth_info.auth_context_id != dce_conn->auth_state.auth_context_id) {
                 return false;
+        }
 …
         if (!call->conn->auth_state.gensec_security) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        status = gensec_update(dce_conn->auth_state.gensec_security,
+                               call,
+                               dce_conn->auth_state.auth_info->credentials,
+                               &dce_conn->auth_state.auth_info->credentials);
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        call->_out_auth_info = (struct dcerpc_auth) {
+                .auth_type = dce_conn->auth_state.auth_type,
+                .auth_level = dce_conn->auth_state.auth_level,
+                .auth_context_id = dce_conn->auth_state.auth_context_id,
+        };
+        call->out_auth_info = &call->_out_auth_info;
+        status = gensec_update_ev(dce_conn->auth_state.gensec_security,
+                               call, call->event_ctx,
+                               call->in_auth_info.credentials,
+                               &call->out_auth_info->credentials);
         if (NT_STATUS_IS_OK(status)) {
                 status = gensec_session_info(dce_conn->auth_state.gensec_security,
+                                             dce_conn,
                                              &dce_conn->auth_state.session_info);
                 if (!NT_STATUS_IS_OK(status)) {
 …
                         return status;
+                }
+                dce_conn->auth_state.auth_finished = true;
+                dce_conn->allow_request = true;
                 /* Now that we are authenticated, got back to the generic session key... */
 …
                 return NT_STATUS_OK;
         } else if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
-                dce_conn->auth_state.auth_info->auth_pad_length = 0;
-                dce_conn->auth_state.auth_info->auth_reserved = 0;
                 return NT_STATUS_OK;
+        }
 …
         struct ncacn_packet *pkt = &call->pkt;
         struct dcesrv_connection *dce_conn = call->conn;
-        struct dcerpc_auth auth;
         NTSTATUS status;
         uint32_t auth_length;
         size_t hdr_size = DCERPC_REQUEST_LENGTH;
+        if (!dce_conn->auth_state.auth_info ||
+            !dce_conn->auth_state.gensec_security) {
+                return true;
+        if (!dce_conn->allow_request) {
+                return false;
+        }
+        if (dce_conn->auth_state.auth_invalid) {
+                return false;
+        }
 …
+        }
         switch (dce_conn->auth_state.auth_info->auth_level) {
+        switch (dce_conn->auth_state.auth_level) {
         case DCERPC_AUTH_LEVEL_PRIVACY:
         case DCERPC_AUTH_LEVEL_INTEGRITY:
 …
+        }
+        if (pkt->auth_length == 0) {
+                DEBUG(1,("dcesrv_auth_request: unexpected auth_length of 0\n"));
+        if (!dce_conn->auth_state.gensec_security) {
                 return false;
+        }
 …
         status = dcerpc_pull_auth_trailer(pkt, call,
                                           &pkt->u.request.stub_and_verifier,
+                                          &auth, &auth_length, false);
+        if (!NT_STATUS_IS_OK(status)) {
+                                          &call->in_auth_info, &auth_length, false);
+        if (!NT_STATUS_IS_OK(status)) {
+                return false;
+        }
+        if (call->in_auth_info.auth_type != dce_conn->auth_state.auth_type) {
+                return false;
+        }
+        if (call->in_auth_info.auth_level != dce_conn->auth_state.auth_level) {
+                return false;
+        }
+        if (call->in_auth_info.auth_context_id != dce_conn->auth_state.auth_context_id) {
                 return false;
+        }
 …
         /* check signature or unseal the packet */
         switch (dce_conn->auth_state.auth_info->auth_level) {
+        switch (dce_conn->auth_state.auth_level) {
         case DCERPC_AUTH_LEVEL_PRIVACY:
                 status = gensec_unseal_packet(dce_conn->auth_state.gensec_security,
-                                              call,
                                               full_packet->data + hdr_size,
                                               pkt->u.request.stub_and_verifier.length,
                                               full_packet->data,
+                                              full_packet->length-auth.credentials.length,
+                                              &auth.credentials);
+                                              full_packet->length-
+                                              call->in_auth_info.credentials.length,
+                                              &call->in_auth_info.credentials);
                 memcpy(pkt->u.request.stub_and_verifier.data,
                        full_packet->data + hdr_size,
 …
         case DCERPC_AUTH_LEVEL_INTEGRITY:
                 status = gensec_check_packet(dce_conn->auth_state.gensec_security,
-                                             call,
                                              pkt->u.request.stub_and_verifier.data,
                                              pkt->u.request.stub_and_verifier.length,
                                              full_packet->data,
+                                             full_packet->length-auth.credentials.length,
+                                             &auth.credentials);
+                                             full_packet->length-
+                                             call->in_auth_info.credentials.length,
+                                             &call->in_auth_info.credentials);
                 break;
 …
         /* remove the indicated amount of padding */
         if (pkt->u.request.stub_and_verifier.length < auth.auth_pad_length) {
                 return false;
+        }
         pkt->u.request.stub_and_verifier.length -= auth.auth_pad_length;
+        if (pkt->u.request.stub_and_verifier.length < call->in_auth_info.auth_pad_length) {
+                return false;
+        }
+        pkt->u.request.stub_and_verifier.length -= call->in_auth_info.auth_pad_length;
         return NT_STATUS_IS_OK(status);
 …
         DATA_BLOB creds2;
+        /* non-signed packets are simple */
+        if (sig_size == 0) {
+                status = ncacn_push_auth(blob, call, pkt, NULL);
+                return NT_STATUS_IS_OK(status);
+        }
+        switch (dce_conn->auth_state.auth_info->auth_level) {
+        switch (dce_conn->auth_state.auth_level) {
         case DCERPC_AUTH_LEVEL_PRIVACY:
         case DCERPC_AUTH_LEVEL_INTEGRITY:
+                if (sig_size == 0) {
+                        return false;
+                }
                 break;
 …
+        }
+        if (!dce_conn->auth_state.gensec_security) {
+                return false;
+        }
         ndr = ndr_push_init_ctx(call);
         if (!ndr) {
 …
                 return false;
+        }
+        call->_out_auth_info = (struct dcerpc_auth) {
+                .auth_type = dce_conn->auth_state.auth_type,
+                .auth_level = dce_conn->auth_state.auth_level,
+                .auth_context_id = dce_conn->auth_state.auth_context_id,
+        };
+        call->out_auth_info = &call->_out_auth_info;
         /* pad to 16 byte multiple in the payload portion of the
 …
            whole packet, whereas w2k8 wants it relative to the start
            of the stub */
+        dce_conn->auth_state.auth_info->auth_pad_length =
+                (16 - (pkt->u.response.stub_and_verifier.length & 15)) & 15;
+        ndr_err = ndr_push_zero(ndr,
+                                dce_conn->auth_state.auth_info->auth_pad_length);
+        call->out_auth_info->auth_pad_length =
+                DCERPC_AUTH_PAD_LENGTH(pkt->u.response.stub_and_verifier.length);
+        ndr_err = ndr_push_zero(ndr, call->out_auth_info->auth_pad_length);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return false;
 …
         payload_length = pkt->u.response.stub_and_verifier.length +
+                dce_conn->auth_state.auth_info->auth_pad_length;
+        /* we start without signature, it will appended later */
+        dce_conn->auth_state.auth_info->credentials = data_blob(NULL, 0);
+                call->out_auth_info->auth_pad_length;
         /* add the auth verifier */
         ndr_err = ndr_push_dcerpc_auth(ndr, NDR_SCALARS|NDR_BUFFERS,
                                        dce_conn->auth_state.auth_info);
+                                       call->out_auth_info);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return false;
 …
         /* sign or seal the packet */
         switch (dce_conn->auth_state.auth_info->auth_level) {
+        switch (dce_conn->auth_state.auth_level) {
         case DCERPC_AUTH_LEVEL_PRIVACY:
                 status = gensec_seal_packet(dce_conn->auth_state.gensec_security,
 …
                 DEBUG(3,("dcesrv_auth_response: creds2.length[%u] != sig_size[%u] pad[%u] stub[%u]\n",
                          (unsigned)creds2.length, (uint32_t)sig_size,
                          (unsigned)dce_conn->auth_state.auth_info->auth_pad_length,
+                         (unsigned)call->out_auth_info->auth_pad_length,
                          (unsigned)pkt->u.response.stub_and_verifier.length));
                 dcerpc_set_frag_length(blob, blob->length + creds2.length);

vendor/current/source4/rpc_server/dcesrv_mgmt.c

-              r414
+              r988
 #include "rpc_server/dcerpc_server.h"
 #include "librpc/gen_ndr/ndr_mgmt.h"
+#define DCESRV_INTERFACE_MGMT_BIND(call, iface) \
+       dcesrv_interface_mgmt_bind(call, iface)
+static NTSTATUS dcesrv_interface_mgmt_bind(struct dcesrv_call_state *dce_call,
+                                             const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_allow_connect(dce_call, iface);
+}
 /*

vendor/current/source4/rpc_server/drsuapi/addentry.c

-              r740
+              r988
                                  dn, LDB_SCOPE_BASE, attrs,
                                  "(objectClass=ntDSDSA)");
                 if (ret != LDB_SUCCESS || res->count < 1) {
+                if (ret != LDB_SUCCESS) {
                         DEBUG(0,(__location__ ": Failed to find dn '%s'\n", dn_string));
                         return WERR_DS_DRA_INTERNAL_ERROR;
+                }
+                if (res->count < 1) {
+                        /* we only add SPNs for nTDSDSA objects */
+                        continue;
+                }
 …
                                                     first_object,
                                                     &num,
+                                                    DSDB_REPL_FLAG_ADD_NCNAME,
                                                     &ids);
                 if (!W_ERROR_IS_OK(status)) {

vendor/current/source4/rpc_server/drsuapi/dcesrv_drsuapi.c

-              r740
+              r988
 #include "rpc_server/common/common.h"
 #include "dsdb/samdb/samdb.h"
+#include "dsdb/common/util.h"
 #include "libcli/security/security.h"
 #include "libcli/security/session.h"
 …
         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR); \
 } while (0)
+#define DCESRV_INTERFACE_DRSUAPI_BIND(call, iface) \
+        dcesrv_interface_drsuapi_bind(call, iface)
+static NTSTATUS dcesrv_interface_drsuapi_bind(struct dcesrv_call_state *dce_call,
+                                              const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_require_privacy(dce_call, iface);
+}
 /*
 …
          * lookup the local servers Replication Epoch
          */
         ntds_dn = samdb_ntds_settings_dn(b_state->sam_ctx);
+        ntds_dn = samdb_ntds_settings_dn(b_state->sam_ctx, mem_ctx);
         W_ERROR_HAVE_NO_MEMORY(ntds_dn);
 …
          * allocate the return bind_info
          */
         bind_info = talloc(mem_ctx, struct drsuapi_DsBindInfoCtr);
+        bind_info = talloc_zero(mem_ctx, struct drsuapi_DsBindInfoCtr);
         W_ERROR_HAVE_NO_MEMORY(bind_info);
 …
                 case 1: {
                         switch(r->in.req->req1.format_offered){
-                        case DRSUAPI_DS_NAME_FORMAT_UPN_AND_ALTSECID:
                         case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT_NAME_SANS_DOMAIN_EX:
+                        case DRSUAPI_DS_NAME_FORMAT_LIST_GLOBAL_CATALOG_SERVERS:
+                        case DRSUAPI_DS_NAME_FORMAT_UPN_FOR_LOGON:
+                        case DRSUAPI_DS_NAME_FORMAT_LIST_SERVERS_WITH_DCS_IN_SITE:
+                        case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT_NAME_SANS_DOMAIN:
                         case DRSUAPI_DS_NAME_FORMAT_STRING_SID_NAME:
                         case DRSUAPI_DS_NAME_FORMAT_ALT_SECURITY_IDENTITIES_NAME:
+                        case DRSUAPI_DS_NAME_FORMAT_MAP_SCHEMA_GUID:
                         case DRSUAPI_DS_NAME_FORMAT_LIST_NCS:
                         case DRSUAPI_DS_NAME_FORMAT_LIST_DOMAINS:
+                        case DRSUAPI_DS_NAME_FORMAT_MAP_SCHEMA_GUID:
+                        case DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT_NAME_SANS_DOMAIN:
+                        case DRSUAPI_DS_NAME_FORMAT_LIST_INFO_FOR_SERVER:
+                        case DRSUAPI_DS_NAME_FORMAT_LIST_GLOBAL_CATALOG_SERVERS:
+                        case DRSUAPI_DS_NAME_FORMAT_LIST_SERVERS_WITH_DCS_IN_SITE:
                         case DRSUAPI_DS_NAME_FORMAT_LIST_SERVERS_FOR_DOMAIN_IN_SITE:
                         case DRSUAPI_DS_NAME_FORMAT_LIST_DOMAINS_IN_SITE:
                         case DRSUAPI_DS_NAME_FORMAT_LIST_SERVERS_IN_SITE:
                         case DRSUAPI_DS_NAME_FORMAT_LIST_SITES:
+                        case DRSUAPI_DS_NAME_FORMAT_UPN_AND_ALTSECID:
+                        case DRSUAPI_DS_NAME_FORMAT_UPN_FOR_LOGON:
                                 DEBUG(0, ("DsCrackNames: Unsupported operation requested: %X",
                                           r->in.req->req1.format_offered));
                                 return WERR_OK;
+                        case DRSUAPI_DS_NAME_FORMAT_LIST_INFO_FOR_SERVER:
+                                return dcesrv_drsuapi_ListInfoServer(b_state->sam_ctx, mem_ctx, &r->in.req->req1, &r->out.ctr->ctr1);
                         case DRSUAPI_DS_NAME_FORMAT_LIST_ROLES:
                                 return dcesrv_drsuapi_ListRoles(b_state->sam_ctx, mem_ctx,
 …
                 if (r->in.req->req1.commit) {
                         ret = ldb_delete(b_state->sam_ctx, ntds_dn);
+                        ret = dsdb_delete(b_state->sam_ctx, ntds_dn, DSDB_TREE_DELETE);
                         if (ret != LDB_SUCCESS) {
                                 return WERR_FOOBAR;
 …
         *r->out.level_out = r->in.req->req1.level;
         r->out.ctr = talloc(mem_ctx, union drsuapi_DsGetDCInfoCtr);
+        r->out.ctr = talloc_zero(mem_ctx, union drsuapi_DsGetDCInfoCtr);
         W_ERROR_HAVE_NO_MEMORY(r->out.ctr);
-        sites_dn = samdb_sites_dn(b_state->sam_ctx, mem_ctx);
-        if (!sites_dn) {
-                return WERR_DS_OBJ_NOT_FOUND;
+        }
         switch (*r->out.level_out) {
 …
+        }
+        sites_dn = samdb_sites_dn(b_state->sam_ctx, mem_ctx);
+        if (!sites_dn) {
+                return WERR_DS_OBJ_NOT_FOUND;
+        }
         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res, sites_dn, LDB_SCOPE_SUBTREE, attrs,
                                  "objectClass=server");
+                                 "(&(objectClass=server)(serverReference=*))");
         if (ret) {
 …
                         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_account, ref_dn,
+                                                 LDB_SCOPE_BASE, attrs_account_1, "objectClass=computer");
+                                                 LDB_SCOPE_BASE, attrs_account_1,
+                                                "(&(objectClass=computer)(userAccountControl:1.2.840.113556.1.4.803:=%u))",
+                                                UF_SERVER_TRUST_ACCOUNT);
                         if (ret == LDB_SUCCESS && res_account->count == 1) {
                                 const char *errstr;
 …
+                }
                 break;
+        default:
+                return WERR_UNKNOWN_LEVEL;
+        }
         return WERR_OK;
 …
+{
         WERROR status;
+        uint32_t timeout;
         status = drs_security_level_check(dce_call, "DsExecuteKCC", SECURITY_DOMAIN_CONTROLLER, NULL);
 …
                 return status;
+        }
+        if (r->in.req->ctr1.taskID != 0) {
+                return WERR_INVALID_PARAM;
+        }
+        if (r->in.req->ctr1.flags & DRSUAPI_DS_EXECUTE_KCC_ASYNCHRONOUS_OPERATION) {
+                timeout = IRPC_CALL_TIMEOUT;
+        } else {
+                /*
+                 * use Infinite time for timeout in case
+                 * the caller made a sync call
+                 */
+                timeout = IRPC_CALL_TIMEOUT_INF;
+        }
         dcesrv_irpc_forward_rpc_call(dce_call, mem_ctx, r, NDR_DRSUAPI_DSEXECUTEKCC,
                                      &ndr_table_drsuapi, "kccsrv", "DsExecuteKCC",
+                                     IRPC_CALL_TIMEOUT);
+                                     timeout);
+        DEBUG(0, ("Forwarded the call to execute the KCC\n"));
         return WERR_OK;
+}

vendor/current/source4/rpc_server/drsuapi/drsutil.c

-              r740
+              r988
 #include "param/param.h"
 #include "auth/session.h"
+#include "rpc_server/drsuapi/dcesrv_drsuapi.h"
 int drsuapi_search_with_extended_dn(struct ldb_context *ldb,
 …
                 return WERR_DS_DRA_ACCESS_DENIED;
         } else if (ret != LDB_SUCCESS) {
                 DEBUG(1,("Failed to perform access check on %s\n", ldb_dn_get_linearized(dn)));
+                DEBUG(1,("Failed to perform access check on %s: %s\n", ldb_dn_get_linearized(dn), ldb_strerror(ret)));
                 return WERR_DS_DRA_INTERNAL_ERROR;
+        }

vendor/current/source4/rpc_server/drsuapi/getncchanges.c

-              r740
+              r988
 #include "dsdb/common/util.h"
+/* state of a partially completed getncchanges call */
+struct drsuapi_getncchanges_state {
+        struct GUID *guids;
+        uint32_t num_records;
+        uint32_t num_processed;
+        struct ldb_dn *ncRoot_dn;
+        bool is_schema_nc;
+        uint64_t min_usn;
+        uint64_t max_usn;
+        struct drsuapi_DsReplicaHighWaterMark last_hwm;
+        struct ldb_dn *last_dn;
+        struct drsuapi_DsReplicaHighWaterMark final_hwm;
+        struct drsuapi_DsReplicaCursor2CtrEx *final_udv;
+        struct drsuapi_DsReplicaLinkedAttribute *la_list;
+        uint32_t la_count;
+        bool la_sorted;
+        uint32_t la_idx;
+};
+static int drsuapi_DsReplicaHighWaterMark_cmp(const struct drsuapi_DsReplicaHighWaterMark *h1,
+                                              const struct drsuapi_DsReplicaHighWaterMark *h2)
+{
+        if (h1->highest_usn < h2->highest_usn) {
+                return -1;
+        } else if (h1->highest_usn > h2->highest_usn) {
+                return 1;
+        } else if (h1->tmp_highest_usn < h2->tmp_highest_usn) {
+                return -1;
+        } else if (h1->tmp_highest_usn > h2->tmp_highest_usn) {
+                return 1;
+        } else if (h1->reserved_usn < h2->reserved_usn) {
+                return -1;
+        } else if (h1->reserved_usn > h2->reserved_usn) {
+                return 1;
+        }
+        return 0;
+}
 /*
   build a DsReplicaObjectIdentifier from a ldb msg
 …
                                           struct drsuapi_DsPartialAttributeSet *partial_attribute_set,
                                           struct drsuapi_DsReplicaCursorCtrEx *uptodateness_vector,
+                                          enum drsuapi_DsExtendedOperation extended_op)
+                                          enum drsuapi_DsExtendedOperation extended_op,
+                                          bool force_object_return)
+{
         const struct ldb_val *md_value;
 …
         /* ignore it if its an empty change. Note that renames always
          * change the 'name' attribute, so they won't be ignored by
+         * this */
+         * this
+         * the force_object_return check is used to force an empty
+         * object return when we timeout in the getncchanges loop.
+         * This allows us to return an empty object, which keeps the
+         * client happy while preventing timeouts
+         */
         if (n == 0 ||
+            (n == 1 && attids[0] == DRSUAPI_ATTID_instanceType)) {
+            (n == 1 &&
+             attids[0] == DRSUAPI_ATTID_instanceType &&
+             !force_object_return)) {
                 talloc_free(obj->meta_data_ctr);
                 obj->meta_data_ctr = NULL;
 …
         obj->object.attribute_ctr.attributes = talloc_array(obj, struct drsuapi_DsReplicaAttribute,
                                                             obj->object.attribute_ctr.num_attributes);
+        if (obj->object.attribute_ctr.attributes == NULL) {
+                return WERR_NOMEM;
+        }
         /*
 …
                                                           &obj->object.attribute_ctr.attributes[i]);
                         if (!W_ERROR_IS_OK(werr)) {
+                                DEBUG(0,("Unable to convert %s to DRS object - %s\n",
+                                         sa->lDAPDisplayName, win_errstr(werr)));
+                                DEBUG(0,("Unable to convert %s on %s to DRS object - %s\n",
+                                         sa->lDAPDisplayName, ldb_dn_get_linearized(msg->dn),
+                                         win_errstr(werr)));
                                 return werr;
+                        }
 …
                                                          &obj->object.attribute_ctr.attributes[i]);
                         if (!W_ERROR_IS_OK(werr)) {
+                                DEBUG(0,("Unable to encrypt %s in DRS object - %s\n",
+                                         sa->lDAPDisplayName, win_errstr(werr)));
+                                DEBUG(0,("Unable to encrypt %s on %s in DRS object - %s\n",
+                                         sa->lDAPDisplayName, ldb_dn_get_linearized(msg->dn),
+                                         win_errstr(werr)));
                                 return werr;
+                        }
+                }
+                if (attids[i] != obj->object.attribute_ctr.attributes[i].attid) {
+                        DEBUG(0, ("Unable to replicate attribute %s on %s via DRS, incorrect attributeID:  "
+                                  "0x%08x vs 0x%08x "
+                                  "Run dbcheck!\n",
+                                  sa->lDAPDisplayName,
+                                  ldb_dn_get_linearized(msg->dn),
+                                  attids[i],
+                                  obj->object.attribute_ctr.attributes[i].attid));
+                        return WERR_DS_DATABASE_ERROR;
+                }
+        }
         return WERR_OK;
+}
 /*
 …
         active = (dsdb_dn_rmd_flags(dsdb_dn->dn) & DSDB_RMD_FLAG_DELETED) == 0;
+        if (!active) {
+                /* We have to check that the inactive link still point to an existing object */
+                struct GUID guid;
+                struct ldb_dn *tdn;
+                int ret;
+                const char *v;
+                v = ldb_msg_find_attr_as_string(msg, "isDeleted", "FALSE");
+                if (strncmp(v, "TRUE", 4) == 0) {
+                        /*
+                          * Note: we skip the transmition of the deleted link even if the other part used to
+                          * know about it because when we transmit the deletion of the object, the link will
+                          * be deleted too due to deletion of object where link points and Windows do so.
+                          */
+                        if (dsdb_functional_level(sam_ctx) >= DS_DOMAIN_FUNCTION_2008_R2) {
+                                v = ldb_msg_find_attr_as_string(msg, "isRecycled", "FALSE");
+                                /*
+                                 * On Windows 2008R2 isRecycled is always present even if FL or DL are < FL 2K8R2
+                                 * if it join an existing domain with deleted objets, it firsts impose to have a
+                                 * schema with the is-Recycled object and for all deleted objects it adds the isRecycled
+                                 * either during initial replication or after the getNCChanges.
+                                 * Behavior of samba has been changed to always have this attribute if it's present in the schema.
+                                 *
+                                 * So if FL <2K8R2 isRecycled might be here or not but we don't care, it's meaning less.
+                                 * If FL >=2K8R2 we are sure that this attribute will be here.
+                                 * For this kind of forest level we do not return the link if the object is recycled
+                                 * (isRecycled = true).
+                                 */
+                                if (strncmp(v, "TRUE", 4) == 0) {
+                                        DEBUG(2, (" object %s is recycled, not returning linked attribute !\n",
+                                                                ldb_dn_get_linearized(msg->dn)));
+                                        return WERR_OK;
+                                }
+                        } else {
+                                return WERR_OK;
+                        }
+                }
+                status = dsdb_get_extended_dn_guid(dsdb_dn->dn, &guid, "GUID");
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0,(__location__ " Unable to extract GUID in linked attribute '%s' in '%s'\n",
+                                sa->lDAPDisplayName, ldb_dn_get_linearized(msg->dn)));
+                        return ntstatus_to_werror(status);
+                }
+                ret = dsdb_find_dn_by_guid(sam_ctx, mem_ctx, &guid, 0, &tdn);
+                if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                        DEBUG(2, (" Search of guid %s returned 0 objects, skipping it !\n",
+                                                GUID_string(mem_ctx, &guid)));
+                        return WERR_OK;
+                } else if (ret != LDB_SUCCESS) {
+                        DEBUG(0, (__location__ " Search of guid %s failed with error code %d\n",
+                                                GUID_string(mem_ctx, &guid),
+                                                ret));
+                        return WERR_OK;
+                }
+        }
         la->attid = sa->attributeID_id;
         la->flags = active?DRSUAPI_DS_LINKED_ATTRIBUTE_FLAG_ACTIVE:0;
+        status = dsdb_get_extended_dn_uint32(dsdb_dn->dn, &la->meta_data.version, "RMD_VERSION");
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,(__location__ " No RMD_VERSION in linked attribute '%s' in '%s'\n",
+                         sa->lDAPDisplayName, ldb_dn_get_linearized(msg->dn)));
+                return ntstatus_to_werror(status);
+        }
+        status = dsdb_get_extended_dn_nttime(dsdb_dn->dn, &la->meta_data.originating_change_time, "RMD_CHANGETIME");
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,(__location__ " No RMD_CHANGETIME in linked attribute '%s' in '%s'\n",
+                         sa->lDAPDisplayName, ldb_dn_get_linearized(msg->dn)));
+                return ntstatus_to_werror(status);
+        }
+        status = dsdb_get_extended_dn_guid(dsdb_dn->dn, &la->meta_data.originating_invocation_id, "RMD_INVOCID");
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,(__location__ " No RMD_INVOCID in linked attribute '%s' in '%s'\n",
+                         sa->lDAPDisplayName, ldb_dn_get_linearized(msg->dn)));
+                return ntstatus_to_werror(status);
+        }
+        status = dsdb_get_extended_dn_uint64(dsdb_dn->dn, &la->meta_data.originating_usn, "RMD_ORIGINATING_USN");
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,(__location__ " No RMD_ORIGINATING_USN in linked attribute '%s' in '%s'\n",
+                         sa->lDAPDisplayName, ldb_dn_get_linearized(msg->dn)));
+                return ntstatus_to_werror(status);
+        }
         status = dsdb_get_extended_dn_nttime(dsdb_dn->dn, &la->originating_add_time, "RMD_ADDTIME");
         if (!NT_STATUS_IS_OK(status)) {
+                return ntstatus_to_werror(status);
+        }
+        status = dsdb_get_extended_dn_uint32(dsdb_dn->dn, &la->meta_data.version, "RMD_VERSION");
+        if (!NT_STATUS_IS_OK(status)) {
+                return ntstatus_to_werror(status);
+        }
+        status = dsdb_get_extended_dn_nttime(dsdb_dn->dn, &la->meta_data.originating_change_time, "RMD_CHANGETIME");
+        if (!NT_STATUS_IS_OK(status)) {
+                return ntstatus_to_werror(status);
+        }
+        status = dsdb_get_extended_dn_guid(dsdb_dn->dn, &la->meta_data.originating_invocation_id, "RMD_INVOCID");
+        if (!NT_STATUS_IS_OK(status)) {
+                return ntstatus_to_werror(status);
+        }
+        status = dsdb_get_extended_dn_uint64(dsdb_dn->dn, &la->meta_data.originating_usn, "RMD_ORIGINATING_USN");
+        if (!NT_STATUS_IS_OK(status)) {
+                return ntstatus_to_werror(status);
+                /* this is possible for upgraded links */
+                la->originating_add_time = la->meta_data.originating_change_time;
+        }
 …
+}
+struct drsuapi_changed_objects {
+        struct ldb_dn *dn;
+        struct GUID guid;
+        uint64_t usn;
+};
 /*
   sort the objects we send by tree order
  */
+static int site_res_cmp_parent_order(struct ldb_message **m1, struct ldb_message **m2)
+{
+        return ldb_dn_compare((*m2)->dn, (*m1)->dn);
+static int site_res_cmp_anc_order(struct drsuapi_changed_objects *m1,
+                                  struct drsuapi_changed_objects *m2,
+                                  struct drsuapi_getncchanges_state *getnc_state)
+{
+        return ldb_dn_compare(m2->dn, m1->dn);
+}
 …
   sort the objects we send first by uSNChanged
  */
+static int site_res_cmp_usn_order(struct ldb_message **m1, struct ldb_message **m2)
+{
+        unsigned usnchanged1, usnchanged2;
+        unsigned cn1, cn2;
+        cn1 = ldb_dn_get_comp_num((*m1)->dn);
+        cn2 = ldb_dn_get_comp_num((*m2)->dn);
+        if (cn1 != cn2) {
+                return cn1 > cn2 ? 1 : -1;
+        }
+        usnchanged1 = ldb_msg_find_attr_as_uint(*m1, "uSNChanged", 0);
+        usnchanged2 = ldb_msg_find_attr_as_uint(*m2, "uSNChanged", 0);
+        if (usnchanged1 == usnchanged2) {
+                return 0;
+        }
+        return usnchanged1 > usnchanged2 ? 1 : -1;
+static int site_res_cmp_usn_order(struct drsuapi_changed_objects *m1,
+                                  struct drsuapi_changed_objects *m2,
+                                  struct drsuapi_getncchanges_state *getnc_state)
+{
+        int ret;
+        ret = ldb_dn_compare(getnc_state->ncRoot_dn, m1->dn);
+        if (ret == 0) {
+                return -1;
+        }
+        ret = ldb_dn_compare(getnc_state->ncRoot_dn, m2->dn);
+        if (ret == 0) {
+                return 1;
+        }
+        if (m1->usn == m2->usn) {
+                return ldb_dn_compare(m2->dn, m1->dn);
+        }
+        if (m1->usn < m2->usn) {
+                return -1;
+        }
+        return 1;
+}
 …
                                      struct drsuapi_DsGetNCChangesCtr6 *ctr6)
+{
         struct ldb_dn *rid_manager_dn, *fsmo_role_dn, *req_dn;
+        struct ldb_dn *rid_manager_dn, *req_dn;
         int ret;
         struct ldb_context *ldb = b_state->sam_ctx;
         struct ldb_result *ext_res;
-        struct ldb_dn *base_dn;
         struct dsdb_fsmo_extended_op *exop;
+        bool is_us;
         /*
 …
         /* find the DN of the RID Manager */
         ret = samdb_reference_dn(ldb, mem_ctx, rid_manager_dn, "fSMORoleOwner", &fsmo_role_dn);
+        ret = samdb_reference_dn_is_our_ntdsa(ldb, rid_manager_dn, "fSMORoleOwner", &is_us);
         if (ret != LDB_SUCCESS) {
+                DEBUG(0,(__location__ ": Failed to find fSMORoleOwner in RID Manager object - %s\n",
+                         ldb_errstring(ldb)));
+                DEBUG(0,("Failed to find fSMORoleOwner in RID Manager object\n"));
                 ctr6->extended_ret = DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER;
                 return WERR_DS_DRA_INTERNAL_ERROR;
+        }
         if (ldb_dn_compare(samdb_ntds_settings_dn(ldb), fsmo_role_dn) != 0) {
+        if (!is_us) {
                 /* we're not the RID Manager - go away */
                 DEBUG(0,(__location__ ": RID Alloc request when not RID Manager\n"));
 …
         talloc_free(ext_res);
-        base_dn = ldb_get_default_basedn(ldb);
         DEBUG(2,("Allocated RID pool for server %s\n",
 …
                                        struct drsuapi_DsGetNCChangesRequest10 *req10,
                                        struct dom_sid *user_sid,
+                                       struct drsuapi_DsGetNCChangesCtr6 *ctr6)
+                                       struct drsuapi_DsGetNCChangesCtr6 *ctr6,
+                                       bool has_get_all_changes)
+{
         struct drsuapi_DsReplicaObjectIdentifier *ncRoot = req10->naming_context;
+        struct ldb_dn *obj_dn, *rodc_dn, *krbtgt_link_dn;
+        struct ldb_dn *obj_dn = NULL;
+        struct ldb_dn *rodc_dn, *krbtgt_link_dn;
         int ret;
         const char *rodc_attrs[] = { "msDS-KrbTgtLink", "msDS-NeverRevealGroup", "msDS-RevealOnDemandGroup", NULL };
 …
         /*
          * we need to work out if we will allow this RODC to
+         * we need to work out if we will allow this DC to
          * replicate the secrets for this object
+         *
 …
                 ctr6->extended_ret = DRSUAPI_EXOP_ERR_ACCESS_DENIED;
                 return WERR_DS_DRA_SOURCE_DISABLED;
+        }
+        /*
+         * In MS-DRSR.pdf 5.99 IsGetNCChangesPermissionGranted
+         *
+         * The pseudo code indicate
+         * revealsecrets = true
+         * if IsRevealSecretRequest(msgIn) then
+         *   if AccessCheckCAR(ncRoot, Ds-Replication-Get-Changes-All) = false
+         *   then
+         *     if (msgIn.ulExtendedOp = EXOP_REPL_SECRETS) then
+         *     <... check if this account is ok to be replicated on this DC ...>
+         *     <... and if not reveal secrets = no ...>
+         *     else
+         *       reveal secrets = false
+         *     endif
+         *   endif
+         * endif
+         *
+         * Which basically means that if you have GET_ALL_CHANGES rights (~== RWDC)
+         * then you can do EXOP_REPL_SECRETS
+         */
+        if (has_get_all_changes) {
+                goto allowed;
+        }
 …
         /* default deny */
 denied:
         DEBUG(2,(__location__ ": Denied RODC secret replication for %s by RODC %s\n",
+        DEBUG(2,(__location__ ": Denied single object with secret replication for %s by RODC %s\n",
                  ldb_dn_get_linearized(obj_dn), ldb_dn_get_linearized(rodc_res->msgs[0]->dn)));
         ctr6->extended_ret = DRSUAPI_EXOP_ERR_NONE;
 …
 allowed:
+        DEBUG(2,(__location__ ": Allowed RODC secret replication for %s by RODC %s\n",
+                 ldb_dn_get_linearized(obj_dn), ldb_dn_get_linearized(rodc_res->msgs[0]->dn)));
+        DEBUG(2,(__location__ ": Allowed single object with secret replication for %s by %s %s\n",
+                 ldb_dn_get_linearized(obj_dn), has_get_all_changes?"RWDC":"RODC",
+                 ldb_dn_get_linearized(rodc_res->msgs[0]->dn)));
         ctr6->extended_ret = DRSUAPI_EXOP_ERR_SUCCESS;
         req10->highwatermark.highest_usn = 0;
 …
 failed:
         DEBUG(2,(__location__ ": Failed RODC secret replication for %s by RODC %s\n",
+        DEBUG(2,(__location__ ": Failed single secret replication for %s by RODC %s\n",
                  ldb_dn_get_linearized(obj_dn), dom_sid_string(mem_ctx, user_sid)));
         ctr6->extended_ret = DRSUAPI_EXOP_ERR_NONE;
 …
         ctr6->extended_ret = DRSUAPI_EXOP_ERR_SUCCESS;
-        req10->highwatermark.highest_usn = 0;
         return WERR_OK;
+}
 …
                                          struct drsuapi_DsGetNCChangesCtr6 *ctr6)
+{
         struct ldb_dn *fsmo_role_dn, *req_dn, *ntds_dn;
+        struct ldb_dn *req_dn, *ntds_dn;
         int ret;
         unsigned int i;
         struct ldb_context *ldb = b_state->sam_ctx;
         struct ldb_message *msg;
+        bool is_us;
         /*
 …
+        }
         /* retrieve the current role owner */
         ret = samdb_reference_dn(ldb, mem_ctx, req_dn, "fSMORoleOwner", &fsmo_role_dn);
+        /* find the DN of the current role owner */
+        ret = samdb_reference_dn_is_our_ntdsa(ldb, req_dn, "fSMORoleOwner", &is_us);
         if (ret != LDB_SUCCESS) {
+                DEBUG(0,(__location__ ": Failed to find fSMORoleOwner in context - %s\n",
+                         ldb_errstring(ldb)));
+                DEBUG(0,("Failed to find fSMORoleOwner in RID Manager object\n"));
                 ctr6->extended_ret = DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER;
                 return WERR_DS_DRA_INTERNAL_ERROR;
+        }
         if (ldb_dn_compare(samdb_ntds_settings_dn(ldb), fsmo_role_dn) != 0) {
                 /* we're not the current owner - go away */
                 DEBUG(0,(__location__ ": FSMO transfer request when not owner\n"));
+        if (!is_us) {
+                /* we're not the RID Manager or role owner - go away */
+                DEBUG(0,(__location__ ": FSMO role or RID manager transfer owner request when not role owner\n"));
                 ctr6->extended_ret = DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER;
                 return WERR_OK;
 …
         W_ERROR_HAVE_NO_MEMORY(msg->dn);
+        ret = dsdb_find_dn_by_guid(ldb, msg, &req10->destination_dsa_guid, &ntds_dn);
+        /* TODO: make sure ntds_dn is a valid nTDSDSA object */
+        ret = dsdb_find_dn_by_guid(ldb, msg, &req10->destination_dsa_guid, 0, &ntds_dn);
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, (__location__ ": Unable to find NTDS object for guid %s - %s\n",
                           GUID_string(mem_ctx, &req10->destination_dsa_guid), ldb_errstring(ldb)));
                 talloc_free(msg);
+                return WERR_DS_DRA_INTERNAL_ERROR;
+                ctr6->extended_ret = DRSUAPI_EXOP_ERR_UNKNOWN_CALLER;
+                return WERR_OK;
+        }
 …
         return WERR_OK;
+}
-/* state of a partially completed getncchanges call */
-struct drsuapi_getncchanges_state {
-        struct GUID *guids;
-        uint32_t num_records;
-        uint32_t num_processed;
-        struct ldb_dn *ncRoot_dn;
-        bool is_schema_nc;
-        uint64_t min_usn;
-        uint64_t highest_usn;
-        struct ldb_dn *last_dn;
-        struct drsuapi_DsReplicaLinkedAttribute *la_list;
-        uint32_t la_count;
-        bool la_sorted;
-        uint32_t la_idx;
-        struct drsuapi_DsReplicaCursorCtrEx *uptodateness_vector;
-};
 /*
 …
+        }
+        if (req10->partial_attribute_set_ex) {
+                /* check the extended attributes they asked for */
+                for (i=0; i<req10->partial_attribute_set_ex->num_attids; i++) {
+                        const struct dsdb_attribute *sa;
+                        sa = dsdb_attribute_by_attributeID_id(schema, req10->partial_attribute_set_ex->attids[i]);
+                        if (sa == NULL) {
+                                return WERR_DS_DRA_SCHEMA_MISMATCH;
+                        }
+                        if (!dsdb_attr_in_rodc_fas(sa)) {
+                                *is_secret_request = true;
+                                return WERR_OK;
+                        }
+                }
+        }
+        *is_secret_request = false;
+        return WERR_OK;
+}
+/*
+  see if this getncchanges request is only for attributes in the GC
+  partial attribute set
+ */
+static WERROR dcesrv_drsuapi_is_gc_pas_request(struct drsuapi_bind_state *b_state,
+                                               struct drsuapi_DsGetNCChangesRequest10 *req10,
+                                               bool *is_gc_pas_request)
+{
+        enum drsuapi_DsExtendedOperation exop;
+        uint32_t i;
+        struct dsdb_schema *schema;
+        exop = req10->extended_op;
+        switch (exop) {
+        case DRSUAPI_EXOP_FSMO_REQ_ROLE:
+        case DRSUAPI_EXOP_FSMO_RID_ALLOC:
+        case DRSUAPI_EXOP_FSMO_RID_REQ_ROLE:
+        case DRSUAPI_EXOP_FSMO_REQ_PDC:
+        case DRSUAPI_EXOP_FSMO_ABANDON_ROLE:
+        case DRSUAPI_EXOP_REPL_SECRET:
+                *is_gc_pas_request = false;
+                return WERR_OK;
+        case DRSUAPI_EXOP_REPL_OBJ:
+        case DRSUAPI_EXOP_NONE:
+                break;
+        }
+        if (req10->partial_attribute_set == NULL) {
+                /* they want it all */
+                *is_gc_pas_request = false;
+                return WERR_OK;
+        }
+        schema = dsdb_get_schema(b_state->sam_ctx, NULL);
         /* check the attributes they asked for */
         for (i=0; i<req10->partial_attribute_set_ex->num_attids; i++) {
+        for (i=0; i<req10->partial_attribute_set->num_attids; i++) {
                 const struct dsdb_attribute *sa;
                 sa = dsdb_attribute_by_attributeID_id(schema, req10->partial_attribute_set_ex->attids[i]);
+                sa = dsdb_attribute_by_attributeID_id(schema, req10->partial_attribute_set->attids[i]);
                 if (sa == NULL) {
                         return WERR_DS_DRA_SCHEMA_MISMATCH;
+                }
                 if (!dsdb_attr_in_rodc_fas(sa)) {
                         *is_secret_request = true;
+                if (!sa->isMemberOfPartialAttributeSet) {
+                        *is_gc_pas_request = false;
                         return WERR_OK;
+                }
+        }
+        *is_secret_request = false;
+        if (req10->partial_attribute_set_ex) {
+                /* check the extended attributes they asked for */
+                for (i=0; i<req10->partial_attribute_set_ex->num_attids; i++) {
+                        const struct dsdb_attribute *sa;
+                        sa = dsdb_attribute_by_attributeID_id(schema, req10->partial_attribute_set_ex->attids[i]);
+                        if (sa == NULL) {
+                                return WERR_DS_DRA_SCHEMA_MISMATCH;
+                        }
+                        if (!sa->isMemberOfPartialAttributeSet) {
+                                *is_gc_pas_request = false;
+                                return WERR_OK;
+                        }
+                }
+        }
+        *is_gc_pas_request = true;
         return WERR_OK;
+}
 …
+/**
+ * Collects object for normal replication cycle.
+ */
+static WERROR getncchanges_collect_objects(struct drsuapi_bind_state *b_state,
+                                           TALLOC_CTX *mem_ctx,
+                                           struct drsuapi_DsGetNCChangesRequest10 *req10,
+                                           struct ldb_dn *search_dn,
+                                           const char *extra_filter,
+                                           struct ldb_result **search_res)
+{
+        int ret;
+        char* search_filter;
+        enum ldb_scope scope = LDB_SCOPE_SUBTREE;
+        //const char *extra_filter;
+        struct drsuapi_getncchanges_state *getnc_state = b_state->getncchanges_state;
+        const char *attrs[] = { "uSNChanged",
+                                "objectGUID" ,
+                                NULL };
+        if (req10->extended_op == DRSUAPI_EXOP_REPL_OBJ ||
+            req10->extended_op == DRSUAPI_EXOP_REPL_SECRET) {
+                scope = LDB_SCOPE_BASE;
+        }
+        //extra_filter = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "object filter");
+        //getnc_state->min_usn = req10->highwatermark.highest_usn;
+        /* Construct response. */
+        search_filter = talloc_asprintf(mem_ctx,
+                                        "(uSNChanged>=%llu)",
+                                        (unsigned long long)(getnc_state->min_usn+1));
+        if (extra_filter) {
+                search_filter = talloc_asprintf(mem_ctx, "(&%s(%s))", search_filter, extra_filter);
+        }
+        if (req10->replica_flags & DRSUAPI_DRS_CRITICAL_ONLY) {
+                search_filter = talloc_asprintf(mem_ctx,
+                                                "(&%s(isCriticalSystemObject=TRUE))",
+                                                search_filter);
+        }
+        if (req10->replica_flags & DRSUAPI_DRS_ASYNC_REP) {
+                scope = LDB_SCOPE_BASE;
+        }
+        if (!search_dn) {
+                search_dn = getnc_state->ncRoot_dn;
+        }
+        DEBUG(2,(__location__ ": getncchanges on %s using filter %s\n",
+                 ldb_dn_get_linearized(getnc_state->ncRoot_dn), search_filter));
+        ret = drsuapi_search_with_extended_dn(b_state->sam_ctx, getnc_state, search_res,
+                                              search_dn, scope, attrs,
+                                              search_filter);
+        if (ret != LDB_SUCCESS) {
+                return WERR_DS_DRA_INTERNAL_ERROR;
+        }
+        return WERR_OK;
+}
+/**
+ * Collects object for normal replication cycle.
+ */
+static WERROR getncchanges_collect_objects_exop(struct drsuapi_bind_state *b_state,
+                                                TALLOC_CTX *mem_ctx,
+                                                struct drsuapi_DsGetNCChangesRequest10 *req10,
+                                                struct drsuapi_DsGetNCChangesCtr6 *ctr6,
+                                                struct ldb_dn *search_dn,
+                                                const char *extra_filter,
+                                                struct ldb_result **search_res)
+{
+        /* we have nothing to do in case of ex-op failure */
+        if (ctr6->extended_ret != DRSUAPI_EXOP_ERR_SUCCESS) {
+                return WERR_OK;
+        }
+        /* TODO: implement extended op specific collection
+         * of objects. Right now we just normal procedure
+         * for collecting objects */
+        return getncchanges_collect_objects(b_state, mem_ctx, req10, search_dn, extra_filter, search_res);
+}
 /*
   drsuapi_DsGetNCChanges
 …
         NTSTATUS status;
         DATA_BLOB session_key;
-        const char *attrs[] = { "uSNChanged",
-                                "objectGUID" ,
-                                NULL };
         WERROR werr;
         struct dcesrv_handle *h;
 …
         struct dom_sid *user_sid;
         bool is_secret_request;
+        bool is_gc_pas_request;
+        struct drsuapi_changed_objects *changes;
+        time_t max_wait;
+        time_t start = time(NULL);
+        bool max_wait_reached = false;
+        bool has_get_all_changes = false;
+        struct GUID invocation_id;
         DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
 …
         sam_ctx = b_state->sam_ctx_system?b_state->sam_ctx_system:b_state->sam_ctx;
+        invocation_id = *(samdb_ntds_invocation_id(sam_ctx));
         *r->out.level_out = 6;
 …
         user_sid = &dce_call->conn->auth_state.session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
+        /* all clients must have GUID_DRS_GET_CHANGES */
         werr = drs_security_access_check_nc_root(b_state->sam_ctx,
                                                  mem_ctx,
 …
         if (!W_ERROR_IS_OK(werr)) {
                 return werr;
+        }
+        /* allowed if the GC PAS and client has
+           GUID_DRS_GET_FILTERED_ATTRIBUTES */
+        werr = dcesrv_drsuapi_is_gc_pas_request(b_state, req10, &is_gc_pas_request);
+        if (!W_ERROR_IS_OK(werr)) {
+                return werr;
+        }
+        if (is_gc_pas_request) {
+                werr = drs_security_access_check_nc_root(b_state->sam_ctx,
+                                                         mem_ctx,
+                                                         dce_call->conn->auth_state.session_info->security_token,
+                                                         req10->naming_context,
+                                                         GUID_DRS_GET_FILTERED_ATTRIBUTES);
+                if (W_ERROR_IS_OK(werr)) {
+                        goto allowed;
+                }
+        }
 …
                 if (!W_ERROR_IS_OK(werr)) {
                         return werr;
+                }
+        }
+                } else {
+                        has_get_all_changes = true;
+                }
+        }
+allowed:
         /* for non-administrator replications, check that they have
            given the correct source_dsa_invocation_id */
 …
                 req10->uptodateness_vector = NULL;
+        }
+        if (GUID_all_zero(&req10->source_dsa_invocation_id)) {
+                req10->source_dsa_invocation_id = invocation_id;
+        }
+        if (!GUID_equal(&req10->source_dsa_invocation_id, &invocation_id)) {
+                /*
+                 * The given highwatermark is only valid relative to the
+                 * specified source_dsa_invocation_id.
+                 */
+                ZERO_STRUCT(req10->highwatermark);
+        }
         getnc_state = b_state->getncchanges_state;
 …
+        }
+        if (getnc_state) {
+                ret = drsuapi_DsReplicaHighWaterMark_cmp(&getnc_state->last_hwm,
+                                                         &req10->highwatermark);
+                if (ret != 0) {
+                        DEBUG(0,(__location__ ": DsGetNCChanges 2nd replication "
+                                 "on DN %s %s highwatermark (last_dn %s)\n",
+                                 ldb_dn_get_linearized(getnc_state->ncRoot_dn),
+                                 (ret > 0) ? "older" : "newer",
+                                 ldb_dn_get_linearized(getnc_state->last_dn)));
+                        talloc_free(getnc_state);
+                        getnc_state = NULL;
+                }
+        }
         if (getnc_state == NULL) {
                 getnc_state = talloc_zero(b_state, struct drsuapi_getncchanges_state);
 …
                                      ldb_get_schema_basedn(b_state->sam_ctx));
                 getnc_state->is_schema_nc = (0 == ret);
+                if (req10->extended_op != DRSUAPI_EXOP_NONE) {
+                        r->out.ctr->ctr6.extended_ret = DRSUAPI_EXOP_ERR_SUCCESS;
+                }
                 /*
 …
                         break;
                 case DRSUAPI_EXOP_REPL_SECRET:
+                        werr = getncchanges_repl_secret(b_state, mem_ctx, req10, user_sid, &r->out.ctr->ctr6);
+                        werr = getncchanges_repl_secret(b_state, mem_ctx, req10,
+                                                        user_sid,
+                                                        &r->out.ctr->ctr6,
+                                                        has_get_all_changes);
                         r->out.result = werr;
                         W_ERROR_NOT_OK_RETURN(werr);
 …
         if (getnc_state->guids == NULL) {
-                char* search_filter;
-                enum ldb_scope scope = LDB_SCOPE_SUBTREE;
                 const char *extra_filter;
+                struct ldb_result *search_res;
+                if (req10->extended_op == DRSUAPI_EXOP_REPL_OBJ ||
+                    req10->extended_op == DRSUAPI_EXOP_REPL_SECRET) {
+                        scope = LDB_SCOPE_BASE;
+                }
+                struct ldb_result *search_res = NULL;
                 extra_filter = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "object filter");
                 getnc_state->min_usn = req10->highwatermark.highest_usn;
+                /* Construct response. */
+                search_filter = talloc_asprintf(mem_ctx,
+                                                "(uSNChanged>=%llu)",
+                                                (unsigned long long)(getnc_state->min_usn+1));
+                if (extra_filter) {
+                        search_filter = talloc_asprintf(mem_ctx, "(&%s(%s))", search_filter, extra_filter);
+                }
+                if (req10->replica_flags & DRSUAPI_DRS_CRITICAL_ONLY) {
+                        search_filter = talloc_asprintf(mem_ctx,
+                                                        "(&%s(isCriticalSystemObject=TRUE))",
+                                                        search_filter);
+                }
+                if (req10->replica_flags & DRSUAPI_DRS_ASYNC_REP) {
+                        scope = LDB_SCOPE_BASE;
+                }
+                if (!search_dn) {
+                        search_dn = getnc_state->ncRoot_dn;
+                }
+                DEBUG(2,(__location__ ": getncchanges on %s using filter %s\n",
+                         ldb_dn_get_linearized(getnc_state->ncRoot_dn), search_filter));
+                ret = drsuapi_search_with_extended_dn(sam_ctx, getnc_state, &search_res,
+                                                      search_dn, scope, attrs,
+                                                      search_filter);
+                if (ret != LDB_SUCCESS) {
+                        return WERR_DS_DRA_INTERNAL_ERROR;
+                }
+                if (req10->replica_flags & DRSUAPI_DRS_GET_ANC) {
+                        TYPESAFE_QSORT(search_res->msgs,
+                                       search_res->count,
+                                       site_res_cmp_parent_order);
+                getnc_state->max_usn = getnc_state->min_usn;
+                getnc_state->final_udv = talloc_zero(getnc_state,
+                                        struct drsuapi_DsReplicaCursor2CtrEx);
+                if (getnc_state->final_udv == NULL) {
+                        return WERR_NOMEM;
+                }
+                werr = get_nc_changes_udv(sam_ctx, getnc_state->ncRoot_dn,
+                                          getnc_state->final_udv);
+                if (!W_ERROR_IS_OK(werr)) {
+                        return werr;
+                }
+                if (req10->extended_op == DRSUAPI_EXOP_NONE) {
+                        werr = getncchanges_collect_objects(b_state, mem_ctx, req10,
+                                                            search_dn, extra_filter,
+                                                            &search_res);
                 } else {
+                        TYPESAFE_QSORT(search_res->msgs,
+                                       search_res->count,
+                                       site_res_cmp_usn_order);
+                }
+                        werr = getncchanges_collect_objects_exop(b_state, mem_ctx, req10,
+                                                                 &r->out.ctr->ctr6,
+                                                                 search_dn, extra_filter,
+                                                                 &search_res);
+                }
+                W_ERROR_NOT_OK_RETURN(werr);
                 /* extract out the GUIDs list */
                 getnc_state->num_records = search_res->count;
+                getnc_state->num_records = search_res ? search_res->count : 0;
                 getnc_state->guids = talloc_array(getnc_state, struct GUID, getnc_state->num_records);
                 W_ERROR_HAVE_NO_MEMORY(getnc_state->guids);
+                changes = talloc_array(getnc_state,
+                                       struct drsuapi_changed_objects,
+                                       getnc_state->num_records);
+                W_ERROR_HAVE_NO_MEMORY(changes);
                 for (i=0; i<getnc_state->num_records; i++) {
+                        getnc_state->guids[i] = samdb_result_guid(search_res->msgs[i], "objectGUID");
+                        changes[i].dn = search_res->msgs[i]->dn;
+                        changes[i].guid = samdb_result_guid(search_res->msgs[i], "objectGUID");
+                        changes[i].usn = ldb_msg_find_attr_as_uint64(search_res->msgs[i], "uSNChanged", 0);
+                        if (changes[i].usn > getnc_state->max_usn) {
+                                getnc_state->max_usn = changes[i].usn;
+                        }
+                }
+                if (req10->replica_flags & DRSUAPI_DRS_GET_ANC) {
+                        LDB_TYPESAFE_QSORT(changes,
+                                           getnc_state->num_records,
+                                           getnc_state,
+                                           site_res_cmp_anc_order);
+                } else {
+                        LDB_TYPESAFE_QSORT(changes,
+                                           getnc_state->num_records,
+                                           getnc_state,
+                                           site_res_cmp_usn_order);
+                }
+                for (i=0; i < getnc_state->num_records; i++) {
+                        getnc_state->guids[i] = changes[i].guid;
                         if (GUID_all_zero(&getnc_state->guids[i])) {
+                                DEBUG(2,("getncchanges: bad objectGUID from %s\n", ldb_dn_get_linearized(search_res->msgs[i]->dn)));
+                                DEBUG(2,("getncchanges: bad objectGUID from %s\n",
+                                         ldb_dn_get_linearized(search_res->msgs[i]->dn)));
                                 return WERR_DS_DRA_INTERNAL_ERROR;
+                        }
+                }
+                getnc_state->final_hwm.tmp_highest_usn = getnc_state->max_usn;
+                getnc_state->final_hwm.reserved_usn = 0;
+                getnc_state->final_hwm.highest_usn = getnc_state->max_usn;
                 talloc_free(search_res);
                 getnc_state->uptodateness_vector = talloc_steal(getnc_state, req10->uptodateness_vector);
+                if (getnc_state->uptodateness_vector) {
                         /* make sure its sorted */
                         TYPESAFE_QSORT(getnc_state->uptodateness_vector->cursors,
                                        getnc_state->uptodateness_vector->count,
                                        drsuapi_DsReplicaCursor_compare);
+                }
+                talloc_free(changes);
+        }
+        if (req10->uptodateness_vector) {
+                /* make sure its sorted */
+                TYPESAFE_QSORT(req10->uptodateness_vector->cursors,
+                               req10->uptodateness_vector->count,
+                               drsuapi_DsReplicaCursor_compare);
+        }
 …
         max_links = lpcfg_parm_int(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "max link sync", 1500);
+        /*
+         * Maximum time that we can spend in a getncchanges
+         * in order to avoid timeout of the other part.
+         * 10 seconds by default.
+         */
+        max_wait = lpcfg_parm_int(dce_call->conn->dce_ctx->lp_ctx, NULL, "drs", "max work time", 10);
         for (i=getnc_state->num_processed;
              i<getnc_state->num_records &&
                      !null_scope &&
+                     (r->out.ctr->ctr6.object_count < max_objects);
+                     (r->out.ctr->ctr6.object_count < max_objects)
+                     && !max_wait_reached;
             i++) {
                 int uSN;
 …
                 msg = msg_res->msgs[0];
+                max_wait_reached = (time(NULL) - start > max_wait);
                 werr = get_nc_changes_build_object(obj, msg,
                                                    sam_ctx, getnc_state->ncRoot_dn,
 …
                                                    req10->replica_flags,
                                                    req10->partial_attribute_set,
+                                                   getnc_state->uptodateness_vector,
+                                                   req10->extended_op);
+                                                   req10->uptodateness_vector,
+                                                   req10->extended_op,
+                                                   max_wait_reached);
                 if (!W_ERROR_IS_OK(werr)) {
                         return werr;
 …
                                                 &getnc_state->la_list,
                                                 &getnc_state->la_count,
                                                 getnc_state->uptodateness_vector);
+                                                req10->uptodateness_vector);
                 if (!W_ERROR_IS_OK(werr)) {
                         return werr;
 …
                 uSN = ldb_msg_find_attr_as_int(msg, "uSNChanged", -1);
+                if (uSN > getnc_state->max_usn) {
+                        /*
+                         * Only report the max_usn we had at the start
+                         * of the replication cycle.
+                         *
+                         * If this object has changed lately we better
+                         * let the destination dsa refetch the change.
+                         * This is better than the risk of loosing some
+                         * objects or linked attributes.
+                         */
+                        uSN = 0;
+                }
                 if (uSN > r->out.ctr->ctr6.new_highwatermark.tmp_highest_usn) {
                         r->out.ctr->ctr6.new_highwatermark.tmp_highest_usn = uSN;
+                }
+                if (uSN > getnc_state->highest_usn) {
+                        getnc_state->highest_usn = uSN;
+                        r->out.ctr->ctr6.new_highwatermark.reserved_usn = 0;
+                }
 …
                 currentObject = &obj->next_object;
+                DEBUG(8,(__location__ ": replicating object %s\n", ldb_dn_get_linearized(msg->dn)));
                 talloc_free(getnc_state->last_dn);
+                getnc_state->last_dn = ldb_dn_copy(getnc_state, msg->dn);
+                DEBUG(8,(__location__ ": replicating object %s\n", ldb_dn_get_linearized(msg->dn)));
+                getnc_state->last_dn = talloc_move(getnc_state, &msg->dn);
                 talloc_free(msg_res);
 …
                          GUID_string(mem_ctx, &req10->destination_dsa_guid)));
                 ureq.naming_context = ncRoot;
+                ureq.dest_dsa_dns_name = talloc_asprintf(mem_ctx, "%s._msdcs.%s",
+                                                         GUID_string(mem_ctx, &req10->destination_dsa_guid),
+                                                         lpcfg_dnsdomain(dce_call->conn->dce_ctx->lp_ctx));
+                ureq.dest_dsa_dns_name = samdb_ntds_msdcs_dns_name(b_state->sam_ctx, mem_ctx,
+                                                                   &req10->destination_dsa_guid);
                 if (!ureq.dest_dsa_dns_name) {
                         return WERR_NOMEM;
 …
                 werr = drsuapi_UpdateRefs(b_state, mem_ctx, &ureq);
                 if (!W_ERROR_IS_OK(werr)) {
+                        DEBUG(0,(__location__ ": Failed UpdateRefs in DsGetNCChanges - %s\n",
+                        DEBUG(0,(__location__ ": Failed UpdateRefs on %s for %s in DsGetNCChanges - %s\n",
+                                 drs_ObjectIdentifier_to_string(mem_ctx, ncRoot), ureq.dest_dsa_dns_name,
                                  win_errstr(werr)));
+                }
 …
                 talloc_steal(mem_ctx, getnc_state->la_list);
+                r->out.ctr->ctr6.uptodateness_vector = talloc(mem_ctx, struct drsuapi_DsReplicaCursor2CtrEx);
+                r->out.ctr->ctr6.new_highwatermark.highest_usn = r->out.ctr->ctr6.new_highwatermark.tmp_highest_usn;
+                werr = get_nc_changes_udv(sam_ctx, getnc_state->ncRoot_dn,
+                                          r->out.ctr->ctr6.uptodateness_vector);
+                if (!W_ERROR_IS_OK(werr)) {
+                        return werr;
+                }
+                r->out.ctr->ctr6.new_highwatermark = getnc_state->final_hwm;
+                r->out.ctr->ctr6.uptodateness_vector = talloc_move(mem_ctx,
+                                                        &getnc_state->final_udv);
                 talloc_free(getnc_state);
                 b_state->getncchanges_state = NULL;
+        } else {
+                ret = drsuapi_DsReplicaHighWaterMark_cmp(&r->out.ctr->ctr6.old_highwatermark,
+                                                         &r->out.ctr->ctr6.new_highwatermark);
+                if (ret == 0) {
+                        /*
+                         * We need to make sure that we never return the
+                         * same highwatermark within the same replication
+                         * cycle more than once. Otherwise we cannot detect
+                         * when the client uses an unexptected highwatermark.
+                         *
+                         * This is a HACK which is needed because our
+                         * object ordering is wrong and set tmp_highest_usn
+                         * to a value that is higher than what we already
+                         * sent to the client (destination dsa).
+                         */
+                        r->out.ctr->ctr6.new_highwatermark.reserved_usn += 1;
+                }
+                getnc_state->last_hwm = r->out.ctr->ctr6.new_highwatermark;
+        }
 …
                 r->out.ctr->ctr6.nc_object_count = 0;
                 ZERO_STRUCT(r->out.ctr->ctr6.new_highwatermark);
-                r->out.ctr->ctr6.extended_ret = DRSUAPI_EXOP_ERR_SUCCESS;
+        }

vendor/current/source4/rpc_server/drsuapi/updaterefs.c

-              r740
+              r988
         for (i=0; i<reps.count; i++) {
                 if (GUID_compare(&dest->source_dsa_obj_guid,
                                  &reps.r[i].ctr.ctr1.source_dsa_obj_guid) == 0) {
+                if (GUID_equal(&dest->source_dsa_obj_guid,
+                               &reps.r[i].ctr.ctr1.source_dsa_obj_guid)) {
                         if (options & DRSUAPI_DRS_GETCHG_CHECK) {
                                 return WERR_OK;
 …
         for (i=0; i<reps.count; i++) {
+                if (GUID_compare(dest_guid, &reps.r[i].ctr.ctr1.source_dsa_obj_guid) == 0) {
+                if (GUID_equal(dest_guid,
+                               &reps.r[i].ctr.ctr1.source_dsa_obj_guid)) {
                         if (i+1 < reps.count) {
                                 memmove(&reps.r[i], &reps.r[i+1], sizeof(reps.r[i])*(reps.count-(i+1)));
 …
+}
+/*
+  drsuapi_DsReplicaUpdateRefs - a non RPC version callable from getncchanges
+*/
+/**
+ * @brief Update the references for the given NC and the destination DSA object
+ *
+ * This function is callable from non RPC functions (ie. getncchanges), it
+ * will validate the request to update reference and then will add/del a repsTo
+ * to the specified server referenced by its DSA GUID in the request.
+ *
+ * @param[in]       b_state          A bind_state object
+ *
+ * @param[in]       mem_ctx          A talloc context for memory allocation
+ *
+ * @param[in]       req              A drsuapi_DsReplicaUpdateRefsRequest1
+ *                                   object which NC, which server and which
+ *                                   action (add/delete) should be performed
+ *
+ * @return                           WERR_OK is success, different error
+ *                                   otherwise.
+ */
 WERROR drsuapi_UpdateRefs(struct drsuapi_bind_state *b_state, TALLOC_CTX *mem_ctx,
                           struct drsuapi_DsReplicaUpdateRefsRequest1 *req)
+{
         WERROR werr;
+        int ret;
         struct ldb_dn *dn;
+        struct ldb_dn *nc_root;
         struct ldb_context *sam_ctx = b_state->sam_ctx_system?b_state->sam_ctx_system:b_state->sam_ctx;
 …
                  drs_ObjectIdentifier_to_string(mem_ctx, req->naming_context)));
+        dn = ldb_dn_new(mem_ctx, sam_ctx, req->naming_context->dn);
+        if (dn == NULL) {
+                return WERR_DS_INVALID_DN_SYNTAX;
+        /*
+         * 4.1.26.2 Server Behavior of the IDL_DRSUpdateRefs Method
+         * Implements the input validation checks
+         */
+        if (GUID_all_zero(&req->dest_dsa_guid)) {
+                return WERR_DS_DRA_INVALID_PARAMETER;
+        }
+        /* FIXME it seems that we should check the length of the stuff too*/
+        if (req->dest_dsa_dns_name == NULL) {
+                return WERR_DS_DRA_INVALID_PARAMETER;
+        }
+        if (!(req->options & (DRSUAPI_DRS_DEL_REF|DRSUAPI_DRS_ADD_REF))) {
+                return WERR_DS_DRA_INVALID_PARAMETER;
+        }
+        dn = drs_ObjectIdentifier_to_dn(mem_ctx, sam_ctx, req->naming_context);
+        W_ERROR_HAVE_NO_MEMORY(dn);
+        ret = dsdb_find_nc_root(sam_ctx, dn, dn, &nc_root);
+        if (ret != LDB_SUCCESS) {
+                DEBUG(2, ("Didn't find a nc for %s\n", ldb_dn_get_linearized(dn)));
+                return WERR_DS_DRA_BAD_NC;
+        }
+        if (ldb_dn_compare(dn, nc_root) != 0) {
+                DEBUG(2, ("dn %s is not equal to %s\n", ldb_dn_get_linearized(dn), ldb_dn_get_linearized(nc_root)));
+                return WERR_DS_DRA_BAD_NC;
+        }
 …
                 DEBUG(0,(__location__ ": Failed to start transaction on samdb: %s\n",
                          ldb_errstring(sam_ctx)));
                 return WERR_DS_DRA_INTERNAL_ERROR;
+                return WERR_DS_DRA_INTERNAL_ERROR;
+        }

vendor/current/source4/rpc_server/drsuapi/writespn.c

-              r740
+              r988
         krb5_error_code kerr;
         krb5_principal principal;
+        const krb5_data *component;
         const char *dns_name, *dnsHostName;
 …
+        }
         if (principal->name.name_string.len != 2) {
+        if (krb5_princ_size(krb_ctx, principal) != 2) {
                 krb5_free_principal(krb_ctx, principal);
                 krb5_free_context(krb_ctx);
 …
+        }
+        dns_name = principal->name.name_string.val[1];
+        component = krb5_princ_component(krb_ctx, principal, 1);
+        dns_name = (const char *)component->data;
         if (strcasecmp(dns_name, dnsHostName) != 0) {
 …
         struct drsuapi_bind_state *b_state;
         struct dcesrv_handle *h;
-        enum security_user_level level;
         *r->out.level_out = r->in.level;
 …
         r->out.res = talloc(mem_ctx, union drsuapi_DsWriteAccountSpnResult);
         W_ERROR_HAVE_NO_MEMORY(r->out.res);
-        level = security_session_user_level(dce_call->conn->auth_state.session_info, NULL);
         switch (r->in.level) {

vendor/current/source4/rpc_server/echo/rpc_echo.c

-              r740
+              r988
 #include "lib/events/events.h"
+#define DCESRV_INTERFACE_RPCECHO_BIND(call, iface) \
+       dcesrv_interface_rpcecho_bind(call, iface)
+static NTSTATUS dcesrv_interface_rpcecho_bind(struct dcesrv_call_state *dce_call,
+                                              const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_allow_connect(dce_call, iface);
+}
 static NTSTATUS dcesrv_echo_AddOne(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct echo_AddOne *r)
 …
         p->r            = r;
         event_add_timed(dce_call->event_ctx, p,
+        tevent_add_timer(dce_call->event_ctx, p,
                         timeval_add(&dce_call->time, r->in.seconds, 0),
                         echo_TestSleep_handler, p);

vendor/current/source4/rpc_server/epmapper/rpc_epmapper.c

-              r740
+              r988
 #include "rpc_server/dcerpc_server.h"
+#define DCESRV_INTERFACE_EPMAPPER_BIND(call, iface) \
+       dcesrv_interface_epmapper_bind(call, iface)
+static NTSTATUS dcesrv_interface_epmapper_bind(struct dcesrv_call_state *dce_call,
+                                             const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_allow_connect(dce_call, iface);
+}
 typedef uint32_t error_status_t;
 …
         for (d=endpoint_list; d; d=d->next) {
                 struct dcesrv_if_list *iface;
-                struct dcerpc_binding *description;
                 for (iface=d->interface_list;iface;iface=iface->next) {
+                        struct dcerpc_binding *description;
                         (*eps) = talloc_realloc(mem_ctx,
                                                   *eps,
 …
                         (*eps)[total].name = iface->iface.name;
+                        description = d->ep_description;
+                        description->object = iface->iface.syntax_id;
+                        description = dcerpc_binding_dup(*eps, d->ep_description);
+                        if (description == NULL) {
+                                return 0;
+                        }
+                        status = dcerpc_binding_set_abstract_syntax(description,
+                                                        &iface->iface.syntax_id);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                return 0;
+                        }
                         status = dcerpc_binding_build_tower(*eps, description, &(*eps)[total].ep);
+                        if (NT_STATUS_IS_ERR(status)) {
+                                DEBUG(1, ("Unable to build tower for %s\n", iface->iface.name));
+                        TALLOC_FREE(description);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                DEBUG(1, ("Unable to build tower for %s - %s\n",
+                                          iface->iface.name, nt_errstr(status)));
                                 continue;
+                        }
 …
         if (floors[1].lhs.protocol != EPM_PROTOCOL_UUID ||
                 !GUID_equal(&ndr_syntax.uuid, &ndr_transfer_syntax.uuid) ||
             ndr_syntax.if_version != ndr_transfer_syntax.if_version) {
+                !GUID_equal(&ndr_syntax.uuid, &ndr_transfer_syntax_ndr.uuid) ||
+            ndr_syntax.if_version != ndr_transfer_syntax_ndr.if_version) {
                 goto failed;
+        }

vendor/current/source4/rpc_server/handles.c

-              r740
+              r988
         sid = &context->conn->auth_state.session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
         h = talloc(context->assoc_group, struct dcesrv_handle);
+        h = talloc_zero(context->conn->assoc_group, struct dcesrv_handle);
         if (!h) {
                 return NULL;
 …
                 return NULL;
+        }
         h->assoc_group = context->assoc_group;
+        h->assoc_group = context->conn->assoc_group;
         h->iface = context->iface;
         h->wire_handle.handle_type = handle_type;
         h->wire_handle.uuid = GUID_random();
         DLIST_ADD(context->assoc_group->handles, h);
+        DLIST_ADD(context->conn->assoc_group->handles, h);
         talloc_set_destructor(h, dcesrv_handle_destructor);
 …
         sid = &context->conn->auth_state.session_info->security_token->sids[PRIMARY_USER_SID_INDEX];
         if (policy_handle_empty(p)) {
+        if (ndr_policy_handle_empty(p)) {
                 /* TODO: we should probably return a NULL handle here */
                 return dcesrv_handle_new(context, handle_type);
+        }
         for (h=context->assoc_group->handles; h; h=h->next) {
+        for (h=context->conn->assoc_group->handles; h; h=h->next) {
                 if (h->wire_handle.handle_type == p->handle_type &&
                     GUID_equal(&p->uuid, &h->wire_handle.uuid)) {

vendor/current/source4/rpc_server/lsa/dcesrv_lsa.c

-              r740
+              r988
    Copyright (C) Andrew Tridgell 2004
    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2008
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 …
 #include "dsdb/common/util.h"
 #include "libcli/security/session.h"
+#include "kdc/kdc-policy.h"
+#include "libcli/lsarpc/util_lsarpc.h"
+#include "lib/messaging/irpc.h"
+#include "libds/common/roles.h"
+#define DCESRV_INTERFACE_LSARPC_BIND(call, iface) \
+       dcesrv_interface_lsarpc_bind(call, iface)
+static NTSTATUS dcesrv_interface_lsarpc_bind(struct dcesrv_call_state *dce_call,
+                                             const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_reject_connect(dce_call, iface);
+}
 /*
 …
   It uses the same logic, but with samba4 helper functions
  */
 static NTSTATUS dcesrv_build_lsa_sd(TALLOC_CTX *mem_ctx,
+static NTSTATUS dcesrv_build_lsa_sd(TALLOC_CTX *mem_ctx,
                                     struct security_descriptor **sd,
                                     struct dom_sid *sid,
+                                    struct dom_sid *sid,
                                     uint32_t sid_access)
+{
 …
         status = dom_sid_split_rid(tmp_ctx, sid, &domain_sid, &rid);
+        NT_STATUS_NOT_OK_RETURN_AND_FREE(status, tmp_ctx);
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(tmp_ctx);
+                return status;
+        }
         domain_admins_sid = dom_sid_add_rid(tmp_ctx, domain_sid, DOMAIN_RID_ADMINS);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(domain_admins_sid, tmp_ctx);
+        if (domain_admins_sid == NULL) {
+                TALLOC_FREE(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
         domain_admins_sid_str = dom_sid_string(tmp_ctx, domain_admins_sid);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(domain_admins_sid_str, tmp_ctx);
+        if (domain_admins_sid_str == NULL) {
+                TALLOC_FREE(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
         sidstr = dom_sid_string(tmp_ctx, sid);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sidstr, tmp_ctx);
+        if (sidstr == NULL) {
+                TALLOC_FREE(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
         *sd = security_descriptor_dacl_create(mem_ctx,
 , sidstr, NULL,
 …
                                               SEC_ACE_TYPE_ACCESS_ALLOWED,
                                               SEC_GENERIC_EXECUTE | SEC_GENERIC_READ, 0,
                                               SID_BUILTIN_ADMINISTRATORS,
                                               SEC_ACE_TYPE_ACCESS_ALLOWED,
                                               SEC_GENERIC_ALL, 0,
                                               SID_BUILTIN_ACCOUNT_OPERATORS,
                                               SEC_ACE_TYPE_ACCESS_ALLOWED,
                                               SEC_GENERIC_ALL, 0,
                                               domain_admins_sid_str,
                                               SEC_ACE_TYPE_ACCESS_ALLOWED,
 …
 static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
                                       TALLOC_CTX *mem_ctx,
                                       struct lsa_EnumAccountRights *r);
 static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_call,
                                            TALLOC_CTX *mem_ctx,
                                            struct lsa_policy_state *state,
 …
                                            const struct lsa_RightSet *rights);
 /*
   lsa_Close
+/*
+  lsa_Close
 */
 static NTSTATUS dcesrv_lsa_Close(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                           struct lsa_Close *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
         struct dcesrv_handle *h;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         *r->out.handle = *r->in.handle;
 …
 /*
   lsa_Delete
+/*
+  lsa_Delete
 */
 static NTSTATUS dcesrv_lsa_Delete(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
+/*
   lsa_DeleteObject
 */
 …
+                }
                 ret = ldb_delete(secret_state->sam_ldb,
+                ret = ldb_delete(secret_state->sam_ldb,
                                  secret_state->secret_dn);
                 if (ret != LDB_SUCCESS) {
 …
         } else if (h->wire_handle.handle_type == LSA_HANDLE_TRUSTED_DOMAIN) {
                 struct lsa_trusted_domain_state *trusted_domain_state =
+                struct lsa_trusted_domain_state *trusted_domain_state =
                         talloc_get_type(h->data, struct lsa_trusted_domain_state);
                 ret = ldb_transaction_start(trusted_domain_state->policy->sam_ldb);
 …
+                }
                 ret = ldb_delete(trusted_domain_state->policy->sam_ldb,
+                ret = ldb_delete(trusted_domain_state->policy->sam_ldb,
                                  trusted_domain_state->trusted_domain_dn);
                 if (ret != LDB_SUCCESS) {
 …
                 if (trusted_domain_state->trusted_domain_user_dn) {
                         ret = ldb_delete(trusted_domain_state->policy->sam_ldb,
+                        ret = ldb_delete(trusted_domain_state->policy->sam_ldb,
                                          trusted_domain_state->trusted_domain_user_dn);
                         if (ret != LDB_SUCCESS) {
 …
                 DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_ACCOUNT);
                 astate = h->data;
 …
+                }
                 status = dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
+                status = dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
                                                     LDB_FLAG_MOD_DELETE, astate->account_sid,
                                                     r2.out.rights);
 …
                 return NT_STATUS_OK;
+        }
+        }
         return NT_STATUS_INVALID_HANDLE;
+}
 /*
   lsa_EnumPrivs
+/*
+  lsa_EnumPrivs
 */
 static NTSTATUS dcesrv_lsa_EnumPrivs(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
+{
         struct dcesrv_handle *h;
-        struct lsa_policy_state *state;
         uint32_t i;
         enum sec_privilege priv;
 …
         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
-        state = h->data;
         i = *r->in.resume_handle;
 …
                 privname = sec_privilege_name(priv);
                 r->out.privs->privs = talloc_realloc(r->out.privs,
                                                        r->out.privs->privs,
                                                        struct lsa_PrivEntry,
+                                                       r->out.privs->privs,
+                                                       struct lsa_PrivEntry,
                                                        r->out.privs->count+1);
                 if (r->out.privs->privs == NULL) {
 …
 /*
   lsa_QuerySecObj
+/*
+  lsa_QuerySecObj
 */
 static NTSTATUS dcesrv_lsa_QuerySecurity(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
+{
         struct dcesrv_handle *h;
+        struct security_descriptor *sd;
+        const struct security_descriptor *sd = NULL;
+        uint32_t access_granted = 0;
+        struct sec_desc_buf *sdbuf = NULL;
         NTSTATUS status;
         struct dom_sid *sid;
 …
         if (h->wire_handle.handle_type == LSA_HANDLE_POLICY) {
+                status = dcesrv_build_lsa_sd(mem_ctx, &sd, sid, 0);
+        } else  if (h->wire_handle.handle_type == LSA_HANDLE_ACCOUNT) {
+                status = dcesrv_build_lsa_sd(mem_ctx, &sd, sid,
+                struct lsa_policy_state *pstate = h->data;
+                sd = pstate->sd;
+                access_granted = pstate->access_mask;
+        } else if (h->wire_handle.handle_type == LSA_HANDLE_ACCOUNT) {
+                struct lsa_account_state *astate = h->data;
+                struct security_descriptor *_sd = NULL;
+                status = dcesrv_build_lsa_sd(mem_ctx, &_sd, sid,
                                              LSA_ACCOUNT_ALL_ACCESS);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+                sd = _sd;
+                access_granted = astate->access_mask;
         } else {
                 return NT_STATUS_INVALID_HANDLE;
+        }
+        NT_STATUS_NOT_OK_RETURN(status);
+        (*r->out.sdbuf) = talloc(mem_ctx, struct sec_desc_buf);
+        NT_STATUS_HAVE_NO_MEMORY(*r->out.sdbuf);
+        (*r->out.sdbuf)->sd = sd;
+        sdbuf = talloc_zero(mem_ctx, struct sec_desc_buf);
+        if (sdbuf == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        status = security_descriptor_for_client(sdbuf, sd, r->in.sec_info,
+                                                access_granted, &sdbuf->sd);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        *r->out.sdbuf = sdbuf;
         return NT_STATUS_OK;
+}
 /*
   lsa_SetSecObj
+/*
+  lsa_SetSecObj
 */
 static NTSTATUS dcesrv_lsa_SetSecObj(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_ChangePassword
+/*
+  lsa_ChangePassword
 */
 static NTSTATUS dcesrv_lsa_ChangePassword(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
+}
 /*
   dssetup_DsRoleGetPrimaryDomainInformation
+/*
+  dssetup_DsRoleGetPrimaryDomainInformation
   This is not an LSA call, but is the only call left on the DSSETUP
   pipe (after the pipe was truncated), and needs lsa_get_policy_state
 */
 static WERROR dcesrv_dssetup_DsRoleGetPrimaryDomainInformation(struct dcesrv_call_state *dce_call,
+static WERROR dcesrv_dssetup_DsRoleGetPrimaryDomainInformation(struct dcesrv_call_state *dce_call,
                                                  TALLOC_CTX *mem_ctx,
                                                  struct dssetup_DsRoleGetPrimaryDomainInformation *r)
 …
                 struct lsa_policy_state *state;
+                NTSTATUS status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx, &state);
+                NTSTATUS status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx,
+, /* we skip access checks */
+                                                              &state);
                 if (!NT_STATUS_IS_OK(status)) {
                         return ntstatus_to_werror(status);
 …
                         role            = DS_ROLE_MEMBER_SERVER;
                         break;
                 case ROLE_DOMAIN_CONTROLLER:
+                case ROLE_ACTIVE_DIRECTORY_DC:
                         if (samdb_is_pdc(state->sam_ldb)) {
                                 role    = DS_ROLE_PRIMARY_DC;
 …
                         /* TODO: what is with dns_domain and forest and guid? */
                         break;
                 case ROLE_DOMAIN_CONTROLLER:
+                case ROLE_ACTIVE_DIRECTORY_DC:
                         flags           = DS_ROLE_PRIMARY_DS_RUNNING;
 …
                                 flags   |= DS_ROLE_PRIMARY_DS_MIXED_MODE;
+                        }
                         domain          = state->domain_name;
                         dns_domain      = state->domain_dns;
 …
+                }
                 info->basic.role        = role;
+                info->basic.role        = role;
                 info->basic.flags       = flags;
                 info->basic.domain      = domain;
 …
+}
 /*
+/*
   lsa_QueryInfoPolicy2
 */
 …
+}
 /*
   lsa_QueryInfoPolicy
+/*
+  lsa_QueryInfoPolicy
 */
 static NTSTATUS dcesrv_lsa_QueryInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
         r2.in.level = r->in.level;
         r2.out.info = r->out.info;
         status = dcesrv_lsa_QueryInfoPolicy2(dce_call, mem_ctx, &r2);
 …
+}
 /*
   lsa_SetInfoPolicy
+/*
+  lsa_SetInfoPolicy
 */
 static NTSTATUS dcesrv_lsa_SetInfoPolicy(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_ClearAuditLog
+/*
+  lsa_ClearAuditLog
 */
 static NTSTATUS dcesrv_lsa_ClearAuditLog(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
+/*
+  lsa_CreateAccount
+static const struct generic_mapping dcesrv_lsa_account_mapping = {
+        LSA_ACCOUNT_READ,
+        LSA_ACCOUNT_WRITE,
+        LSA_ACCOUNT_EXECUTE,
+        LSA_ACCOUNT_ALL_ACCESS
+};
+/*
+  lsa_CreateAccount
   This call does not seem to have any long-term effects, hence no database operations
 …
                 return NT_STATUS_NO_MEMORY;
+        }
         astate->policy = talloc_reference(astate, state);
         astate->access_mask = r->in.access_mask;
+        /*
+         * For now we grant all requested access.
+         *
+         * We will fail at the ldb layer later.
+         */
+        if (astate->access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
+                astate->access_mask &= ~SEC_FLAG_MAXIMUM_ALLOWED;
+                astate->access_mask |= LSA_ACCOUNT_ALL_ACCESS;
+        }
+        se_map_generic(&astate->access_mask, &dcesrv_lsa_account_mapping);
+        DEBUG(10,("%s: %s access desired[0x%08X] granted[0x%08X].\n",
+                  __func__, dom_sid_string(mem_ctx, astate->account_sid),
+                 (unsigned)r->in.access_mask,
+                 (unsigned)astate->access_mask));
         ah = dcesrv_handle_new(dce_call->context, LSA_HANDLE_ACCOUNT);
 …
 /*
   lsa_EnumAccounts
+/*
+  lsa_EnumAccounts
 */
 static NTSTATUS dcesrv_lsa_EnumAccounts(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
         /* NOTE: This call must only return accounts that have at least
            one privilege set
+           one privilege set
         */
         ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs,
+        ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs,
                            "(&(objectSid=*)(privilege=*))");
         if (ret < 0) {
 …
         for (i=0;i<count;i++) {
                 r->out.sids->sids[i].sid =
                         samdb_result_dom_sid(r->out.sids->sids,
+                r->out.sids->sids[i].sid =
+                        samdb_result_dom_sid(r->out.sids->sids,
                                              res[i + *r->in.resume_handle],
                                              "objectSid");
 …
         return NT_STATUS_OK;
+}
 …
         enum ndr_err_code ndr_err;
+        if (iopw->current.count != iopw->count) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        if (iopw->previous.count > iopw->current.count) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        if (iopw->previous.count == 0) {
+                /*
+                 * If the previous credentials are not present
+                 * we need to make a copy.
+                 */
+                iopw->previous = iopw->current;
+        }
+        if (iopw->previous.count < iopw->current.count) {
+                struct AuthenticationInformationArray *c = &iopw->current;
+                struct AuthenticationInformationArray *p = &iopw->previous;
+                /*
+                 * The previous array needs to have the same size
+                 * as the current one.
+                 *
+                 * We may have to fill with TRUST_AUTH_TYPE_NONE
+                 * elements.
+                 */
+                p->array = talloc_realloc(mem_ctx, p->array,
+                                   struct AuthenticationInformation,
+                                   c->count);
+                if (p->array == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                while (p->count < c->count) {
+                        struct AuthenticationInformation *a =
+                                &p->array[p->count++];
+                        *a = (struct AuthenticationInformation) {
+                                .LastUpdateTime = p->array[0].LastUpdateTime,
+                                .AuthType = TRUST_AUTH_TYPE_NONE,
+                        };
+                }
+        }
         ndr_err = ndr_push_struct_blob(trustauth_blob, mem_ctx,
                                        iopw,
 …
                                struct ldb_dn **user_dn)
+{
+        struct ldb_request *req;
         struct ldb_message *msg;
         struct ldb_dn *dn;
 …
         /* create the trusted_domain user account */
+        ret = ldb_add(sam_ldb, msg);
+        ret = ldb_build_add_req(&req, sam_ldb, mem_ctx, msg, NULL, NULL,
+                                ldb_op_default_callback, NULL);
+        if (ret != LDB_SUCCESS) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        ret = ldb_request_add_control(req, DSDB_CONTROL_PERMIT_INTERDOMAIN_TRUST_UAC_OID,
+                                      false, NULL);
+        if (ret != LDB_SUCCESS) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        ret = dsdb_autotransaction_request(sam_ldb, req);
         if (ret != LDB_SUCCESS) {
                 DEBUG(0,("Failed to create user record %s: %s\n",
 …
                                                     TALLOC_CTX *mem_ctx,
                                                     struct lsa_CreateTrustedDomainEx2 *r,
+                                                    int op)
+                                                    int op,
+                                                    struct lsa_TrustDomainInfoAuthInfo *unencrypted_auth_info)
+{
         struct dcesrv_handle *policy_handle;
 …
         const char *netbios_name;
         const char *dns_name;
-        const char *name;
         DATA_BLOB trustAuthIncoming, trustAuthOutgoing, auth_blob;
         struct trustDomainPasswords auth_struct;
 …
         NTSTATUS nt_status;
         struct ldb_context *sam_ldb;
+        struct server_id *server_ids = NULL;
+        uint32_t num_server_ids = 0;
+        NTSTATUS status;
+        struct dom_sid *tmp_sid1;
+        struct dom_sid *tmp_sid2;
+        uint32_t tmp_rid;
+        bool ok;
+        char *dns_encoded = NULL;
+        char *netbios_encoded = NULL;
+        char *sid_encoded = NULL;
         DCESRV_PULL_HANDLE(policy_handle, r->in.policy_handle, LSA_HANDLE_POLICY);
 …
         dns_name = r->in.info->domain_name.string;
+        if (dns_name == NULL) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        if (r->in.info->sid == NULL) {
+                return NT_STATUS_INVALID_SID;
+        }
+        /*
+         * We expect S-1-5-21-A-B-C, but we don't
+         * allow S-1-5-21-0-0-0 as this is used
+         * for claims and compound identities.
+         *
+         * So we call dom_sid_split_rid() 3 times
+         * and compare the result to S-1-5-21
+         */
+        status = dom_sid_split_rid(mem_ctx, r->in.info->sid, &tmp_sid1, &tmp_rid);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        status = dom_sid_split_rid(mem_ctx, tmp_sid1, &tmp_sid2, &tmp_rid);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        status = dom_sid_split_rid(mem_ctx, tmp_sid2, &tmp_sid1, &tmp_rid);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        ok = dom_sid_parse("S-1-5-21", tmp_sid2);
+        if (!ok) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        ok = dom_sid_equal(tmp_sid1, tmp_sid2);
+        if (!ok) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        ok = dom_sid_parse("S-1-5-21-0-0-0", tmp_sid2);
+        if (!ok) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        ok = !dom_sid_equal(r->in.info->sid, tmp_sid2);
+        if (!ok) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        dns_encoded = ldb_binary_encode_string(mem_ctx, dns_name);
+        if (dns_encoded == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        netbios_encoded = ldb_binary_encode_string(mem_ctx, netbios_name);
+        if (netbios_encoded == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        sid_encoded = ldap_encode_ndr_dom_sid(mem_ctx, r->in.info->sid);
+        if (sid_encoded == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
         trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
 …
         if (strcasecmp(netbios_name, "BUILTIN") == 0
             || (dns_name && strcasecmp(dns_name, "BUILTIN") == 0)
+            || (strcasecmp(dns_name, "BUILTIN") == 0)
             || (dom_sid_in_domain(policy_state->builtin_sid, r->in.info->sid))) {
                 return NT_STATUS_INVALID_PARAMETER;
 …
         if (strcasecmp(netbios_name, policy_state->domain_name) == 0
             || strcasecmp(netbios_name, policy_state->domain_dns) == 0
             || (dns_name && strcasecmp(dns_name, policy_state->domain_dns) == 0)
             || (dns_name && strcasecmp(dns_name, policy_state->domain_name) == 0)
+            || strcasecmp(dns_name, policy_state->domain_dns) == 0
+            || strcasecmp(dns_name, policy_state->domain_name) == 0
             || (dom_sid_equal(policy_state->domain_sid, r->in.info->sid))) {
                 return NT_STATUS_CURRENT_DOMAIN_NOT_ALLOWED;
 …
                 auth_struct.outgoing.count = 0;
                 auth_struct.incoming.count = 0;
         } else {
                 auth_blob = data_blob_const(r->in.auth_info->auth_blob.data,
                                             r->in.auth_info->auth_blob.size);
+        } else if (op == NDR_LSA_CREATETRUSTEDDOMAINEX2) {
+                auth_blob = data_blob_const(r->in.auth_info_internal->auth_blob.data,
+                                            r->in.auth_info_internal->auth_blob.size);
                 nt_status = get_trustdom_auth_blob(dce_call, mem_ctx,
                                                    &auth_blob, &auth_struct);
 …
                         return nt_status;
+                }
+                if (op == NDR_LSA_CREATETRUSTEDDOMAINEX) {
+                        if (auth_struct.incoming.count > 1) {
+                                return NT_STATUS_INVALID_PARAMETER;
+                        }
+                }
+        } else if (op == NDR_LSA_CREATETRUSTEDDOMAINEX) {
+                if (unencrypted_auth_info->incoming_count > 1) {
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
+                /* more investigation required here, do not create secrets for
+                 * now */
+                auth_struct.outgoing.count = 0;
+                auth_struct.incoming.count = 0;
+        } else {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
 …
+        }
+        if (dns_name) {
+                char *dns_encoded = ldb_binary_encode_string(mem_ctx, netbios_name);
+                char *netbios_encoded = ldb_binary_encode_string(mem_ctx, netbios_name);
+                /* search for the trusted_domain record */
+                ret = gendb_search(sam_ldb,
+                                   mem_ctx, policy_state->system_dn, &msgs, attrs,
+                                   "(&(|(flatname=%s)(cn=%s)(trustPartner=%s)(flatname=%s)(cn=%s)(trustPartner=%s))(objectclass=trustedDomain))",
+                                   dns_encoded, dns_encoded, dns_encoded, netbios_encoded, netbios_encoded, netbios_encoded);
+                if (ret > 0) {
+                        ldb_transaction_cancel(sam_ldb);
+                        return NT_STATUS_OBJECT_NAME_COLLISION;
+                }
+        } else {
+                char *netbios_encoded = ldb_binary_encode_string(mem_ctx, netbios_name);
+                /* search for the trusted_domain record */
+                ret = gendb_search(sam_ldb,
+                                   mem_ctx, policy_state->system_dn, &msgs, attrs,
+                                   "(&(|(flatname=%s)(cn=%s)(trustPartner=%s))(objectclass=trustedDomain))",
+                                   netbios_encoded, netbios_encoded, netbios_encoded);
+                if (ret > 0) {
+                        ldb_transaction_cancel(sam_ldb);
+                        return NT_STATUS_OBJECT_NAME_COLLISION;
+                }
+        }
+        if (ret < 0 ) {
+        /* search for the trusted_domain record */
+        ret = gendb_search(sam_ldb,
+                           mem_ctx, policy_state->system_dn, &msgs, attrs,
+                           "(&(objectClass=trustedDomain)(|"
+                             "(flatname=%s)(trustPartner=%s)"
+                             "(flatname=%s)(trustPartner=%s)"
+                             "(securityIdentifier=%s)))",
+                           dns_encoded, dns_encoded,
+                           netbios_encoded, netbios_encoded,
+                           sid_encoded);
+        if (ret > 0) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_OBJECT_NAME_COLLISION;
+        }
+        if (ret < 0) {
                 ldb_transaction_cancel(sam_ldb);
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
-        name = dns_name ? dns_name : netbios_name;
         msg = ldb_msg_new(mem_ctx);
         if (msg == NULL) {
 …
         msg->dn = ldb_dn_copy(mem_ctx, policy_state->system_dn);
         if ( ! ldb_dn_add_child_fmt(msg->dn, "cn=%s", name)) {
+        if ( ! ldb_dn_add_child_fmt(msg->dn, "cn=%s", dns_name)) {
                         ldb_transaction_cancel(sam_ldb);
                 return NT_STATUS_NO_MEMORY;
+        }
+        ldb_msg_add_string(msg, "flatname", netbios_name);
+        if (r->in.info->sid) {
+                ret = samdb_msg_add_dom_sid(sam_ldb, mem_ctx, msg, "securityIdentifier", r->in.info->sid);
+                if (ret != LDB_SUCCESS) {
+                        ldb_transaction_cancel(sam_ldb);
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
+        }
+        ldb_msg_add_string(msg, "objectClass", "trustedDomain");
+        samdb_msg_add_int(sam_ldb, mem_ctx, msg, "trustType", r->in.info->trust_type);
+        samdb_msg_add_int(sam_ldb, mem_ctx, msg, "trustAttributes", r->in.info->trust_attributes);
+        samdb_msg_add_int(sam_ldb, mem_ctx, msg, "trustDirection", r->in.info->trust_direction);
+        if (dns_name) {
+                ldb_msg_add_string(msg, "trustPartner", dns_name);
+        ret = ldb_msg_add_string(msg, "objectClass", "trustedDomain");
+        if (ret != LDB_SUCCESS) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_NO_MEMORY;;
+        }
+        ret = ldb_msg_add_string(msg, "flatname", netbios_name);
+        if (ret != LDB_SUCCESS) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_NO_MEMORY;
+        }
+        ret = ldb_msg_add_string(msg, "trustPartner", dns_name);
+        if (ret != LDB_SUCCESS) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_NO_MEMORY;;
+        }
+        ret = samdb_msg_add_dom_sid(sam_ldb, mem_ctx, msg, "securityIdentifier",
+                                    r->in.info->sid);
+        if (ret != LDB_SUCCESS) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_NO_MEMORY;;
+        }
+        ret = samdb_msg_add_int(sam_ldb, mem_ctx, msg, "trustType", r->in.info->trust_type);
+        if (ret != LDB_SUCCESS) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_NO_MEMORY;;
+        }
+        ret = samdb_msg_add_int(sam_ldb, mem_ctx, msg, "trustAttributes", r->in.info->trust_attributes);
+        if (ret != LDB_SUCCESS) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_NO_MEMORY;;
+        }
+        ret = samdb_msg_add_int(sam_ldb, mem_ctx, msg, "trustDirection", r->in.info->trust_direction);
+        if (ret != LDB_SUCCESS) {
+                ldb_transaction_cancel(sam_ldb);
+                return NT_STATUS_NO_MEMORY;;
+        }
 …
+        }
+        /*
+         * Notify winbindd that we have a new trust
+         */
+        status = irpc_servers_byname(dce_call->msg_ctx,
+                                     mem_ctx,
+                                     "winbind_server",
+                                     &num_server_ids, &server_ids);
+        if (NT_STATUS_IS_OK(status) && num_server_ids >= 1) {
+                enum ndr_err_code ndr_err;
+                DATA_BLOB b = {};
+                ndr_err = ndr_push_struct_blob(&b, mem_ctx, r->in.info,
+                        (ndr_push_flags_fn_t)ndr_push_lsa_TrustDomainInfoInfoEx);
+                if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        imessaging_send(dce_call->msg_ctx, server_ids[0],
+                                MSG_WINBIND_NEW_TRUSTED_DOMAIN, &b);
+                }
+        }
+        TALLOC_FREE(server_ids);
         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
         if (!handle) {
 …
                                            struct lsa_CreateTrustedDomainEx2 *r)
+{
         return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, r, NDR_LSA_CREATETRUSTEDDOMAINEX2);
+        return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, r, NDR_LSA_CREATETRUSTEDDOMAINEX2, NULL);
+}
 /*
 …
         r2.in.policy_handle = r->in.policy_handle;
         r2.in.info = r->in.info;
-        r2.in.auth_info = r->in.auth_info;
         r2.out.trustdom_handle = r->out.trustdom_handle;
         return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, &r2, NDR_LSA_CREATETRUSTEDDOMAINEX);
+}
 /*
   lsa_CreateTrustedDomain
+        return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, &r2, NDR_LSA_CREATETRUSTEDDOMAINEX, r->in.auth_info);
+}
+/*
+  lsa_CreateTrustedDomain
 */
 static NTSTATUS dcesrv_lsa_CreateTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
+        }
         r2.in.info->domain_name.string = NULL;
+        r2.in.info->domain_name = r->in.info->name;
         r2.in.info->netbios_name = r->in.info->name;
         r2.in.info->sid = r->in.info->sid;
 …
         r2.in.info->trust_type = LSA_TRUST_TYPE_DOWNLEVEL;
         r2.in.info->trust_attributes = 0;
         r2.in.access_mask = r->in.access_mask;
         r2.out.trustdom_handle = r->out.trustdom_handle;
+        return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, &r2, NDR_LSA_CREATETRUSTEDDOMAIN);
+}
+/*
+  lsa_OpenTrustedDomain
+*/
+static NTSTATUS dcesrv_lsa_OpenTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                                      struct lsa_OpenTrustedDomain *r)
+{
+        struct dcesrv_handle *policy_handle;
+        struct lsa_policy_state *policy_state;
+        return dcesrv_lsa_CreateTrustedDomain_base(dce_call, mem_ctx, &r2, NDR_LSA_CREATETRUSTEDDOMAIN, NULL);
+}
+static NTSTATUS dcesrv_lsa_OpenTrustedDomain_common(
+                                        struct dcesrv_call_state *dce_call,
+                                        TALLOC_CTX *tmp_mem,
+                                        struct lsa_policy_state *policy_state,
+                                        const char *filter,
+                                        uint32_t access_mask,
+                                        struct dcesrv_handle **_handle)
+{
         struct lsa_trusted_domain_state *trusted_domain_state;
         struct dcesrv_handle *handle;
 …
                 NULL
         };
+        uint32_t direction;
+        int ret;
+        /* TODO: perform access checks */
+        /* search for the trusted_domain record */
+        ret = gendb_search(policy_state->sam_ldb, tmp_mem,
+                           policy_state->system_dn,
+                           &msgs, attrs, "%s", filter);
+        if (ret == 0) {
+                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+        }
+        if (ret != 1) {
+                DEBUG(0,("Found %d records matching %s under %s\n", ret,
+                         filter,
+                         ldb_dn_get_linearized(policy_state->system_dn)));
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
+        trusted_domain_state = talloc_zero(tmp_mem,
+                                           struct lsa_trusted_domain_state);
+        if (!trusted_domain_state) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        trusted_domain_state->policy = policy_state;
+        trusted_domain_state->trusted_domain_dn =
+                talloc_steal(trusted_domain_state, msgs[0]->dn);
+        direction = ldb_msg_find_attr_as_int(msgs[0], "trustDirection", 0);
+        if (direction & LSA_TRUST_DIRECTION_INBOUND) {
+                const char *flatname = ldb_msg_find_attr_as_string(msgs[0],
+                                                        "flatname", NULL);
+                /* search for the trusted_domain account */
+                ret = gendb_search(policy_state->sam_ldb, tmp_mem,
+                                   policy_state->domain_dn,
+                                   &msgs, attrs,
+                                   "(&(samaccountname=%s$)(objectclass=user)"
+                                   "(userAccountControl:%s:=%u))",
+                                   flatname,
+                                   LDB_OID_COMPARATOR_AND,
+                                   UF_INTERDOMAIN_TRUST_ACCOUNT);
+                if (ret == 1) {
+                        trusted_domain_state->trusted_domain_user_dn =
+                                talloc_steal(trusted_domain_state, msgs[0]->dn);
+                }
+        }
+        handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
+        if (!handle) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        handle->data = talloc_steal(handle, trusted_domain_state);
+        trusted_domain_state->access_mask = access_mask;
+        trusted_domain_state->policy = talloc_reference(trusted_domain_state,
+                                                        policy_state);
+        *_handle = handle;
+        return NT_STATUS_OK;
+}
+/*
+  lsa_OpenTrustedDomain
+*/
+static NTSTATUS dcesrv_lsa_OpenTrustedDomain(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                                      struct lsa_OpenTrustedDomain *r)
+{
+        struct dcesrv_handle *policy_handle;
+        struct lsa_policy_state *policy_state;
+        struct dcesrv_handle *handle;
         const char *sid_string;
+        int ret;
+        char *filter;
+        NTSTATUS status;
         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
 …
         policy_state = policy_handle->data;
-        trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
-        if (!trusted_domain_state) {
-                return NT_STATUS_NO_MEMORY;
+        }
-        trusted_domain_state->policy = policy_state;
         sid_string = dom_sid_string(mem_ctx, r->in.sid);
         if (!sid_string) {
 …
+        }
+        /* search for the trusted_domain record */
+        ret = gendb_search(trusted_domain_state->policy->sam_ldb,
+                           mem_ctx, policy_state->system_dn, &msgs, attrs,
+                           "(&(securityIdentifier=%s)(objectclass=trustedDomain))",
+                           sid_string);
+        if (ret == 0) {
+                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+        }
+        if (ret != 1) {
+                DEBUG(0,("Found %d records matching DN %s\n", ret,
+                         ldb_dn_get_linearized(policy_state->system_dn)));
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
+        trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msgs[0]->dn);
+        trusted_domain_state->trusted_domain_user_dn = NULL;
+        if (ldb_msg_find_attr_as_int(msgs[0], "trustDirection", 0) & LSA_TRUST_DIRECTION_INBOUND) {
+                const char *flatname = ldb_binary_encode_string(mem_ctx, ldb_msg_find_attr_as_string(msgs[0], "flatname", NULL));
+                /* search for the trusted_domain record */
+                ret = gendb_search(trusted_domain_state->policy->sam_ldb,
+                                   mem_ctx, policy_state->domain_dn, &msgs, attrs,
+                                   "(&(samaccountname=%s$)(objectclass=user)(userAccountControl:1.2.840.113556.1.4.803:=%u))",
+                                   flatname, UF_INTERDOMAIN_TRUST_ACCOUNT);
+                if (ret == 1) {
+                        trusted_domain_state->trusted_domain_user_dn = talloc_steal(trusted_domain_state, msgs[0]->dn);
+                }
+        }
+        handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
+        if (!handle) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        handle->data = talloc_steal(handle, trusted_domain_state);
+        trusted_domain_state->access_mask = r->in.access_mask;
+        trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
+        filter = talloc_asprintf(mem_ctx,
+                                 "(&(securityIdentifier=%s)"
+                                 "(objectclass=trustedDomain))",
+                                 sid_string);
+        if (filter == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        status = dcesrv_lsa_OpenTrustedDomain_common(dce_call, mem_ctx,
+                                                     policy_state,
+                                                     filter,
+                                                     r->in.access_mask,
+                                                     &handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         *r->out.trustdom_handle = handle->wire_handle;
         return NT_STATUS_OK;
+}
 …
+{
         struct dcesrv_handle *policy_handle;
         struct lsa_policy_state *policy_state;
-        struct lsa_trusted_domain_state *trusted_domain_state;
         struct dcesrv_handle *handle;
-        struct ldb_message **msgs;
-        const char *attrs[] = {
-                NULL
-        };
         char *td_name;
+        int ret;
+        char *filter;
+        NTSTATUS status;
         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
 …
+        }
-        trusted_domain_state = talloc_zero(mem_ctx, struct lsa_trusted_domain_state);
-        if (!trusted_domain_state) {
-                return NT_STATUS_NO_MEMORY;
+        }
-        trusted_domain_state->policy = policy_state;
         /* search for the trusted_domain record */
         td_name = ldb_binary_encode_string(mem_ctx, r->in.name.string);
+        ret = gendb_search(trusted_domain_state->policy->sam_ldb,
+                           mem_ctx, policy_state->system_dn, &msgs, attrs,
+        if (td_name == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        filter = talloc_asprintf(mem_ctx,
                            "(&(|(flatname=%s)(cn=%s)(trustPartner=%s))"
                              "(objectclass=trustedDomain))",
                            td_name, td_name, td_name);
+        if (ret == 0) {
+                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+        }
+        if (ret != 1) {
+                DEBUG(0,("Found %d records matching DN %s\n", ret,
+                         ldb_dn_get_linearized(policy_state->system_dn)));
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
+        /* TODO: perform access checks */
+        trusted_domain_state->trusted_domain_dn = talloc_reference(trusted_domain_state, msgs[0]->dn);
+        handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_TRUSTED_DOMAIN);
+        if (!handle) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        handle->data = talloc_steal(handle, trusted_domain_state);
+        trusted_domain_state->access_mask = r->in.access_mask;
+        trusted_domain_state->policy = talloc_reference(trusted_domain_state, policy_state);
+        if (filter == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        status = dcesrv_lsa_OpenTrustedDomain_common(dce_call, mem_ctx,
+                                                     policy_state,
+                                                     filter,
+                                                     r->in.access_mask,
+                                                     &handle);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         *r->out.trustdom_handle = handle->wire_handle;
 …
 /*
+/*
   lsa_SetTrustedDomainInfo
 */
 …
                                 "trustType", "trustAttributes",
                                 "trustPosixOffset",
+                                "msDs-supportedEncryptionTypes", NULL };
+                                "msDs-supportedEncryptionTypes",
+                                "msDS-TrustForestTrustInfo",
+                                NULL
+        };
         char *dns = NULL;
         char *nbn = NULL;
 …
         const struct ldb_val *orig_val;
         uint32_t orig_uint = 0;
         int flags = 0;
+        unsigned int flags = 0;
         int ret;
 …
         /* entry exists, just modify secret if any */
         if (in->count == 0) {
+        if (in == NULL || in->count == 0) {
                 return NT_STATUS_OK;
+        }
 …
 static NTSTATUS setInfoTrustedDomain_base(struct dcesrv_call_state *dce_call,
                                           struct dcesrv_handle *p_handle,
+                                          struct lsa_policy_state *p_state,
                                           TALLOC_CTX *mem_ctx,
                                           struct ldb_message *dom_msg,
 …
                                           union lsa_TrustedDomainInfo *info)
+{
-        struct lsa_policy_state *p_state = p_handle->data;
         uint32_t *posix_offset = NULL;
         struct lsa_TrustDomainInfoInfoEx *info_ex = NULL;
 …
         DATA_BLOB trustAuthIncoming, trustAuthOutgoing, auth_blob;
         struct trustDomainPasswords auth_struct;
+        struct trustAuthInOutBlob *current_passwords = NULL;
         NTSTATUS nt_status;
         struct ldb_message **msgs;
 …
         bool del_outgoing = false;
         bool del_incoming = false;
+        bool del_forest_info = false;
         bool in_transaction = false;
         int ret;
 …
         if (auth_info) {
+                /* FIXME: not handled yet */
+                return NT_STATUS_INVALID_PARAMETER;
+                nt_status = auth_info_2_auth_blob(mem_ctx, auth_info,
+                                                  &trustAuthIncoming,
+                                                  &trustAuthOutgoing);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
+                if (trustAuthIncoming.data) {
+                        /* This does the decode of some of this twice, but it is easier that way */
+                        nt_status = auth_info_2_trustauth_inout(mem_ctx,
+                                                                auth_info->incoming_count,
+                                                                auth_info->incoming_current_auth_info,
+                                                                NULL,
+                                                                &current_passwords);
+                        if (!NT_STATUS_IS_OK(nt_status)) {
+                                return nt_status;
+                        }
+                }
+        }
 …
         /* TODO: should we fetch previous values from the existing entry
          * and append them ? */
         if (auth_struct.incoming.count) {
+        if (auth_info_int && auth_struct.incoming.count) {
                 nt_status = get_trustauth_inout_blob(dce_call, mem_ctx,
                                                      &auth_struct.incoming,
 …
                         return nt_status;
+                }
+                current_passwords = &auth_struct.incoming;
         } else {
                 trustAuthIncoming = data_blob(NULL, 0);
+        }
         if (auth_struct.outgoing.count) {
+        if (auth_info_int && auth_struct.outgoing.count) {
                 nt_status = get_trustauth_inout_blob(dce_call, mem_ctx,
                                                      &auth_struct.outgoing,
 …
         if (info_ex) {
                 uint32_t origattrs;
+                uint32_t changed_attrs;
                 uint32_t origdir;
-                uint32_t tmp;
                 int origtype;
 …
+                }
+                tmp = info_ex->trust_direction ^ origdir;
+                if (tmp & LSA_TRUST_DIRECTION_INBOUND) {
+                        if (origdir & LSA_TRUST_DIRECTION_INBOUND) {
+                                del_incoming = true;
+                        } else {
+                if (info_ex->trust_direction & LSA_TRUST_DIRECTION_INBOUND) {
+                        if (auth_info != NULL && trustAuthIncoming.length > 0) {
                                 add_incoming = true;
+                        }
+                }
+                if (tmp & LSA_TRUST_DIRECTION_OUTBOUND) {
+                        if (origdir & LSA_TRUST_DIRECTION_OUTBOUND) {
+                                del_outgoing = true;
+                        } else {
+                if (info_ex->trust_direction & LSA_TRUST_DIRECTION_OUTBOUND) {
+                        if (auth_info != NULL && trustAuthOutgoing.length > 0) {
                                 add_outgoing = true;
+                        }
+                }
+                if ((origdir & LSA_TRUST_DIRECTION_INBOUND) &&
+                    !(info_ex->trust_direction & LSA_TRUST_DIRECTION_INBOUND)) {
+                        del_incoming = true;
+                }
+                if ((origdir & LSA_TRUST_DIRECTION_OUTBOUND) &&
+                    !(info_ex->trust_direction & LSA_TRUST_DIRECTION_OUTBOUND)) {
+                        del_outgoing = true;
+                }
 …
                 /* TODO: check forestFunctionality from ldb opaque */
                 /* TODO: check what is set makes sense */
+                /* for now refuse changes */
+                if (origattrs == -1 ||
+                    origattrs != info_ex->trust_attributes) {
+                        DEBUG(1, ("Attempted to change trust attributes! "
+                                  "Operation not handled\n"));
+                changed_attrs = origattrs ^ info_ex->trust_attributes;
+                if (changed_attrs & ~LSA_TRUST_ATTRIBUTE_FOREST_TRANSITIVE) {
+                        /*
+                         * For now we only allow
+                         * LSA_TRUST_ATTRIBUTE_FOREST_TRANSITIVE to be changed.
+                         *
+                         * TODO: we may need to support more attribute changes
+                         */
+                        DEBUG(1, ("Attempted to change trust attributes "
+                                  "(0x%08x != 0x%08x)! "
+                                  "Operation not handled yet...\n",
+                                  (unsigned)origattrs,
+                                  (unsigned)info_ex->trust_attributes));
                         return NT_STATUS_INVALID_PARAMETER;
+                }
+                if (!(info_ex->trust_attributes &
+                      LSA_TRUST_ATTRIBUTE_FOREST_TRANSITIVE))
+                {
+                        struct ldb_message_element *orig_forest_el = NULL;
+                        orig_forest_el = ldb_msg_find_element(dom_msg,
+                                                "msDS-TrustForestTrustInfo");
+                        if (orig_forest_el != NULL) {
+                                del_forest_info = true;
+                        }
+                }
+        }
 …
+        }
         if (add_incoming && trustAuthIncoming.data) {
+        if (add_incoming || del_incoming) {
                 ret = ldb_msg_add_empty(msg, "trustAuthIncoming",
                                         LDB_FLAG_MOD_REPLACE, NULL);
 …
                         return NT_STATUS_NO_MEMORY;
+                }
+                ret = ldb_msg_add_value(msg, "trustAuthIncoming",
+                                        &trustAuthIncoming, NULL);
+                if (ret != LDB_SUCCESS) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+        }
+        if (add_outgoing && trustAuthOutgoing.data) {
+                ret = ldb_msg_add_empty(msg, "trustAuthIncoming",
+                if (add_incoming) {
+                        ret = ldb_msg_add_value(msg, "trustAuthIncoming",
+                                                &trustAuthIncoming, NULL);
+                        if (ret != LDB_SUCCESS) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                }
+        }
+        if (add_outgoing || del_outgoing) {
+                ret = ldb_msg_add_empty(msg, "trustAuthOutgoing",
                                         LDB_FLAG_MOD_REPLACE, NULL);
                 if (ret != LDB_SUCCESS) {
                         return NT_STATUS_NO_MEMORY;
+                }
+                ret = ldb_msg_add_value(msg, "trustAuthOutgoing",
+                                        &trustAuthOutgoing, NULL);
+                if (add_outgoing) {
+                        ret = ldb_msg_add_value(msg, "trustAuthOutgoing",
+                                                &trustAuthOutgoing, NULL);
+                        if (ret != LDB_SUCCESS) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                }
+        }
+        if (del_forest_info) {
+                ret = ldb_msg_add_empty(msg, "msDS-TrustForestTrustInfo",
+                                        LDB_FLAG_MOD_REPLACE, NULL);
                 if (ret != LDB_SUCCESS) {
                         return NT_STATUS_NO_MEMORY;
 …
         in_transaction = true;
+        ret = ldb_modify(p_state->sam_ldb, msg);
+        if (ret != LDB_SUCCESS) {
+                DEBUG(1,("Failed to modify trusted domain record %s: %s\n",
+                         ldb_dn_get_linearized(msg->dn),
+                         ldb_errstring(p_state->sam_ldb)));
+                if (ret == LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS) {
+                        nt_status = NT_STATUS_ACCESS_DENIED;
+                } else {
+                        nt_status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                }
+                goto done;
+        if (msg->num_elements) {
+                ret = ldb_modify(p_state->sam_ldb, msg);
+                if (ret != LDB_SUCCESS) {
+                        DEBUG(1,("Failed to modify trusted domain record %s: %s\n",
+                                 ldb_dn_get_linearized(msg->dn),
+                                 ldb_errstring(p_state->sam_ldb)));
+                        nt_status = dsdb_ldb_err_to_ntstatus(ret);
+                        goto done;
+                }
+        }
 …
+                }
+                /* We use trustAuthIncoming.data to incidate that auth_struct.incoming is valid */
                 nt_status = update_trust_user(mem_ctx,
                                               p_state->sam_ldb,
 …
                                               del_incoming,
                                               netbios_name,
                                               &auth_struct.incoming);
+                                              current_passwords);
                 if (!NT_STATUS_IS_OK(nt_status)) {
                         goto done;
 …
+        }
         return setInfoTrustedDomain_base(dce_call, h, mem_ctx,
+        return setInfoTrustedDomain_base(dce_call, td_state->policy, mem_ctx,
                                          msgs[0], r->in.level, r->in.info);
+}
 /*
+/*
   lsa_DeleteTrustedDomain
 */
 …
+{
         NTSTATUS status;
         struct lsa_OpenTrustedDomain opn;
+        struct lsa_OpenTrustedDomain opn = {{0},{0}};
         struct lsa_DeleteObject del;
         struct dcesrv_handle *h;
 …
+}
 static NTSTATUS fill_trust_domain_ex(TALLOC_CTX *mem_ctx,
                                      struct ldb_message *msg,
                                      struct lsa_TrustDomainInfoInfoEx *info_ex)
+static NTSTATUS fill_trust_domain_ex(TALLOC_CTX *mem_ctx,
+                                     struct ldb_message *msg,
+                                     struct lsa_TrustDomainInfoInfoEx *info_ex)
+{
         info_ex->domain_name.string
 …
         info_ex->netbios_name.string
                 = ldb_msg_find_attr_as_string(msg, "flatname", NULL);
         info_ex->sid
+        info_ex->sid
                 = samdb_result_dom_sid(mem_ctx, msg, "securityIdentifier");
         info_ex->trust_direction
 …
                 = ldb_msg_find_attr_as_int(msg, "trustType", 0);
         info_ex->trust_attributes
                 = ldb_msg_find_attr_as_int(msg, "trustAttributes", 0);
+                = ldb_msg_find_attr_as_int(msg, "trustAttributes", 0);
         return NT_STATUS_OK;
+}
 /*
+/*
   lsa_QueryTrustedDomainInfo
 */
 …
         struct ldb_message **res;
         const char *attrs[] = {
                 "flatname",
+                "flatname",
                 "trustPartner",
                 "securityIdentifier",
                 "trustDirection",
                 "trustType",
                 "trustAttributes",
+                "trustAttributes",
                 "msDs-supportedEncryptionTypes",
                 NULL
 …
+        }
         msg = res[0];
         info = talloc_zero(mem_ctx, union lsa_TrustedDomainInfo);
         if (!info) {
 …
 #if 0  /* Win2k3 doesn't implement this */
         case LSA_TRUSTED_DOMAIN_INFO_BASIC:
                 r->out.info->info_basic.netbios_name.string
+                r->out.info->info_basic.netbios_name.string
                         = ldb_msg_find_attr_as_string(msg, "flatname", NULL);
                 r->out.info->info_basic.sid
 …
                         = ldb_msg_find_attr_as_uint(msg, "posixOffset", 0);
                 return fill_trust_domain_ex(mem_ctx, msg, &info->full_info2_internal.info.info_ex);
         case LSA_TRUSTED_DOMAIN_SUPPORTED_ENCRYPTION_TYPES:
                 info->enc_types.enc_types
 …
 /*
+/*
   lsa_QueryTrustedDomainInfoBySid
 */
 …
+{
         NTSTATUS status;
         struct lsa_OpenTrustedDomain opn;
+        struct lsa_OpenTrustedDomain opn = {{0},{0}};
         struct lsa_QueryTrustedDomainInfo query;
         struct dcesrv_handle *h;
 …
+        }
         return setInfoTrustedDomain_base(dce_call, policy_handle, mem_ctx,
+        return setInfoTrustedDomain_base(dce_call, policy_state, mem_ctx,
                                          msgs[0], r->in.level, r->in.info);
+}
 /*
+/*
    lsa_QueryTrustedDomainInfoByName
 */
 …
+{
         NTSTATUS status;
         struct lsa_OpenTrustedDomainByName opn;
+        struct lsa_OpenTrustedDomainByName opn = {{0},{0}};
         struct lsa_QueryTrustedDomainInfo query;
         struct dcesrv_handle *h;
 …
                 return status;
+        }
         /* Ensure this handle goes away at the end of this call */
         DCESRV_PULL_HANDLE(h, opn.out.trustdom_handle, DCESRV_HANDLE_ANY);
 …
                 return status;
+        }
         return NT_STATUS_OK;
+}
 /*
   lsa_CloseTrustedDomainEx
+  lsa_CloseTrustedDomainEx
 */
 static NTSTATUS dcesrv_lsa_CloseTrustedDomainEx(struct dcesrv_call_state *dce_call,
 …
+}
 /*
   lsa_EnumTrustDom
+/*
+  lsa_EnumTrustDom
 */
 static NTSTATUS dcesrv_lsa_EnumTrustDom(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
         struct ldb_message **domains;
         const char *attrs[] = {
                 "flatname",
+                "flatname",
                 "securityIdentifier",
                 NULL
 …
         policy_state = policy_handle->data;
         /* search for all users in this domain. This could possibly be cached and
+        /* search for all users in this domain. This could possibly be cached and
            resumed based on resume_key */
         count = gendb_search(policy_state->sam_ldb, mem_ctx, policy_state->system_dn, &domains, attrs,
+        count = gendb_search(policy_state->sam_ldb, mem_ctx, policy_state->system_dn, &domains, attrs,
                              "objectclass=trustedDomain");
         if (count < 0) {
 …
+        }
         /* return the rest, limit by max_size. Note that we
+        /* return the rest, limit by max_size. Note that we
            use the w2k3 element size value of 60 */
         r->out.domains->count = count - *r->in.resume_handle;
         r->out.domains->count = MIN(r->out.domains->count,
+        r->out.domains->count = MIN(r->out.domains->count,
 +(r->in.max_size/LSA_ENUM_TRUST_DOMAIN_MULTIPLIER));
 …
+}
 /*
   lsa_EnumTrustedDomainsEx
+/*
+  lsa_EnumTrustedDomainsEx
 */
 static NTSTATUS dcesrv_lsa_EnumTrustedDomainsEx(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
         struct ldb_message **domains;
         const char *attrs[] = {
                 "flatname",
+                "flatname",
                 "trustPartner",
                 "securityIdentifier",
                 "trustDirection",
                 "trustType",
                 "trustAttributes",
+                "trustAttributes",
                 NULL
         };
 …
         policy_state = policy_handle->data;
         /* search for all users in this domain. This could possibly be cached and
+        /* search for all users in this domain. This could possibly be cached and
            resumed based on resume_key */
         count = gendb_search(policy_state->sam_ldb, mem_ctx, policy_state->system_dn, &domains, attrs,
+        count = gendb_search(policy_state->sam_ldb, mem_ctx, policy_state->system_dn, &domains, attrs,
                              "objectclass=trustedDomain");
         if (count < 0) {
 …
+        }
         /* return the rest, limit by max_size. Note that we
+        /* return the rest, limit by max_size. Note that we
            use the w2k3 element size value of 60 */
         r->out.domains->count = count - *r->in.resume_handle;
         r->out.domains->count = MIN(r->out.domains->count,
+        r->out.domains->count = MIN(r->out.domains->count,
 +(r->in.max_size/LSA_ENUM_TRUST_DOMAIN_EX_MULTIPLIER));
 …
+        }
+        *r->out.resume_handle = *r->in.resume_handle + r->out.domains->count;
         return NT_STATUS_OK;
+}
 /*
   lsa_OpenAccount
+/*
+  lsa_OpenAccount
 */
 static NTSTATUS dcesrv_lsa_OpenAccount(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
                 return NT_STATUS_NO_MEMORY;
+        }
         astate->policy = talloc_reference(astate, state);
         astate->access_mask = r->in.access_mask;
+        /*
+         * For now we grant all requested access.
+         *
+         * We will fail at the ldb layer later.
+         */
+        if (astate->access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
+                astate->access_mask &= ~SEC_FLAG_MAXIMUM_ALLOWED;
+                astate->access_mask |= LSA_ACCOUNT_ALL_ACCESS;
+        }
+        se_map_generic(&astate->access_mask, &dcesrv_lsa_account_mapping);
+        DEBUG(10,("%s: %s access desired[0x%08X] granted[0x%08X] - success.\n",
+                  __func__, dom_sid_string(mem_ctx, astate->account_sid),
+                 (unsigned)r->in.access_mask,
+                 (unsigned)astate->access_mask));
         ah = dcesrv_handle_new(dce_call->context, LSA_HANDLE_ACCOUNT);
 …
 /*
   lsa_EnumPrivsAccount
 */
 static NTSTATUS dcesrv_lsa_EnumPrivsAccount(struct dcesrv_call_state *dce_call,
+/*
+  lsa_EnumPrivsAccount
+*/
+static NTSTATUS dcesrv_lsa_EnumPrivsAccount(struct dcesrv_call_state *dce_call,
                                      TALLOC_CTX *mem_ctx,
                                      struct lsa_EnumPrivsAccount *r)
 …
+        }
         ret = gendb_search(astate->policy->pdb, mem_ctx, NULL, &res, attrs,
+        ret = gendb_search(astate->policy->pdb, mem_ctx, NULL, &res, attrs,
                            "objectSid=%s", sidstr);
         if (ret < 0) {
 …
+}
 /*
   lsa_EnumAccountRights
 */
 static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
+/*
+  lsa_EnumAccountRights
+*/
+static NTSTATUS dcesrv_lsa_EnumAccountRights(struct dcesrv_call_state *dce_call,
                                       TALLOC_CTX *mem_ctx,
                                       struct lsa_EnumAccountRights *r)
 …
+        }
         ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs,
+        ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs,
                            "(&(objectSid=%s)(privilege=*))", sidstr);
         if (ret == 0) {
 …
+        }
         if (ret != 1) {
                 DEBUG(3, ("searching for account rights for SID: %s failed: %s",
+                DEBUG(3, ("searching for account rights for SID: %s failed: %s",
                           dom_sid_string(mem_ctx, r->in.sid),
                           ldb_errstring(state->pdb)));
 …
         r->out.rights->count = el->num_values;
         r->out.rights->names = talloc_array(r->out.rights,
+        r->out.rights->names = talloc_array(r->out.rights,
                                             struct lsa_StringLarge, r->out.rights->count);
         if (r->out.rights->names == NULL) {
 …
 /*
+/*
   helper for lsa_AddAccountRights and lsa_RemoveAccountRights
 */
 static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_AddRemoveAccountRights(struct dcesrv_call_state *dce_call,
                                            TALLOC_CTX *mem_ctx,
                                            struct lsa_policy_state *state,
 …
         sidndrstr = ldap_encode_ndr_dom_sid(msg, sid);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sidndrstr, msg);
+        if (sidndrstr == NULL) {
+                TALLOC_FREE(msg);
+                return NT_STATUS_NO_MEMORY;
+        }
         sidstr = dom_sid_string(msg, sid);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sidstr, msg);
+        if (sidstr == NULL) {
+                TALLOC_FREE(msg);
+                return NT_STATUS_NO_MEMORY;
+        }
         dnstr = talloc_asprintf(msg, "sid=%s", sidstr);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(dnstr, msg);
+        if (dnstr == NULL) {
+                TALLOC_FREE(msg);
+                return NT_STATUS_NO_MEMORY;
+        }
         msg->dn = ldb_dn_new(msg, state->pdb, dnstr);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg->dn, msg);
+        if (msg->dn == NULL) {
+                TALLOC_FREE(msg);
+                return NT_STATUS_NO_MEMORY;
+        }
         if (LDB_FLAG_MOD_TYPE(ldb_flag) == LDB_FLAG_MOD_ADD) {
 …
                         uint32_t j;
                         for (j=0;j<r2.out.rights->count;j++) {
                                 if (strcasecmp_m(r2.out.rights->names[j].string,
+                                if (strcasecmp_m(r2.out.rights->names[j].string,
                                                rights->names[i].string) == 0) {
                                         break;
 …
+                }
                 ldb_msg_add_string(msg, "comment", "added via LSA");
                 ret = ldb_add(state->pdb, msg);
+                ret = ldb_add(state->pdb, msg);
+        }
         if (ret != LDB_SUCCESS) {
 …
                         return NT_STATUS_OK;
+                }
                 DEBUG(3, ("Could not %s attributes from %s: %s",
+                DEBUG(3, ("Could not %s attributes from %s: %s",
                           LDB_FLAG_MOD_TYPE(ldb_flag) == LDB_FLAG_MOD_DELETE ? "delete" : "add",
                           ldb_dn_get_linearized(msg->dn), ldb_errstring(state->pdb)));
 …
+}
 /*
+/*
   lsa_AddPrivilegesToAccount
 */
 …
+        }
         return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
+        return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
                                           LDB_FLAG_MOD_ADD, astate->account_sid,
                                           &rights);
 …
 /*
+/*
   lsa_RemovePrivilegesFromAccount
 */
 …
         rights = talloc(mem_ctx, struct lsa_RightSet);
         if (r->in.remove_all == 1 &&
+        if (r->in.remove_all == 1 &&
             r->in.privs == NULL) {
                 struct lsa_EnumAccountRights r2;
 …
+                }
                 return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
+                return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
                                                   LDB_FLAG_MOD_DELETE, astate->account_sid,
                                                   r2.out.rights);
 …
+        }
         return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
+        return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, astate->policy,
                                           LDB_FLAG_MOD_DELETE, astate->account_sid,
                                           rights);
 …
 /*
+/*
   lsa_GetQuotasForAccount
 */
 …
 /*
+/*
   lsa_SetQuotasForAccount
 */
 …
 /*
+/*
   lsa_GetSystemAccessAccount
 */
 …
+        }
         ret = gendb_search(astate->policy->pdb, mem_ctx, NULL, &res, attrs,
+        ret = gendb_search(astate->policy->pdb, mem_ctx, NULL, &res, attrs,
                            "objectSid=%s", sidstr);
         if (ret < 0) {
 …
 /*
+/*
   lsa_SetSystemAccessAccount
 */
 …
 /*
   lsa_CreateSecret
+/*
+  lsa_CreateSecret
 */
 static NTSTATUS dcesrv_lsa_CreateSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
         DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
         ZERO_STRUCTP(r->out.sec_handle);
         switch (security_session_user_level(dce_call->conn->auth_state.session_info, NULL))
+        {
 …
                 return NT_STATUS_INVALID_PARAMETER;
+        }
         secret_state = talloc(mem_ctx, struct lsa_secret_state);
         NT_STATUS_HAVE_NO_MEMORY(secret_state);
 …
                 ret = gendb_search(secret_state->sam_ldb,
                                    mem_ctx, policy_state->system_dn, &msgs, attrs,
                                    "(&(cn=%s)(objectclass=secret))",
+                                   "(&(cn=%s)(objectclass=secret))",
                                    name2);
                 if (ret > 0) {
                         return NT_STATUS_OBJECT_NAME_COLLISION;
+                }
                 if (ret < 0) {
                         DEBUG(0,("Failure searching for CN=%s: %s\n",
+                        DEBUG(0,("Failure searching for CN=%s: %s\n",
                                  name2, ldb_errstring(secret_state->sam_ldb)));
                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 …
+                }
                 secret_state->sam_ldb = talloc_reference(secret_state,
+                secret_state->sam_ldb = talloc_reference(secret_state,
                                                          secrets_db_connect(mem_ctx, dce_call->conn->dce_ctx->lp_ctx));
                 NT_STATUS_HAVE_NO_MEMORY(secret_state->sam_ldb);
 …
                                    ldb_dn_new(mem_ctx, secret_state->sam_ldb, "cn=LSA Secrets"),
                                    &msgs, attrs,
                                    "(&(cn=%s)(objectclass=secret))",
+                                   "(&(cn=%s)(objectclass=secret))",
                                    ldb_binary_encode_string(mem_ctx, name));
                 if (ret > 0) {
                         return NT_STATUS_OBJECT_NAME_COLLISION;
+                }
                 if (ret < 0) {
                         DEBUG(0,("Failure searching for CN=%s: %s\n",
+                        DEBUG(0,("Failure searching for CN=%s: %s\n",
                                  name, ldb_errstring(secret_state->sam_ldb)));
                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
 …
                 ret = ldb_msg_add_string(msg, "cn", name);
                 if (ret != LDB_SUCCESS) return NT_STATUS_NO_MEMORY;
+        }
+        }
         ret = ldb_msg_add_string(msg, "objectClass", "secret");
         if (ret != LDB_SUCCESS) return NT_STATUS_NO_MEMORY;
         secret_state->secret_dn = talloc_reference(secret_state, msg->dn);
         NT_STATUS_HAVE_NO_MEMORY(secret_state->secret_dn);
 …
         if (ret != LDB_SUCCESS) {
                 DEBUG(0,("Failed to create secret record %s: %s\n",
                          ldb_dn_get_linearized(msg->dn),
+                         ldb_dn_get_linearized(msg->dn),
                          ldb_errstring(secret_state->sam_ldb)));
                 return NT_STATUS_ACCESS_DENIED;
 …
         handle->data = talloc_steal(handle, secret_state);
         secret_state->access_mask = r->in.access_mask;
         secret_state->policy = talloc_reference(secret_state, policy_state);
         NT_STATUS_HAVE_NO_MEMORY(secret_state->policy);
         *r->out.sec_handle = handle->wire_handle;
         return NT_STATUS_OK;
+}
 /*
   lsa_OpenSecret
+/*
+  lsa_OpenSecret
 */
 static NTSTATUS dcesrv_lsa_OpenSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
+{
         struct dcesrv_handle *policy_handle;
         struct lsa_policy_state *policy_state;
         struct lsa_secret_state *secret_state;
 …
                 return NT_STATUS_INVALID_PARAMETER;
+        }
         switch (security_session_user_level(dce_call->conn->auth_state.session_info, NULL))
+        {
 …
                 name = &r->in.name.string[2];
                 /* We need to connect to the database as system, as this is one of the rare RPC calls that must read the secrets (and this is denied otherwise) */
                 secret_state->sam_ldb = talloc_reference(secret_state,
+                secret_state->sam_ldb = talloc_reference(secret_state,
                                                          samdb_connect(mem_ctx, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, system_session(dce_call->conn->dce_ctx->lp_ctx), 0));
                 secret_state->global = true;
 …
                 ret = gendb_search(secret_state->sam_ldb,
                                    mem_ctx, policy_state->system_dn, &msgs, attrs,
                                    "(&(cn=%s Secret)(objectclass=secret))",
+                                   "(&(cn=%s Secret)(objectclass=secret))",
                                    ldb_binary_encode_string(mem_ctx, name));
                 if (ret == 0) {
                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+                }
                 if (ret != 1) {
                         DEBUG(0,("Found %d records matching DN %s\n", ret,
 …
                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                }
         } else {
                 secret_state->global = false;
                 secret_state->sam_ldb = talloc_reference(secret_state,
+                secret_state->sam_ldb = talloc_reference(secret_state,
                                                          secrets_db_connect(mem_ctx, dce_call->conn->dce_ctx->lp_ctx));
 …
                                    ldb_dn_new(mem_ctx, secret_state->sam_ldb, "cn=LSA Secrets"),
                                    &msgs, attrs,
                                    "(&(cn=%s)(objectclass=secret))",
+                                   "(&(cn=%s)(objectclass=secret))",
                                    ldb_binary_encode_string(mem_ctx, name));
                 if (ret == 0) {
                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+                }
                 if (ret != 1) {
                         DEBUG(0,("Found %d records matching CN=%s\n",
+                        DEBUG(0,("Found %d records matching CN=%s\n",
                                  ret, ldb_binary_encode_string(mem_ctx, name)));
                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                }
+        }
+        }
         secret_state->secret_dn = talloc_reference(secret_state, msgs[0]->dn);
         handle = dcesrv_handle_new(dce_call->context, LSA_HANDLE_SECRET);
         if (!handle) {
                 return NT_STATUS_NO_MEMORY;
+        }
         handle->data = talloc_steal(handle, secret_state);
         secret_state->access_mask = r->in.access_mask;
         secret_state->policy = talloc_reference(secret_state, policy_state);
         *r->out.sec_handle = handle->wire_handle;
         return NT_STATUS_OK;
+}
 /*
   lsa_SetSecret
+/*
+  lsa_SetSecret
 */
 static NTSTATUS dcesrv_lsa_SetSecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
                 crypt_secret.data = r->in.old_val->data;
                 crypt_secret.length = r->in.old_val->size;
                 status = sess_decrypt_blob(mem_ctx, &crypt_secret, &session_key, &secret);
                 if (!NT_STATUS_IS_OK(status)) {
                         return status;
+                }
                 val.data = secret.data;
                 val.length = secret.length;
                 /* set value */
                 if (ldb_msg_add_value(msg, "priorValue", &val, NULL) != LDB_SUCCESS) {
                         return NT_STATUS_NO_MEMORY;
+                }
+                        return NT_STATUS_NO_MEMORY;
+                }
                 /* set old value mtime */
                 if (samdb_msg_add_uint64(secret_state->sam_ldb,
+                if (samdb_msg_add_uint64(secret_state->sam_ldb,
                                          mem_ctx, msg, "priorSetTime", nt_now) != LDB_SUCCESS) {
                         return NT_STATUS_NO_MEMORY;
+                        return NT_STATUS_NO_MEMORY;
+                }
 …
                         NULL
                 };
                 /* search for the secret record */
                 ret = gendb_search_dn(secret_state->sam_ldb,mem_ctx,
 …
                         return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+                }
                 if (ret != 1) {
                         DEBUG(0,("Found %d records matching dn=%s\n", ret,
 …
                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                }
                 old_val = ldb_msg_find_ldb_val(res[0], "currentValue");
                 last_set_time = ldb_msg_find_attr_as_uint64(res[0], "lastSetTime", 0);
                 if (old_val) {
                         /* set old value */
                         if (ldb_msg_add_value(msg, "priorValue",
                                               old_val, NULL) != LDB_SUCCESS) {
                                 return NT_STATUS_NO_MEMORY;
+                                return NT_STATUS_NO_MEMORY;
+                        }
                 } else {
                         if (samdb_msg_add_delete(secret_state->sam_ldb,
+                        if (samdb_msg_add_delete(secret_state->sam_ldb,
                                                  mem_ctx, msg, "priorValue") != LDB_SUCCESS) {
                                 return NT_STATUS_NO_MEMORY;
+                        }
+                }
+                }
                 /* set old value mtime */
                 if (ldb_msg_find_ldb_val(res[0], "lastSetTime")) {
                         if (samdb_msg_add_uint64(secret_state->sam_ldb,
+                        if (samdb_msg_add_uint64(secret_state->sam_ldb,
                                                  mem_ctx, msg, "priorSetTime", last_set_time) != LDB_SUCCESS) {
                                 return NT_STATUS_NO_MEMORY;
+                                return NT_STATUS_NO_MEMORY;
+                        }
                 } else {
                         if (samdb_msg_add_uint64(secret_state->sam_ldb,
+                        if (samdb_msg_add_uint64(secret_state->sam_ldb,
                                                  mem_ctx, msg, "priorSetTime", nt_now) != LDB_SUCCESS) {
                                 return NT_STATUS_NO_MEMORY;
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                }
 …
                 crypt_secret.data = r->in.new_val->data;
                 crypt_secret.length = r->in.new_val->size;
                 status = sess_decrypt_blob(mem_ctx, &crypt_secret, &session_key, &secret);
                 if (!NT_STATUS_IS_OK(status)) {
                         return status;
+                }
                 val.data = secret.data;
                 val.length = secret.length;
                 /* set value */
                 if (ldb_msg_add_value(msg, "currentValue", &val, NULL) != LDB_SUCCESS) {
                         return NT_STATUS_NO_MEMORY;
+                }
+                        return NT_STATUS_NO_MEMORY;
+                }
                 /* set new value mtime */
                 if (samdb_msg_add_uint64(secret_state->sam_ldb,
+                if (samdb_msg_add_uint64(secret_state->sam_ldb,
                                          mem_ctx, msg, "lastSetTime", nt_now) != LDB_SUCCESS) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                        return NT_STATUS_NO_MEMORY;
+                }
         } else {
                 /* NULL out the NEW value */
                 if (samdb_msg_add_uint64(secret_state->sam_ldb,
+                if (samdb_msg_add_uint64(secret_state->sam_ldb,
                                          mem_ctx, msg, "lastSetTime", nt_now) != LDB_SUCCESS) {
                         return NT_STATUS_NO_MEMORY;
+                }
                 if (samdb_msg_add_delete(secret_state->sam_ldb,
+                        return NT_STATUS_NO_MEMORY;
+                }
+                if (samdb_msg_add_delete(secret_state->sam_ldb,
                                          mem_ctx, msg, "currentValue") != LDB_SUCCESS) {
                         return NT_STATUS_NO_MEMORY;
 …
         ret = dsdb_replace(secret_state->sam_ldb, msg, 0);
         if (ret != LDB_SUCCESS) {
+                /* we really need samdb.c to return NTSTATUS */
+                return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
 /*
   lsa_QuerySecret
+/*
+  lsa_QuerySecret
 */
 static NTSTATUS dcesrv_lsa_QuerySecret(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
                 "priorValue",
                 "lastSetTime",
                 "priorSetTime",
+                "priorSetTime",
                 NULL
         };
 …
+        }
         msg = res[0];
         nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
         if (!NT_STATUS_IS_OK(nt_status)) {
                 return nt_status;
+        }
         if (r->in.old_val) {
                 const struct ldb_val *prior_val;
 …
                         return NT_STATUS_NO_MEMORY;
+                }
                 prior_val = ldb_msg_find_ldb_val(res[0], "priorValue");
+                prior_val = ldb_msg_find_ldb_val(msg, "priorValue");
                 if (prior_val && prior_val->length) {
                         secret.data = prior_val->data;
                         secret.length = prior_val->length;
                         /* Encrypt */
                         crypt_secret = sess_encrypt_blob(mem_ctx, &secret, &session_key);
 …
+                }
+        }
         if (r->in.old_mtime) {
                 r->out.old_mtime = talloc(mem_ctx, NTTIME);
 …
                         return NT_STATUS_NO_MEMORY;
+                }
                 *r->out.old_mtime = ldb_msg_find_attr_as_uint64(res[0], "priorSetTime", 0);
+        }
+                *r->out.old_mtime = ldb_msg_find_attr_as_uint64(msg, "priorSetTime", 0);
+        }
         if (r->in.new_val) {
                 const struct ldb_val *new_val;
 …
+                }
                 new_val = ldb_msg_find_ldb_val(res[0], "currentValue");
+                new_val = ldb_msg_find_ldb_val(msg, "currentValue");
                 if (new_val && new_val->length) {
                         secret.data = new_val->data;
                         secret.length = new_val->length;
                         /* Encrypt */
                         crypt_secret = sess_encrypt_blob(mem_ctx, &secret, &session_key);
 …
+                }
+        }
         if (r->in.new_mtime) {
                 r->out.new_mtime = talloc(mem_ctx, NTTIME);
 …
                         return NT_STATUS_NO_MEMORY;
+                }
                 *r->out.new_mtime = ldb_msg_find_attr_as_uint64(res[0], "lastSetTime", 0);
+        }
+                *r->out.new_mtime = ldb_msg_find_attr_as_uint64(msg, "lastSetTime", 0);
+        }
         return NT_STATUS_OK;
+}
 /*
+/*
   lsa_LookupPrivValue
 */
 static NTSTATUS dcesrv_lsa_LookupPrivValue(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_LookupPrivValue(struct dcesrv_call_state *dce_call,
                                     TALLOC_CTX *mem_ctx,
                                     struct lsa_LookupPrivValue *r)
+{
         struct dcesrv_handle *h;
-        struct lsa_policy_state *state;
         int id;
         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
-        state = h->data;
         id = sec_privilege_id(r->in.name->string);
 …
         r->out.luid->high = 0;
         return NT_STATUS_OK;
+}
 /*
   lsa_LookupPrivName
 */
 static NTSTATUS dcesrv_lsa_LookupPrivName(struct dcesrv_call_state *dce_call,
+        return NT_STATUS_OK;
+}
+/*
+  lsa_LookupPrivName
+*/
+static NTSTATUS dcesrv_lsa_LookupPrivName(struct dcesrv_call_state *dce_call,
                                    TALLOC_CTX *mem_ctx,
                                    struct lsa_LookupPrivName *r)
+{
         struct dcesrv_handle *h;
-        struct lsa_policy_state *state;
         struct lsa_StringLarge *name;
         const char *privname;
         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
-        state = h->data;
         if (r->in.luid->high != 0) {
 …
         *r->out.name = name;
         return NT_STATUS_OK;
+}
 /*
+        return NT_STATUS_OK;
+}
+/*
   lsa_LookupPrivDisplayName
 */
 static NTSTATUS dcesrv_lsa_LookupPrivDisplayName(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_LookupPrivDisplayName(struct dcesrv_call_state *dce_call,
                                           TALLOC_CTX *mem_ctx,
                                           struct lsa_LookupPrivDisplayName *r)
+{
         struct dcesrv_handle *h;
-        struct lsa_policy_state *state;
         struct lsa_StringLarge *disp_name = NULL;
         enum sec_privilege id;
         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
-        state = h->data;
         id = sec_privilege_id(r->in.name->string);
 …
 /*
+/*
   lsa_EnumAccountsWithUserRight
 */
 static NTSTATUS dcesrv_lsa_EnumAccountsWithUserRight(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_EnumAccountsWithUserRight(struct dcesrv_call_state *dce_call,
                                               TALLOC_CTX *mem_ctx,
                                               struct lsa_EnumAccountsWithUserRight *r)
 …
         if (r->in.name == NULL) {
                 return NT_STATUS_NO_SUCH_PRIVILEGE;
+        }
+        }
         privname = r->in.name->string;
 …
+        }
         ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs,
+        ret = gendb_search(state->pdb, mem_ctx, NULL, &res, attrs,
                            "privilege=%s", privname);
         if (ret < 0) {
 …
 /*
+/*
   lsa_AddAccountRights
 */
 static NTSTATUS dcesrv_lsa_AddAccountRights(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_AddAccountRights(struct dcesrv_call_state *dce_call,
                                      TALLOC_CTX *mem_ctx,
                                      struct lsa_AddAccountRights *r)
 …
         state = h->data;
         return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
+        return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
                                           LDB_FLAG_MOD_ADD,
                                           r->in.sid, r->in.rights);
 …
 /*
+/*
   lsa_RemoveAccountRights
 */
 static NTSTATUS dcesrv_lsa_RemoveAccountRights(struct dcesrv_call_state *dce_call,
+static NTSTATUS dcesrv_lsa_RemoveAccountRights(struct dcesrv_call_state *dce_call,
                                         TALLOC_CTX *mem_ctx,
                                         struct lsa_RemoveAccountRights *r)
 …
         state = h->data;
         return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
+        return dcesrv_lsa_AddRemoveAccountRights(dce_call, mem_ctx, state,
                                           LDB_FLAG_MOD_DELETE,
                                           r->in.sid, r->in.rights);
 …
 /*
+/*
   lsa_StorePrivateData
 */
 …
 /*
+/*
   lsa_RetrievePrivateData
 */
 …
 /*
+/*
   lsa_GetUserName
 */
 …
                                 struct lsa_GetUserName *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
         NTSTATUS status = NT_STATUS_OK;
         const char *account_name;
 …
         struct lsa_String *_authority_name = NULL;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         /* this is what w2k3 does */
         r->out.account_name = r->in.account_name;
 …
+}
+static void kdc_get_policy(struct loadparm_context *lp_ctx,
+                           struct smb_krb5_context *smb_krb5_context,
+                           struct lsa_DomainInfoKerberos *k)
+{
+        time_t svc_tkt_lifetime;
+        time_t usr_tkt_lifetime;
+        time_t renewal_lifetime;
+        /* These should be set and stored via Group Policy, but until then, some defaults are in order */
+        /* Our KDC always re-validates the client */
+        k->authentication_options = LSA_POLICY_KERBEROS_VALIDATE_CLIENT;
+        lpcfg_default_kdc_policy(lp_ctx, &svc_tkt_lifetime,
+                                 &usr_tkt_lifetime, &renewal_lifetime);
+        unix_to_nt_time(&k->service_tkt_lifetime, svc_tkt_lifetime);
+        unix_to_nt_time(&k->user_tkt_lifetime, usr_tkt_lifetime);
+        unix_to_nt_time(&k->user_tkt_renewaltime, renewal_lifetime);
+#ifdef SAMBA4_USES_HEIMDAL /* MIT lacks krb5_get_max_time_skew.
+        However in the parent function we basically just did a full
+        krb5_context init with the only purpose of getting a global
+        config option (the max skew), it would probably make more sense
+        to have a lp_ or ldb global option as the samba default */
+        if (smb_krb5_context) {
+                unix_to_nt_time(&k->clock_skew,
+                                krb5_get_max_time_skew(smb_krb5_context->krb5_context));
+        }
+#endif
+        k->reserved = 0;
+}
 /*
   lsa_QueryDomainInformationPolicy
 …
                 struct lsa_DomainInfoKerberos *k = &info->kerberos_info;
                 struct smb_krb5_context *smb_krb5_context;
+                int ret = smb_krb5_init_context(mem_ctx,
+                                                        dce_call->event_ctx,
+                int ret = smb_krb5_init_context(mem_ctx,
                                                         dce_call->conn->dce_ctx->lp_ctx,
                                                         &smb_krb5_context);
 …
+}
 /*
   lsa_CREDRWRITE
+/*
+  lsa_CREDRWRITE
 */
 static NTSTATUS dcesrv_lsa_CREDRWRITE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRREAD
+/*
+  lsa_CREDRREAD
 */
 static NTSTATUS dcesrv_lsa_CREDRREAD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRENUMERATE
+/*
+  lsa_CREDRENUMERATE
 */
 static NTSTATUS dcesrv_lsa_CREDRENUMERATE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRWRITEDOMAINCREDENTIALS
+/*
+  lsa_CREDRWRITEDOMAINCREDENTIALS
 */
 static NTSTATUS dcesrv_lsa_CREDRWRITEDOMAINCREDENTIALS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRREADDOMAINCREDENTIALS
+/*
+  lsa_CREDRREADDOMAINCREDENTIALS
 */
 static NTSTATUS dcesrv_lsa_CREDRREADDOMAINCREDENTIALS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRDELETE
+/*
+  lsa_CREDRDELETE
 */
 static NTSTATUS dcesrv_lsa_CREDRDELETE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRGETTARGETINFO
+/*
+  lsa_CREDRGETTARGETINFO
 */
 static NTSTATUS dcesrv_lsa_CREDRGETTARGETINFO(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRPROFILELOADED
+/*
+  lsa_CREDRPROFILELOADED
 */
 static NTSTATUS dcesrv_lsa_CREDRPROFILELOADED(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_CREDRGETSESSIONTYPES
+/*
+  lsa_CREDRGETSESSIONTYPES
 */
 static NTSTATUS dcesrv_lsa_CREDRGETSESSIONTYPES(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_LSARREGISTERAUDITEVENT
+/*
+  lsa_LSARREGISTERAUDITEVENT
 */
 static NTSTATUS dcesrv_lsa_LSARREGISTERAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_LSARGENAUDITEVENT
+/*
+  lsa_LSARGENAUDITEVENT
 */
 static NTSTATUS dcesrv_lsa_LSARGENAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_LSARUNREGISTERAUDITEVENT
+/*
+  lsa_LSARUNREGISTERAUDITEVENT
 */
 static NTSTATUS dcesrv_lsa_LSARUNREGISTERAUDITEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_lsaRQueryForestTrustInformation
+/*
+  lsa_lsaRQueryForestTrustInformation
 */
 static NTSTATUS dcesrv_lsa_lsaRQueryForestTrustInformation(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                        struct lsa_lsaRQueryForestTrustInformation *r)
+{
+        DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
+#define DNS_CMP_MATCH 0
+#define DNS_CMP_FIRST_IS_CHILD 1
+#define DNS_CMP_SECOND_IS_CHILD 2
+#define DNS_CMP_NO_MATCH 3
+/* this function assumes names are well formed DNS names.
+ * it doesn't validate them */
+static int dns_cmp(const char *s1, size_t l1,
+                   const char *s2, size_t l2)
+{
+        const char *p1, *p2;
+        size_t t1, t2;
+        int cret;
+        if (l1 == l2) {
+                if (strcasecmp_m(s1, s2) == 0) {
+                        return DNS_CMP_MATCH;
+                }
+                return DNS_CMP_NO_MATCH;
+        }
+        if (l1 > l2) {
+                p1 = s1;
+                p2 = s2;
+                t1 = l1;
+                t2 = l2;
+                cret = DNS_CMP_FIRST_IS_CHILD;
+        } else {
+                p1 = s2;
+                p2 = s1;
+                t1 = l2;
+                t2 = l1;
+                cret = DNS_CMP_SECOND_IS_CHILD;
+        }
+        if (p1[t1 - t2 - 1] != '.') {
+                return DNS_CMP_NO_MATCH;
+        }
+        if (strcasecmp_m(&p1[t1 - t2], p2) == 0) {
+                return cret;
+        }
+        return DNS_CMP_NO_MATCH;
+}
+/* decode all TDOs forest trust info blobs */
+static NTSTATUS get_ft_info(TALLOC_CTX *mem_ctx,
+                            struct ldb_message *msg,
+                            struct ForestTrustInfo *info)
+{
+        const struct ldb_val *ft_blob;
+        enum ndr_err_code ndr_err;
+        ft_blob = ldb_msg_find_ldb_val(msg, "msDS-TrustForestTrustInfo");
+        if (!ft_blob || !ft_blob->data) {
+                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+        }
+        /* ldb_val is equivalent to DATA_BLOB */
+        ndr_err = ndr_pull_struct_blob_all(ft_blob, mem_ctx, info,
+                                           (ndr_pull_flags_fn_t)ndr_pull_ForestTrustInfo);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+        struct dcesrv_handle *h = NULL;
+        struct lsa_policy_state *p_state = NULL;
+        int forest_level = DS_DOMAIN_FUNCTION_2000;
+        const char * const trust_attrs[] = {
+                "securityIdentifier",
+                "flatName",
+                "trustPartner",
+                "trustAttributes",
+                "trustDirection",
+                "trustType",
+                "msDS-TrustForestTrustInfo",
+                NULL
+        };
+        struct ldb_message *trust_tdo_msg = NULL;
+        struct lsa_TrustDomainInfoInfoEx *trust_tdo = NULL;
+        struct ForestTrustInfo *trust_fti = NULL;
+        struct lsa_ForestTrustInformation *trust_lfti = NULL;
+        NTSTATUS status;
+        DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
+        p_state = h->data;
+        if (strcmp(p_state->domain_dns, p_state->forest_dns)) {
                 return NT_STATUS_INVALID_DOMAIN_STATE;
+        }
+        return NT_STATUS_OK;
+}
+static NTSTATUS own_ft_info(struct lsa_policy_state *ps,
+                            struct ForestTrustInfo *fti)
+{
+        struct ForestTrustDataDomainInfo *info;
+        struct ForestTrustInfoRecord *rec;
+        fti->version = 1;
+        fti->count = 2;
+        fti->records = talloc_array(fti,
+                                    struct ForestTrustInfoRecordArmor, 2);
+        if (!fti->records) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        /* TLN info */
+        rec = &fti->records[0].record;
+        rec->flags = 0;
+        rec->timestamp = 0;
+        rec->type = LSA_FOREST_TRUST_TOP_LEVEL_NAME;
+        rec->data.name.string = talloc_strdup(fti, ps->forest_dns);
+        if (!rec->data.name.string) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        rec->data.name.size = strlen(rec->data.name.string);
+        /* DOMAIN info */
+        rec = &fti->records[1].record;
+        rec->flags = 0;
+        rec->timestamp = 0;
+        rec->type = LSA_FOREST_TRUST_DOMAIN_INFO;
+        info = &rec->data.info;
+        info->sid = *ps->domain_sid;
+        info->dns_name.string = talloc_strdup(fti, ps->domain_dns);
+        if (!info->dns_name.string) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        info->dns_name.size = strlen(info->dns_name.string);
+        info->netbios_name.string = talloc_strdup(fti, ps->domain_name);
+        if (!info->netbios_name.string) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        info->netbios_name.size = strlen(info->netbios_name.string);
+        return NT_STATUS_OK;
+}
+static NTSTATUS make_ft_info(TALLOC_CTX *mem_ctx,
+                             struct lsa_ForestTrustInformation *lfti,
+                             struct ForestTrustInfo *fti)
+{
+        struct lsa_ForestTrustRecord *lrec;
+        struct ForestTrustInfoRecord *rec;
+        struct lsa_StringLarge *tln;
+        struct lsa_ForestTrustDomainInfo *info;
+        uint32_t i;
+        fti->version = 1;
+        fti->count = lfti->count;
+        fti->records = talloc_array(mem_ctx,
+                                    struct ForestTrustInfoRecordArmor,
+                                    fti->count);
+        if (!fti->records) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        for (i = 0; i < fti->count; i++) {
+                lrec = lfti->entries[i];
+                rec = &fti->records[i].record;
+                rec->flags = lrec->flags;
+                rec->timestamp = lrec->time;
+                rec->type = lrec->type;
+                switch (lrec->type) {
+                case LSA_FOREST_TRUST_TOP_LEVEL_NAME:
+                case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
+                        tln = &lrec->forest_trust_data.top_level_name;
+                        rec->data.name.string =
+                                talloc_strdup(mem_ctx, tln->string);
+                        if (!rec->data.name.string) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                        rec->data.name.size = strlen(rec->data.name.string);
+                        break;
+                case LSA_FOREST_TRUST_DOMAIN_INFO:
+                        info = &lrec->forest_trust_data.domain_info;
+                        rec->data.info.sid = *info->domain_sid;
+                        rec->data.info.dns_name.string =
+                                talloc_strdup(mem_ctx,
+                                            info->dns_domain_name.string);
+                        if (!rec->data.info.dns_name.string) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                        rec->data.info.dns_name.size =
+                                strlen(rec->data.info.dns_name.string);
+                        rec->data.info.netbios_name.string =
+                                talloc_strdup(mem_ctx,
+                                            info->netbios_domain_name.string);
+                        if (!rec->data.info.netbios_name.string) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                        rec->data.info.netbios_name.size =
+                                strlen(rec->data.info.netbios_name.string);
+                        break;
+                default:
+                        return NT_STATUS_INVALID_DOMAIN_STATE;
+                }
+        }
+        return NT_STATUS_OK;
+}
+static NTSTATUS add_collision(struct lsa_ForestTrustCollisionInfo *c_info,
+                              uint32_t idx, uint32_t collision_type,
+                              uint32_t conflict_type, const char *tdo_name);
+static NTSTATUS check_ft_info(TALLOC_CTX *mem_ctx,
+                              const char *tdo_name,
+                              struct ForestTrustInfo *tdo_fti,
+                              struct ForestTrustInfo *new_fti,
+                              struct lsa_ForestTrustCollisionInfo *c_info)
+{
+        struct ForestTrustInfoRecord *nrec;
+        struct ForestTrustInfoRecord *trec;
+        const char *dns_name;
+        const char *nb_name;
+        struct dom_sid *sid;
+        const char *tname;
+        size_t dns_len;
+        size_t nb_len;
+        size_t tlen;
+        NTSTATUS nt_status;
+        uint32_t new_fti_idx;
+        uint32_t i;
+        /* use always TDO type, until we understand when Xref can be used */
+        uint32_t collision_type = LSA_FOREST_TRUST_COLLISION_TDO;
+        bool tln_conflict;
+        bool sid_conflict;
+        bool nb_conflict;
+        bool exclusion;
+        bool ex_rule;
+        int ret;
+        for (new_fti_idx = 0; new_fti_idx < new_fti->count; new_fti_idx++) {
+                nrec = &new_fti->records[new_fti_idx].record;
+                dns_name = NULL;
+                tln_conflict = false;
+                sid_conflict = false;
+                nb_conflict = false;
+                exclusion = false;
+                switch (nrec->type) {
+                case LSA_FOREST_TRUST_TOP_LEVEL_NAME_EX:
+                        /* exclusions do not conflict by definition */
+                        break;
+                case FOREST_TRUST_TOP_LEVEL_NAME:
+                        dns_name = nrec->data.name.string;
+                        dns_len = nrec->data.name.size;
+                        break;
+                case LSA_FOREST_TRUST_DOMAIN_INFO:
+                        dns_name = nrec->data.info.dns_name.string;
+                        dns_len = nrec->data.info.dns_name.size;
+                        nb_name = nrec->data.info.netbios_name.string;
+                        nb_len = nrec->data.info.netbios_name.size;
+                        sid = &nrec->data.info.sid;
+                        break;
+                }
+                if (!dns_name) continue;
+                /* check if this is already taken and not excluded */
+                for (i = 0; i < tdo_fti->count; i++) {
+                        trec = &tdo_fti->records[i].record;
+                        switch (trec->type) {
+                        case FOREST_TRUST_TOP_LEVEL_NAME:
+                                ex_rule = false;
+                                tname = trec->data.name.string;
+                                tlen = trec->data.name.size;
+                                break;
+                        case FOREST_TRUST_TOP_LEVEL_NAME_EX:
+                                ex_rule = true;
+                                tname = trec->data.name.string;
+                                tlen = trec->data.name.size;
+                                break;
+                        case FOREST_TRUST_DOMAIN_INFO:
+                                ex_rule = false;
+                                tname = trec->data.info.dns_name.string;
+                                tlen = trec->data.info.dns_name.size;
+                        }
+                        ret = dns_cmp(dns_name, dns_len, tname, tlen);
+                        switch (ret) {
+                        case DNS_CMP_MATCH:
+                                /* if it matches exclusion,
+                                 * it doesn't conflict */
+                                if (ex_rule) {
+                                        exclusion = true;
+                                        break;
+                                }
+                                /* fall through */
+                        case DNS_CMP_FIRST_IS_CHILD:
+                        case DNS_CMP_SECOND_IS_CHILD:
+                                tln_conflict = true;
+                                /* fall through */
+                        default:
+                                break;
+                        }
+                        /* explicit exclusion, no dns name conflict here */
+                        if (exclusion) {
+                                tln_conflict = false;
+                        }
+                        if (trec->type != FOREST_TRUST_DOMAIN_INFO) {
+                                continue;
+                        }
+                        /* also test for domain info */
+                        if (!(trec->flags & LSA_SID_DISABLED_ADMIN) &&
+                            dom_sid_compare(&trec->data.info.sid, sid) == 0) {
+                                sid_conflict = true;
+                        }
+                        if (!(trec->flags & LSA_NB_DISABLED_ADMIN) &&
+                            strcasecmp_m(trec->data.info.netbios_name.string,
+                                         nb_name) == 0) {
+                                nb_conflict = true;
+                        }
+                }
+                if (tln_conflict) {
+                        nt_status = add_collision(c_info, new_fti_idx,
+                                                  collision_type,
+                                                  LSA_TLN_DISABLED_CONFLICT,
+                                                  tdo_name);
+                }
+                if (sid_conflict) {
+                        nt_status = add_collision(c_info, new_fti_idx,
+                                                  collision_type,
+                                                  LSA_SID_DISABLED_CONFLICT,
+                                                  tdo_name);
+                }
+                if (nb_conflict) {
+                        nt_status = add_collision(c_info, new_fti_idx,
+                                                  collision_type,
+                                                  LSA_NB_DISABLED_CONFLICT,
+                                                  tdo_name);
+                }
+        }
+        return NT_STATUS_OK;
+}
+static NTSTATUS add_collision(struct lsa_ForestTrustCollisionInfo *c_info,
+                              uint32_t idx, uint32_t collision_type,
+                              uint32_t conflict_type, const char *tdo_name)
+{
+        struct lsa_ForestTrustCollisionRecord **es;
+        uint32_t i = c_info->count;
+        es = talloc_realloc(c_info, c_info->entries,
+                            struct lsa_ForestTrustCollisionRecord *, i + 1);
+        if (!es) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        c_info->entries = es;
+        c_info->count = i + 1;
+        es[i] = talloc(es, struct lsa_ForestTrustCollisionRecord);
+        if (!es[i]) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        es[i]->index = idx;
+        es[i]->type = collision_type;
+        es[i]->flags.flags = conflict_type;
+        es[i]->name.string = talloc_strdup(es[i], tdo_name);
+        if (!es[i]->name.string) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        es[i]->name.size = strlen(es[i]->name.string);
+        forest_level = dsdb_forest_functional_level(p_state->sam_ldb);
+        if (forest_level < DS_DOMAIN_FUNCTION_2003) {
+                return NT_STATUS_INVALID_DOMAIN_STATE;
+        }
+        if (r->in.trusted_domain_name->string == NULL) {
+                return NT_STATUS_NO_SUCH_DOMAIN;
+        }
+        status = dsdb_trust_search_tdo(p_state->sam_ldb,
+                                       r->in.trusted_domain_name->string,
+                                       r->in.trusted_domain_name->string,
+                                       trust_attrs, mem_ctx, &trust_tdo_msg);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                return NT_STATUS_NO_SUCH_DOMAIN;
+        }
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        status = dsdb_trust_parse_tdo_info(mem_ctx, trust_tdo_msg, &trust_tdo);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        if (!(trust_tdo->trust_attributes & LSA_TRUST_ATTRIBUTE_FOREST_TRANSITIVE)) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        if (r->in.highest_record_type >= LSA_FOREST_TRUST_RECORD_TYPE_LAST) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        status = dsdb_trust_parse_forest_info(mem_ctx,
+                                              trust_tdo_msg,
+                                              &trust_fti);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        status = dsdb_trust_forest_info_to_lsa(mem_ctx, trust_fti,
+                                               &trust_lfti);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+        *r->out.forest_trust_info = trust_lfti;
         return NT_STATUS_OK;
+}
 …
         struct dcesrv_handle *h;
         struct lsa_policy_state *p_state;
+        const char *trust_attrs[] = { "trustPartner", "trustAttributes",
+                                      "msDS-TrustForestTrustInfo", NULL };
+        struct ldb_message **dom_res = NULL;
+        struct ldb_dn *tdo_dn;
+        struct ldb_message *msg;
+        int num_res, i;
+        const char *td_name;
+        uint32_t trust_attributes;
+        struct lsa_ForestTrustCollisionInfo *c_info;
+        struct ForestTrustInfo *nfti;
+        struct ForestTrustInfo *fti;
+        DATA_BLOB ft_blob;
+        const char * const trust_attrs[] = {
+                "securityIdentifier",
+                "flatName",
+                "trustPartner",
+                "trustAttributes",
+                "trustDirection",
+                "trustType",
+                "msDS-TrustForestTrustInfo",
+                NULL
+        };
+        struct ldb_message *trust_tdo_msg = NULL;
+        struct lsa_TrustDomainInfoInfoEx *trust_tdo = NULL;
+        struct lsa_ForestTrustInformation *step1_lfti = NULL;
+        struct lsa_ForestTrustInformation *step2_lfti = NULL;
+        struct ForestTrustInfo *trust_fti = NULL;
+        struct ldb_result *trusts_res = NULL;
+        unsigned int i;
+        struct lsa_TrustDomainInfoInfoEx *xref_tdo = NULL;
+        struct lsa_ForestTrustInformation *xref_lfti = NULL;
+        struct lsa_ForestTrustCollisionInfo *c_info = NULL;
+        DATA_BLOB ft_blob = {};
+        struct ldb_message *msg = NULL;
+        NTSTATUS status;
         enum ndr_err_code ndr_err;
-        NTSTATUS nt_status;
-        bool am_rodc;
         int ret;
+        bool in_transaction = false;
         DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
 …
+        }
+        /* abort if we are not a PDC */
+        if (r->in.check_only == 0) {
+                ret = ldb_transaction_start(p_state->sam_ldb);
+                if (ret != LDB_SUCCESS) {
+                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                }
+                in_transaction = true;
+        }
+        /*
+         * abort if we are not a PDC
+         *
+         * In future we should use a function like IsEffectiveRoleOwner()
+         */
         if (!samdb_is_pdc(p_state->sam_ldb)) {
+                return NT_STATUS_INVALID_DOMAIN_ROLE;
+        }
+        ret = samdb_rodc(p_state->sam_ldb, &am_rodc);
+        if (ret == LDB_SUCCESS && am_rodc) {
+                return NT_STATUS_NO_SUCH_DOMAIN;
+        }
+        /* check caller has TRUSTED_SET_AUTH */
+        /* fetch all trusted domain objects */
+        num_res = gendb_search(p_state->sam_ldb, mem_ctx,
+                               p_state->system_dn,
+                               &dom_res, trust_attrs,
+                               "(objectclass=trustedDomain)");
+        if (num_res == 0) {
+                return NT_STATUS_NO_SUCH_DOMAIN;
+        }
+        for (i = 0; i < num_res; i++) {
+                td_name = ldb_msg_find_attr_as_string(dom_res[i],
+                                                      "trustPartner", NULL);
+                if (!td_name) {
+                        return NT_STATUS_INVALID_DOMAIN_STATE;
+                }
+                if (strcasecmp_m(td_name,
+                                 r->in.trusted_domain_name->string) == 0) {
+                        break;
+                }
+        }
+        if (i >= num_res) {
+                return NT_STATUS_NO_SUCH_DOMAIN;
+        }
+        tdo_dn = dom_res[i]->dn;
+        trust_attributes = ldb_msg_find_attr_as_uint(dom_res[i],
+                                                     "trustAttributes", 0);
+        if (!(trust_attributes & NETR_TRUST_ATTRIBUTE_FOREST_TRANSITIVE)) {
+                return NT_STATUS_INVALID_PARAMETER;
+                status = NT_STATUS_INVALID_DOMAIN_ROLE;
+                goto done;
+        }
+        if (r->in.trusted_domain_name->string == NULL) {
+                status = NT_STATUS_NO_SUCH_DOMAIN;
+                goto done;
+        }
+        status = dsdb_trust_search_tdo(p_state->sam_ldb,
+                                       r->in.trusted_domain_name->string,
+                                       r->in.trusted_domain_name->string,
+                                       trust_attrs, mem_ctx, &trust_tdo_msg);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                status = NT_STATUS_NO_SUCH_DOMAIN;
+                goto done;
+        }
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = dsdb_trust_parse_tdo_info(mem_ctx, trust_tdo_msg, &trust_tdo);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        if (!(trust_tdo->trust_attributes & LSA_TRUST_ATTRIBUTE_FOREST_TRANSITIVE)) {
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto done;
+        }
         if (r->in.highest_record_type >= LSA_FOREST_TRUST_RECORD_TYPE_LAST) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        nfti = talloc(mem_ctx, struct ForestTrustInfo);
+        if (!nfti) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        nt_status = make_ft_info(nfti, r->in.forest_trust_info, nfti);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                return nt_status;
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto done;
+        }
+        /*
+         * verify and normalize the given forest trust info.
+         *
+         * Step1: doesn't reorder yet, so step1_lfti might contain
+         * NULL entries. This means dsdb_trust_verify_forest_info()
+         * can generate collision entries with the callers index.
+         */
+        status = dsdb_trust_normalize_forest_info_step1(mem_ctx,
+                                                        r->in.forest_trust_info,
+                                                        &step1_lfti);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         c_info = talloc_zero(r->out.collision_info,
                              struct lsa_ForestTrustCollisionInfo);
+        if (!c_info) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        /* first check own info, then other domains */
+        fti = talloc(mem_ctx, struct ForestTrustInfo);
+        if (!fti) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        nt_status = own_ft_info(p_state, fti);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                return nt_status;
+        }
+        nt_status = check_ft_info(c_info, p_state->domain_dns,
+                                  fti, nfti, c_info);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                return nt_status;
+        }
+        for (i = 0; i < num_res; i++) {
+                fti = talloc(mem_ctx, struct ForestTrustInfo);
+                if (!fti) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                nt_status = get_ft_info(mem_ctx, dom_res[i], fti);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        if (NT_STATUS_EQUAL(nt_status,
+                            NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                                continue;
+                        }
+                        return nt_status;
+                }
+                td_name = ldb_msg_find_attr_as_string(dom_res[i],
+                                                      "trustPartner", NULL);
+                if (!td_name) {
+                        return NT_STATUS_INVALID_DOMAIN_STATE;
+                }
+                nt_status = check_ft_info(c_info, td_name, fti, nfti, c_info);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
+        }
+        *r->out.collision_info = c_info;
+        if (c_info == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        /*
+         * First check our own forest, then other domains/forests
+         */
+        status = dsdb_trust_xref_tdo_info(mem_ctx, p_state->sam_ldb,
+                                          &xref_tdo);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = dsdb_trust_xref_forest_info(mem_ctx, p_state->sam_ldb,
+                                             &xref_lfti);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        /*
+         * The documentation proposed to generate
+         * LSA_FOREST_TRUST_COLLISION_XREF collisions.
+         * But Windows always uses LSA_FOREST_TRUST_COLLISION_TDO.
+         */
+        status = dsdb_trust_verify_forest_info(xref_tdo, xref_lfti,
+                                               LSA_FOREST_TRUST_COLLISION_TDO,
+                                               c_info, step1_lfti);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        /* fetch all other trusted domain objects */
+        status = dsdb_trust_search_tdos(p_state->sam_ldb,
+                                        trust_tdo->domain_name.string,
+                                        trust_attrs,
+                                        mem_ctx, &trusts_res);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        /*
+         * now check against the other domains.
+         * and generate LSA_FOREST_TRUST_COLLISION_TDO collisions.
+         */
+        for (i = 0; i < trusts_res->count; i++) {
+                struct lsa_TrustDomainInfoInfoEx *tdo = NULL;
+                struct ForestTrustInfo *fti = NULL;
+                struct lsa_ForestTrustInformation *lfti = NULL;
+                status = dsdb_trust_parse_tdo_info(mem_ctx,
+                                                   trusts_res->msgs[i],
+                                                   &tdo);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
+                status = dsdb_trust_parse_forest_info(tdo,
+                                                      trusts_res->msgs[i],
+                                                      &fti);
+                if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+                        continue;
+                }
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
+                status = dsdb_trust_forest_info_to_lsa(tdo, fti, &lfti);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
+                status = dsdb_trust_verify_forest_info(tdo, lfti,
+                                                LSA_FOREST_TRUST_COLLISION_TDO,
+                                                c_info, step1_lfti);
+                if (!NT_STATUS_IS_OK(status)) {
+                        goto done;
+                }
+                TALLOC_FREE(tdo);
+        }
         if (r->in.check_only != 0) {
+                return NT_STATUS_OK;
+        }
+        /* not just a check, write info back */
+        ndr_err = ndr_push_struct_blob(&ft_blob, mem_ctx, nfti,
+                status = NT_STATUS_OK;
+                goto done;
+        }
+        /*
+         * not just a check, write info back
+         */
+        /*
+         * normalize the given forest trust info.
+         *
+         * Step2: adds TOP_LEVEL_NAME[_EX] in reverse order,
+         * followed by DOMAIN_INFO in reverse order. It also removes
+         * possible NULL entries from Step1.
+         */
+        status = dsdb_trust_normalize_forest_info_step2(mem_ctx, step1_lfti,
+                                                        &step2_lfti);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        status = dsdb_trust_forest_info_from_lsa(mem_ctx, step2_lfti,
+                                                 &trust_fti);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+        ndr_err = ndr_push_struct_blob(&ft_blob, mem_ctx, trust_fti,
                                        (ndr_push_flags_fn_t)ndr_push_ForestTrustInfo);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return NT_STATUS_INVALID_PARAMETER;
+                status = NT_STATUS_INVALID_PARAMETER;
+                goto done;
+        }
         msg = ldb_msg_new(mem_ctx);
         if (msg == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        msg->dn = ldb_dn_copy(mem_ctx, tdo_dn);
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        msg->dn = ldb_dn_copy(mem_ctx, trust_tdo_msg->dn);
         if (!msg->dn) {
+                return NT_STATUS_NO_MEMORY;
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
 …
                                 LDB_FLAG_MOD_REPLACE, NULL);
         if (ret != LDB_SUCCESS) {
+                return NT_STATUS_NO_MEMORY;
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
         ret = ldb_msg_add_value(msg, "msDS-TrustForestTrustInfo",
                                 &ft_blob, NULL);
         if (ret != LDB_SUCCESS) {
+                return NT_STATUS_NO_MEMORY;
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
         ret = ldb_modify(p_state->sam_ldb, msg);
         if (ret != LDB_SUCCESS) {
+                status = dsdb_ldb_err_to_ntstatus(ret);
                 DEBUG(0, ("Failed to store Forest Trust Info: %s\n",
                           ldb_errstring(p_state->sam_ldb)));
+                switch (ret) {
+                case LDB_ERR_INSUFFICIENT_ACCESS_RIGHTS:
+                        return NT_STATUS_ACCESS_DENIED;
+                default:
+                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                }
+        }
+        return NT_STATUS_OK;
+}
+/*
+  lsa_CREDRRENAME
+                goto done;
+        }
+        /* ok, all fine, commit transaction and return */
+        in_transaction = false;
+        ret = ldb_transaction_commit(p_state->sam_ldb);
+        if (ret != LDB_SUCCESS) {
+                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                goto done;
+        }
+        status = NT_STATUS_OK;
+done:
+        if (NT_STATUS_IS_OK(status) && c_info->count != 0) {
+                *r->out.collision_info = c_info;
+        }
+        if (in_transaction) {
+                ldb_transaction_cancel(p_state->sam_ldb);
+        }
+        return status;
+}
+/*
+  lsa_CREDRRENAME
 */
 static NTSTATUS dcesrv_lsa_CREDRRENAME(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_LSAROPENPOLICYSCE
+/*
+  lsa_LSAROPENPOLICYSCE
 */
 static NTSTATUS dcesrv_lsa_LSAROPENPOLICYSCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_LSARADTREGISTERSECURITYEVENTSOURCE
+/*
+  lsa_LSARADTREGISTERSECURITYEVENTSOURCE
 */
 static NTSTATUS dcesrv_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
+/*
+  lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE
 */
 static NTSTATUS dcesrv_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   lsa_LSARADTREPORTSECURITYEVENT
+/*
+  lsa_LSARADTREPORTSECURITYEVENT
 */
 static NTSTATUS dcesrv_lsa_LSARADTREPORTSECURITYEVENT(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 ******************************************/
 /*
   dssetup_DsRoleDnsNameToFlatName
+/*
+  dssetup_DsRoleDnsNameToFlatName
 */
 static WERROR dcesrv_dssetup_DsRoleDnsNameToFlatName(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   dssetup_DsRoleDcAsDc
+/*
+  dssetup_DsRoleDcAsDc
 */
 static WERROR dcesrv_dssetup_DsRoleDcAsDc(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   dssetup_DsRoleDcAsReplica
+/*
+  dssetup_DsRoleDcAsReplica
 */
 static WERROR dcesrv_dssetup_DsRoleDcAsReplica(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   dssetup_DsRoleDemoteDc
+/*
+  dssetup_DsRoleDemoteDc
 */
 static WERROR dcesrv_dssetup_DsRoleDemoteDc(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   dssetup_DsRoleGetDcOperationProgress
+/*
+  dssetup_DsRoleGetDcOperationProgress
 */
 static WERROR dcesrv_dssetup_DsRoleGetDcOperationProgress(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   dssetup_DsRoleServerSaveStateForUpgrade
+/*
+  dssetup_DsRoleServerSaveStateForUpgrade
 */
 static WERROR dcesrv_dssetup_DsRoleServerSaveStateForUpgrade(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   dssetup_DsRoleUpgradeDownlevelServer
+/*
+  dssetup_DsRoleUpgradeDownlevelServer
 */
 static WERROR dcesrv_dssetup_DsRoleUpgradeDownlevelServer(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
 /*
   dssetup_DsRoleAbortDownlevelServerUpgrade
+/*
+  dssetup_DsRoleAbortDownlevelServerUpgrade
 */
 static WERROR dcesrv_dssetup_DsRoleAbortDownlevelServerUpgrade(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 …
+{
         NTSTATUS ret;
         ret = dcerpc_server_dssetup_init();
         if (!NT_STATUS_IS_OK(ret)) {

vendor/current/source4/rpc_server/lsa/lsa.h

-              r740
+              r988
         struct ldb_context *sam_ldb;
         struct ldb_context *pdb;
-        uint32_t access_mask;
         struct ldb_dn *domain_dn;
         struct ldb_dn *forest_dn;
 …
         struct dom_sid *world_domain_sid;
         int mixed_domain;
+        struct security_descriptor *sd;
+        uint32_t access_mask;
 };

vendor/current/source4/rpc_server/lsa/lsa_init.c

-              r740
+              r988
 #include "rpc_server/lsa/lsa.h"
+NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+/*
+ * This matches a Windows 2012R2 dc in
+ * a domain with function level 2012R2.
+ */
+#define DCESRV_LSA_POLICY_SD_SDDL \
+        "O:BAG:SY" \
+        "D:" \
+        "(D;;0x00000800;;;AN)" \
+        "(A;;GA;;;BA)" \
+        "(A;;GX;;;WD)" \
+        "(A;;0x00000801;;;AN)" \
+        "(A;;0x00001000;;;LS)" \
+        "(A;;0x00001000;;;NS)" \
+        "(A;;0x00001000;;;IS)" \
+        "(A;;0x00000801;;;S-1-15-2-1)"
+static const struct generic_mapping dcesrv_lsa_policy_mapping = {
+        LSA_POLICY_READ,
+        LSA_POLICY_WRITE,
+        LSA_POLICY_EXECUTE,
+        LSA_POLICY_ALL_ACCESS
+};
+NTSTATUS dcesrv_lsa_get_policy_state(struct dcesrv_call_state *dce_call,
+                                     TALLOC_CTX *mem_ctx,
+                                     uint32_t access_desired,
                                      struct lsa_policy_state **_state)
+{
+        struct auth_session_info *session_info = dce_call->conn->auth_state.session_info;
+        enum security_user_level security_level;
         struct lsa_policy_state *state;
         struct ldb_result *dom_res;
 …
         int ret;
         state = talloc(mem_ctx, struct lsa_policy_state);
+        state = talloc_zero(mem_ctx, struct lsa_policy_state);
         if (!state) {
                 return NT_STATUS_NO_MEMORY;
 …
                 return NT_STATUS_NO_SUCH_DOMAIN;
+        }
+        state->sd = sddl_decode(state, DCESRV_LSA_POLICY_SD_SDDL,
+                                state->domain_sid);
+        if (state->sd == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        state->sd->dacl->revision = SECURITY_ACL_REVISION_NT4;
+        se_map_generic(&access_desired, &dcesrv_lsa_policy_mapping);
+        security_acl_map_generic(state->sd->dacl, &dcesrv_lsa_policy_mapping);
+        security_level = security_session_user_level(session_info, NULL);
+        if (security_level >= SECURITY_SYSTEM) {
+                /*
+                 * The security descriptor doesn't allow system,
+                 * but we want to allow system via ncalrpc as root.
+                 */
+                state->access_mask = access_desired;
+                if (state->access_mask & SEC_FLAG_MAXIMUM_ALLOWED) {
+                        state->access_mask &= ~SEC_FLAG_MAXIMUM_ALLOWED;
+                        state->access_mask |= LSA_POLICY_ALL_ACCESS;
+                }
+        } else {
+                NTSTATUS status;
+                status = se_access_check(state->sd,
+                                         session_info->security_token,
+                                         access_desired,
+                                         &state->access_mask);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(2,("%s: access desired[0x%08X] rejected[0x%08X] - %s\n",
+                                 __func__,
+                                 (unsigned)access_desired,
+                                 (unsigned)state->access_mask,
+                                 nt_errstr(status)));
+                        return status;
+                }
+        }
+        DEBUG(10,("%s: access desired[0x%08X] granted[0x%08X] - success.\n",
+                  __func__,
+                 (unsigned)access_desired,
+                 (unsigned)state->access_mask));
         *_state = state;
 …
                                 struct lsa_OpenPolicy2 *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
         NTSTATUS status;
         struct lsa_policy_state *state;
         struct dcesrv_handle *handle;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         ZERO_STRUCTP(r->out.handle);
 …
+        }
+        status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx, &state);
+        status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx,
+                                             r->in.access_mask,
+                                             &state);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
         handle->data = talloc_steal(handle, state);
-        /* need to check the access mask against - need ACLs - fails
-           WSPP test */
-        state->access_mask = r->in.access_mask;
         state->handle = handle;
         *r->out.handle = handle->wire_handle;
 …
                                 struct lsa_OpenPolicy *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
         struct lsa_OpenPolicy2 r2;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         r2.in.system_name = NULL;

vendor/current/source4/rpc_server/lsa/lsa_lookup.c

-              r740
+              r988
                         *authority_name = NAME_BUILTIN;
                         *sid = dom_sid_parse_talloc(mem_ctx, SID_BUILTIN);
+                        if (*sid == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
                         *rtype = SID_NAME_DOMAIN;
                         *rid = 0xFFFFFFFF;
 …
                         *authority_name = NAME_NT_AUTHORITY;
                         *sid =  dom_sid_parse_talloc(mem_ctx, SID_NT_AUTHORITY);
+                        if (*sid == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
                         *rtype = SID_NAME_DOMAIN;
                         dom_sid_split_rid(NULL, *sid, NULL, rid);
 …
                         *authority_name = NAME_BUILTIN;
                         *sid = dom_sid_parse_talloc(mem_ctx, SID_BUILTIN);
+                        if (*sid == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
                         *rtype = SID_NAME_DOMAIN;
                         *rid = 0xFFFFFFFF;
 …
+                }
                 if (strcasecmp_m(username, state->domain_dns) == 0) {
+                        *authority_name = state->domain_name;
+                        *sid =  state->domain_sid;
+                        *authority_name = talloc_strdup(mem_ctx,
+                                                        state->domain_name);
+                        if (*authority_name == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                        *sid =  dom_sid_dup(mem_ctx, state->domain_sid);
+                        if (*sid == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
                         *rtype = SID_NAME_DOMAIN;
                         *rid = 0xFFFFFFFF;
 …
+                }
                 if (strcasecmp_m(username, state->domain_name) == 0) {
+                        *authority_name = state->domain_name;
+                        *sid =  state->domain_sid;
+                        *authority_name = talloc_strdup(mem_ctx,
+                                                        state->domain_name);
+                        if (*authority_name == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
+                        *sid =  dom_sid_dup(mem_ctx, state->domain_sid);
+                        if (*sid == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
                         *rtype = SID_NAME_DOMAIN;
                         *rid = 0xFFFFFFFF;
                         return NT_STATUS_OK;
+                }
                 /* Perhaps this is a well known user? */
                 name = talloc_asprintf(mem_ctx, "%s\\%s", NAME_NT_AUTHORITY, username);
 …
                         *authority_name = NAME_NT_AUTHORITY;
                         *sid = dom_sid_parse_talloc(mem_ctx, SID_NT_AUTHORITY);
+                        if (*sid == NULL) {
+                                return NT_STATUS_NO_MEMORY;
+                        }
                         *rtype = SID_NAME_DOMAIN;
                         dom_sid_split_rid(NULL, *sid, NULL, rid);
 …
                 domain_dn = state->builtin_dn;
         } else if (strcasecmp_m(domain, state->domain_dns) == 0) {
+                *authority_name = state->domain_name;
+                *authority_name = talloc_strdup(mem_ctx,
+                                                state->domain_name);
+                if (*authority_name == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
                 domain_dn = state->domain_dn;
         } else if (strcasecmp_m(domain, state->domain_name) == 0) {
+                *authority_name = state->domain_name;
+                *authority_name = talloc_strdup(mem_ctx,
+                                                state->domain_name);
+                if (*authority_name == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
                 domain_dn = state->domain_dn;
         } else {
 …
+        }
+        if (dom_sid_equal(state->domain_sid, sid)) {
+                *authority_name = talloc_strdup(mem_ctx, state->domain_name);
+                if (*authority_name == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                *name = NULL;
+                *rtype = SID_NAME_DOMAIN;
+                return NT_STATUS_OK;
+        }
         if (dom_sid_in_domain(state->domain_sid, sid)) {
+                *authority_name = state->domain_name;
+                *authority_name = talloc_strdup(mem_ctx, state->domain_name);
+                if (*authority_name == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
                 domain_dn = state->domain_dn;
         } else if (dom_sid_in_domain(state->builtin_sid, sid)) {
 …
+}
+/*
+  lsa_LookupSids2
+*/
+NTSTATUS dcesrv_lsa_LookupSids2(struct dcesrv_call_state *dce_call,
+                                TALLOC_CTX *mem_ctx,
+                                struct lsa_LookupSids2 *r)
+{
+        struct lsa_policy_state *state;
+static NTSTATUS dcesrv_lsa_LookupSids_common(struct dcesrv_call_state *dce_call,
+                                             TALLOC_CTX *mem_ctx,
+                                             struct lsa_policy_state *state,
+                                             struct lsa_LookupSids2 *r)
+{
         struct lsa_RefDomainList *domains = NULL;
+        NTSTATUS status = NT_STATUS_OK;
         uint32_t i;
-        NTSTATUS status = NT_STATUS_OK;
         if (r->in.level < LSA_LOOKUP_NAMES_ALL ||
 …
            MS-DTYP 2.4.2
         */
-        status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx, &state);
-        if (!NT_STATUS_IS_OK(status)) {
-                return status;
+        }
         domains = talloc_zero(r->out.domains,  struct lsa_RefDomainList);
 …
+        }
+        return NT_STATUS_OK;
+        return status;
+}
+/*
+  lsa_LookupSids2
+*/
+NTSTATUS dcesrv_lsa_LookupSids2(struct dcesrv_call_state *dce_call,
+                                TALLOC_CTX *mem_ctx,
+                                struct lsa_LookupSids2 *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
+        struct lsa_policy_state *state;
+        struct dcesrv_handle *h;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
+        DCESRV_PULL_HANDLE(h, r->in.handle, LSA_HANDLE_POLICY);
+        state = h->data;
+        return dcesrv_lsa_LookupSids_common(dce_call,
+                                            mem_ctx,
+                                            state,
+                                            r);
+}
 …
                                 struct lsa_LookupSids3 *r)
+{
+        struct lsa_LookupSids2 r2;
+        struct lsa_OpenPolicy2 pol;
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
+        const struct dcesrv_auth *auth = &dce_call->conn->auth_state;
+        struct lsa_policy_state *policy_state;
+        struct lsa_LookupSids2 q;
         NTSTATUS status;
+        struct dcesrv_handle *h;
+        ZERO_STRUCT(r2);
+        /* No policy handle on the wire, so make one up here */
+        r2.in.handle = talloc(mem_ctx, struct policy_handle);
+        if (!r2.in.handle) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        pol.out.handle = r2.in.handle;
+        pol.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
+        pol.in.attr = NULL;
+        pol.in.system_name = NULL;
+        status = dcesrv_lsa_OpenPolicy2(dce_call, mem_ctx, &pol);
+        if (transport != NCACN_IP_TCP) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
+        /*
+         * We don't have policy handles on this call. So this must be restricted
+         * to crypto connections only.
+         */
+        if (auth->auth_type != DCERPC_AUTH_TYPE_SCHANNEL ||
+            auth->auth_level < DCERPC_AUTH_LEVEL_INTEGRITY) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
+        status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx,
+, /* we skip access checks */
+                                             &policy_state);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
+        }
+        /* ensure this handle goes away at the end of this call */
+        DCESRV_PULL_HANDLE(h, r2.in.handle, LSA_HANDLE_POLICY);
+        talloc_steal(mem_ctx, h);
+        r2.in.sids     = r->in.sids;
+        r2.in.names    = r->in.names;
+        r2.in.level    = r->in.level;
+        r2.in.count    = r->in.count;
+        r2.in.lookup_options = r->in.lookup_options;
+        r2.in.client_revision = r->in.client_revision;
+        r2.out.count   = r->out.count;
+        r2.out.names   = r->out.names;
+        r2.out.domains = r->out.domains;
+        status = dcesrv_lsa_LookupSids2(dce_call, mem_ctx, &r2);
+        r->out.domains = r2.out.domains;
+        r->out.names   = r2.out.names;
+        r->out.count   = r2.out.count;
+        ZERO_STRUCT(q);
+        q.in.handle   = NULL;
+        q.in.sids     = r->in.sids;
+        q.in.names    = r->in.names;
+        q.in.level    = r->in.level;
+        q.in.count    = r->in.count;
+        q.in.lookup_options = r->in.lookup_options;
+        q.in.client_revision = r->in.client_revision;
+        q.out.count   = r->out.count;
+        q.out.names   = r->out.names;
+        q.out.domains = r->out.domains;
+        status = dcesrv_lsa_LookupSids_common(dce_call,
+                                              mem_ctx,
+                                              policy_state,
+                                              &q);
+        talloc_free(policy_state);
+        r->out.count = q.out.count;
+        r->out.names = q.out.names;
+        r->out.domains = q.out.domains;
         return status;
 …
                                struct lsa_LookupSids *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
         struct lsa_LookupSids2 r2;
         NTSTATUS status;
         uint32_t i;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         ZERO_STRUCT(r2);
 …
+}
+/*
+  lsa_LookupNames3
+*/
+NTSTATUS dcesrv_lsa_LookupNames3(struct dcesrv_call_state *dce_call,
+                                 TALLOC_CTX *mem_ctx,
+                                 struct lsa_LookupNames3 *r)
+{
+        struct lsa_policy_state *policy_state;
+        struct dcesrv_handle *policy_handle;
+        uint32_t i;
+static NTSTATUS dcesrv_lsa_LookupNames_common(struct dcesrv_call_state *dce_call,
+                                              TALLOC_CTX *mem_ctx,
+                                              struct lsa_policy_state *policy_state,
+                                              struct lsa_LookupNames3 *r)
+{
         struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
         struct lsa_RefDomainList *domains;
+        DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
+        uint32_t i;
         if (r->in.level < LSA_LOOKUP_NAMES_ALL ||
 …
                 return NT_STATUS_INVALID_PARAMETER;
+        }
-        policy_state = policy_handle->data;
         *r->out.domains = NULL;
 …
+}
+/*
+  lsa_LookupNames3
+*/
+NTSTATUS dcesrv_lsa_LookupNames3(struct dcesrv_call_state *dce_call,
+                                 TALLOC_CTX *mem_ctx,
+                                 struct lsa_LookupNames3 *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
+        struct lsa_policy_state *policy_state;
+        struct dcesrv_handle *policy_handle;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
+        DCESRV_PULL_HANDLE(policy_handle, r->in.handle, LSA_HANDLE_POLICY);
+        policy_state = policy_handle->data;
+        return dcesrv_lsa_LookupNames_common(dce_call,
+                                             mem_ctx,
+                                             policy_state,
+                                             r);
+}
 /*
   lsa_LookupNames4
 …
                                  struct lsa_LookupNames4 *r)
+{
+        struct lsa_LookupNames3 r2;
+        struct lsa_OpenPolicy2 pol;
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
+        const struct dcesrv_auth *auth = &dce_call->conn->auth_state;
+        struct lsa_policy_state *policy_state;
+        struct lsa_LookupNames3 q;
         NTSTATUS status;
+        struct dcesrv_handle *h;
+        ZERO_STRUCT(r2);
+        /* No policy handle on the wire, so make one up here */
+        r2.in.handle = talloc(mem_ctx, struct policy_handle);
+        if (!r2.in.handle) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        pol.out.handle = r2.in.handle;
+        pol.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
+        pol.in.attr = NULL;
+        pol.in.system_name = NULL;
+        status = dcesrv_lsa_OpenPolicy2(dce_call, mem_ctx, &pol);
+        if (transport != NCACN_IP_TCP) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
+        /*
+         * We don't have policy handles on this call. So this must be restricted
+         * to crypto connections only.
+         */
+        if (auth->auth_type != DCERPC_AUTH_TYPE_SCHANNEL ||
+            auth->auth_level < DCERPC_AUTH_LEVEL_INTEGRITY) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
+        status = dcesrv_lsa_get_policy_state(dce_call, mem_ctx,
+, /* we skip access checks */
+                                             &policy_state);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
+        }
+        /* ensure this handle goes away at the end of this call */
+        DCESRV_PULL_HANDLE(h, r2.in.handle, LSA_HANDLE_POLICY);
+        talloc_steal(mem_ctx, h);
+        r2.in.num_names = r->in.num_names;
+        r2.in.names = r->in.names;
+        r2.in.level = r->in.level;
+        r2.in.sids = r->in.sids;
+        r2.in.count = r->in.count;
+        r2.in.lookup_options = r->in.lookup_options;
+        r2.in.client_revision = r->in.client_revision;
+        r2.out.domains = r->out.domains;
+        r2.out.sids = r->out.sids;
+        r2.out.count = r->out.count;
+        status = dcesrv_lsa_LookupNames3(dce_call, mem_ctx, &r2);
+        r->out.domains = r2.out.domains;
+        r->out.sids = r2.out.sids;
+        r->out.count = r2.out.count;
+        ZERO_STRUCT(q);
+        q.in.handle = NULL;
+        q.in.num_names = r->in.num_names;
+        q.in.names = r->in.names;
+        q.in.level = r->in.level;
+        q.in.sids = r->in.sids;
+        q.in.count = r->in.count;
+        q.in.lookup_options = r->in.lookup_options;
+        q.in.client_revision = r->in.client_revision;
+        q.out.count = r->out.count;
+        q.out.sids = r->out.sids;
+        q.out.domains = r->out.domains;
+        status = dcesrv_lsa_LookupNames_common(dce_call,
+                                               mem_ctx,
+                                               policy_state,
+                                               &q);
+        talloc_free(policy_state);
+        r->out.count = q.out.count;
+        r->out.sids = q.out.sids;
+        r->out.domains = q.out.domains;
         return status;
+}
 …
                                  struct lsa_LookupNames2 *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
         struct lsa_policy_state *state;
         struct dcesrv_handle *h;
 …
         struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
         struct lsa_RefDomainList *domains;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         *r->out.domains = NULL;
 …
                        struct lsa_LookupNames *r)
+{
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
         struct lsa_LookupNames2 r2;
         NTSTATUS status;
         uint32_t i;
+        if (transport != NCACN_NP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         ZERO_STRUCT(r2);

vendor/current/source4/rpc_server/netlogon/dcerpc_netlogon.c

-              r740
+              r988
 #include "dsdb/samdb/samdb.h"
 #include "../lib/util/util_ldb.h"
+#include "../lib/util/memcache.h"
 #include "../libcli/auth/schannel.h"
 #include "libcli/security/security.h"
 …
 #include "librpc/gen_ndr/ndr_irpc_c.h"
 #include "../libcli/ldap/ldap_ndr.h"
 #include "cldap_server/cldap_server.h"
+#include "dsdb/samdb/ldb_modules/util.h"
 #include "lib/tsocket/tsocket.h"
 #include "librpc/gen_ndr/ndr_netlogon.h"
+#include "librpc/gen_ndr/ndr_lsa.h"
+#include "librpc/gen_ndr/ndr_samr.h"
 #include "librpc/gen_ndr/ndr_irpc.h"
+#include "librpc/gen_ndr/ndr_winbind.h"
+#include "librpc/gen_ndr/ndr_winbind_c.h"
+#include "lib/socket/netif.h"
+#define DCESRV_INTERFACE_NETLOGON_BIND(call, iface) \
+       dcesrv_interface_netlogon_bind(call, iface)
+static NTSTATUS dcesrv_interface_netlogon_bind(struct dcesrv_call_state *dce_call,
+                                               const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_reject_connect(dce_call, iface);
+}
+static struct memcache *global_challenge_table;
 struct netlogon_server_pipe_state {
 …
         struct netlogon_server_pipe_state *pipe_state =
                 talloc_get_type(dce_call->context->private_data, struct netlogon_server_pipe_state);
+        DATA_BLOB key, val;
         ZERO_STRUCTP(r->out.return_credentials);
+        if (global_challenge_table == NULL) {
+                /*
+                 * We maintain a global challenge table
+                 * with a fixed size (8k)
+                 *
+                 * This is required for the strange clients
+                 * which use different connections for
+                 * netr_ServerReqChallenge() and netr_ServerAuthenticate3()
+                 *
+                 */
+                global_challenge_table = memcache_init(talloc_autofree_context(),
+);
+                if (global_challenge_table == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+        }
         /* destroyed on pipe shutdown */
 …
         dce_call->context->private_data = pipe_state;
+        key = data_blob_string_const(r->in.computer_name);
+        val = data_blob_const(pipe_state, sizeof(*pipe_state));
+        memcache_add(global_challenge_table, SINGLETON_CACHE, key, val);
         return NT_STATUS_OK;
+}
 …
         struct netlogon_server_pipe_state *pipe_state =
                 talloc_get_type(dce_call->context->private_data, struct netlogon_server_pipe_state);
+        DATA_BLOB challenge_key;
+        bool challenge_valid = false;
+        struct netlogon_server_pipe_state challenge;
         struct netlogon_creds_CredentialState *creds;
         struct ldb_context *sam_ctx;
+        struct samr_Password *mach_pwd;
+        struct samr_Password *curNtHash = NULL;
+        struct samr_Password *prevNtHash = NULL;
         uint32_t user_account_control;
         int num_records;
 …
         const char *attrs[] = {"unicodePwd", "userAccountControl",
                                "objectSid", NULL};
-        const char *trust_dom_attrs[] = {"flatname", NULL};
         const char *account_name;
+        uint32_t server_flags = 0;
+        uint32_t negotiate_flags = 0;
+        bool allow_nt4_crypto = lpcfg_allow_nt4_crypto(dce_call->conn->dce_ctx->lp_ctx);
+        bool reject_des_client = !allow_nt4_crypto;
+        bool reject_md5_client = lpcfg_reject_md5_clients(dce_call->conn->dce_ctx->lp_ctx);
+        int schannel = lpcfg_server_schannel(dce_call->conn->dce_ctx->lp_ctx);
+        bool reject_none_rpc = (schannel == true);
         ZERO_STRUCTP(r->out.return_credentials);
         *r->out.rid = 0;
+        challenge_key = data_blob_string_const(r->in.computer_name);
+        if (pipe_state != NULL) {
+                dce_call->context->private_data = NULL;
+                /*
+                 * If we had a challenge remembered on the connection
+                 * consider this for usage. This can't be cleanup
+                 * by other clients.
+                 *
+                 * This is the default code path for typical clients
+                 * which call netr_ServerReqChallenge() and
+                 * netr_ServerAuthenticate3() on the same dcerpc connection.
+                 */
+                challenge = *pipe_state;
+                TALLOC_FREE(pipe_state);
+                challenge_valid = true;
+        } else {
+                DATA_BLOB val;
+                bool ok;
+                /*
+                 * Fallback and try to get the challenge from
+                 * the global cache.
+                 *
+                 * If too many clients are using this code path,
+                 * they may destroy their cache entries as the
+                 * global_challenge_table memcache has a fixed size.
+                 *
+                 * Note: this handles global_challenge_table == NULL fine
+                 */
+                ok = memcache_lookup(global_challenge_table, SINGLETON_CACHE,
+                                     challenge_key, &val);
+                if (ok && val.length == sizeof(challenge)) {
+                        memcpy(&challenge, val.data, sizeof(challenge));
+                        challenge_valid = true;
+                } else {
+                        ZERO_STRUCT(challenge);
+                }
+        }
+        server_flags = NETLOGON_NEG_ACCOUNT_LOCKOUT |
+                       NETLOGON_NEG_PERSISTENT_SAMREPL |
+                       NETLOGON_NEG_ARCFOUR |
+                       NETLOGON_NEG_PROMOTION_COUNT |
+                       NETLOGON_NEG_CHANGELOG_BDC |
+                       NETLOGON_NEG_FULL_SYNC_REPL |
+                       NETLOGON_NEG_MULTIPLE_SIDS |
+                       NETLOGON_NEG_REDO |
+                       NETLOGON_NEG_PASSWORD_CHANGE_REFUSAL |
+                       NETLOGON_NEG_SEND_PASSWORD_INFO_PDC |
+                       NETLOGON_NEG_GENERIC_PASSTHROUGH |
+                       NETLOGON_NEG_CONCURRENT_RPC |
+                       NETLOGON_NEG_AVOID_ACCOUNT_DB_REPL |
+                       NETLOGON_NEG_AVOID_SECURITYAUTH_DB_REPL |
+                       NETLOGON_NEG_STRONG_KEYS |
+                       NETLOGON_NEG_TRANSITIVE_TRUSTS |
+                       NETLOGON_NEG_DNS_DOMAIN_TRUSTS |
+                       NETLOGON_NEG_PASSWORD_SET2 |
+                       NETLOGON_NEG_GETDOMAININFO |
+                       NETLOGON_NEG_CROSS_FOREST_TRUSTS |
+                       NETLOGON_NEG_NEUTRALIZE_NT4_EMULATION |
+                       NETLOGON_NEG_RODC_PASSTHROUGH |
+                       NETLOGON_NEG_SUPPORTS_AES |
+                       NETLOGON_NEG_AUTHENTICATED_RPC_LSASS |
+                       NETLOGON_NEG_AUTHENTICATED_RPC;
+        negotiate_flags = *r->in.negotiate_flags & server_flags;
+        if (negotiate_flags & NETLOGON_NEG_AUTHENTICATED_RPC) {
+                reject_none_rpc = false;
+        }
+        if (negotiate_flags & NETLOGON_NEG_STRONG_KEYS) {
+                reject_des_client = false;
+        }
+        if (negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                reject_des_client = false;
+                reject_md5_client = false;
+        }
+        if (reject_des_client || reject_md5_client) {
+                /*
+                 * Here we match Windows 2012 and return no flags.
+                 */
+                *r->out.negotiate_flags = 0;
+                return NT_STATUS_DOWNGRADE_DETECTED;
+        }
+        /*
+         * At this point we can cleanup the cache entry,
+         * if we fail the client needs to call netr_ServerReqChallenge
+         * again.
+         *
+         * Note: this handles global_challenge_table == NULL
+         * and also a non existing record just fine.
+         */
+        memcache_delete(global_challenge_table,
+                        SINGLETON_CACHE, challenge_key);
         /*
 …
          * call fails with access denied!
          */
+        *r->out.negotiate_flags = NETLOGON_NEG_ACCOUNT_LOCKOUT |
+                                  NETLOGON_NEG_PERSISTENT_SAMREPL |
+                                  NETLOGON_NEG_ARCFOUR |
+                                  NETLOGON_NEG_PROMOTION_COUNT |
+                                  NETLOGON_NEG_CHANGELOG_BDC |
+                                  NETLOGON_NEG_FULL_SYNC_REPL |
+                                  NETLOGON_NEG_MULTIPLE_SIDS |
+                                  NETLOGON_NEG_REDO |
+                                  NETLOGON_NEG_PASSWORD_CHANGE_REFUSAL |
+                                  NETLOGON_NEG_SEND_PASSWORD_INFO_PDC |
+                                  NETLOGON_NEG_GENERIC_PASSTHROUGH |
+                                  NETLOGON_NEG_CONCURRENT_RPC |
+                                  NETLOGON_NEG_AVOID_ACCOUNT_DB_REPL |
+                                  NETLOGON_NEG_AVOID_SECURITYAUTH_DB_REPL |
+                                  NETLOGON_NEG_STRONG_KEYS |
+                                  NETLOGON_NEG_TRANSITIVE_TRUSTS |
+                                  NETLOGON_NEG_DNS_DOMAIN_TRUSTS |
+                                  NETLOGON_NEG_PASSWORD_SET2 |
+                                  NETLOGON_NEG_GETDOMAININFO |
+                                  NETLOGON_NEG_CROSS_FOREST_TRUSTS |
+                                  NETLOGON_NEG_NEUTRALIZE_NT4_EMULATION |
+                                  NETLOGON_NEG_RODC_PASSTHROUGH |
+                                  NETLOGON_NEG_AUTHENTICATED_RPC_LSASS |
+                                  NETLOGON_NEG_AUTHENTICATED_RPC;
+        *r->out.negotiate_flags = negotiate_flags;
+        if (reject_none_rpc) {
+                /* schannel must be used, but client did not offer it. */
+                DEBUG(0,("%s: schannel required but client failed "
+                        "to offer it. Client was %s\n",
+                        __func__, r->in.account_name));
+                return NT_STATUS_ACCESS_DENIED;
+        }
         switch (r->in.secure_channel_type) {
 …
         case SEC_CHAN_RODC:
                 break;
+        case SEC_CHAN_NULL:
+                return NT_STATUS_INVALID_PARAMETER;
         default:
                 DEBUG(1, ("Client asked for an invalid secure channel type: %d\n",
 …
+        }
+        if (r->in.secure_channel_type == SEC_CHAN_DNS_DOMAIN) {
+                char *encoded_account = ldb_binary_encode_string(mem_ctx, r->in.account_name);
+                const char *flatname;
+                if (!encoded_account) {
+        if (r->in.secure_channel_type == SEC_CHAN_DOMAIN ||
+            r->in.secure_channel_type == SEC_CHAN_DNS_DOMAIN)
+        {
+                struct ldb_message *tdo_msg = NULL;
+                const char * const tdo_attrs[] = {
+                        "trustAuthIncoming",
+                        "trustAttributes",
+                        "flatName",
+                        NULL
+                };
+                char *encoded_name = NULL;
+                size_t len;
+                const char *flatname = NULL;
+                char trailer = '$';
+                bool require_trailer = true;
+                const char *netbios = NULL;
+                const char *dns = NULL;
+                if (r->in.secure_channel_type == SEC_CHAN_DNS_DOMAIN) {
+                        trailer = '.';
+                        require_trailer = false;
+                }
+                encoded_name = ldb_binary_encode_string(mem_ctx,
+                                                        r->in.account_name);
+                if (encoded_name == NULL) {
                         return NT_STATUS_NO_MEMORY;
+                }
+                /* Kill the trailing dot */
+                if (encoded_account[strlen(encoded_account)-1] == '.') {
+                        encoded_account[strlen(encoded_account)-1] = '\0';
+                }
+                /* pull the user attributes */
+                num_records = gendb_search(sam_ctx, mem_ctx, NULL, &msgs,
+                                           trust_dom_attrs,
+                                           "(&(trustPartner=%s)(objectclass=trustedDomain))",
+                                           encoded_account);
+                if (num_records == 0) {
+                        DEBUG(3,("Couldn't find trust [%s] in samdb.\n",
+                                 encoded_account));
+                len = strlen(encoded_name);
+                if (len < 2) {
                         return NT_STATUS_NO_TRUST_SAM_ACCOUNT;
+                }
+                if (num_records > 1) {
+                        DEBUG(0,("Found %d records matching user [%s]\n", num_records, r->in.account_name));
+                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                }
+                flatname = ldb_msg_find_attr_as_string(msgs[0], "flatname", NULL);
+                if (!flatname) {
+                        /* No flatname for this trust - we can't proceed */
+                if (require_trailer && encoded_name[len - 1] != trailer) {
                         return NT_STATUS_NO_TRUST_SAM_ACCOUNT;
+                }
+                encoded_name[len - 1] = '\0';
+                if (r->in.secure_channel_type == SEC_CHAN_DNS_DOMAIN) {
+                        dns = encoded_name;
+                } else {
+                        netbios = encoded_name;
+                }
+                nt_status = dsdb_trust_search_tdo(sam_ctx,
+                                                  netbios, dns,
+                                                  tdo_attrs, mem_ctx, &tdo_msg);
+                if (NT_STATUS_EQUAL(nt_status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                        DEBUG(2, ("Client asked for a trusted domain secure channel, "
+                                  "but there's no tdo for [%s] => [%s] \n",
+                                  r->in.account_name, encoded_name));
+                        return NT_STATUS_NO_TRUST_SAM_ACCOUNT;
+                }
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
+                nt_status = dsdb_trust_get_incoming_passwords(tdo_msg, mem_ctx,
+                                                              &curNtHash,
+                                                              &prevNtHash);
+                if (NT_STATUS_EQUAL(nt_status, NT_STATUS_ACCOUNT_DISABLED)) {
+                        return NT_STATUS_NO_TRUST_SAM_ACCOUNT;
+                }
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
+                flatname = ldb_msg_find_attr_as_string(tdo_msg, "flatName", NULL);
+                if (flatname == NULL) {
+                        return NT_STATUS_NO_TRUST_SAM_ACCOUNT;
+                }
                 account_name = talloc_asprintf(mem_ctx, "%s$", flatname);
+                if (!account_name) {
+                if (account_name == NULL) {
                         return NT_STATUS_NO_MEMORY;
+                }
         } else {
                 account_name = r->in.account_name;
 …
+        }
+        *r->out.rid = samdb_result_rid_from_sid(mem_ctx, msgs[0],
+                                                "objectSid", 0);
+        mach_pwd = samdb_result_hash(mem_ctx, msgs[0], "unicodePwd");
+        if (mach_pwd == NULL) {
+        if (!(user_account_control & UF_INTERDOMAIN_TRUST_ACCOUNT)) {
+                nt_status = samdb_result_passwords_no_lockout(mem_ctx,
+                                        dce_call->conn->dce_ctx->lp_ctx,
+                                        msgs[0], NULL, &curNtHash);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return NT_STATUS_ACCESS_DENIED;
+                }
+        }
+        if (curNtHash == NULL) {
                 return NT_STATUS_ACCESS_DENIED;
+        }
+        if (!pipe_state) {
+                DEBUG(1, ("No challenge requested by client, cannot authenticate\n"));
+        if (!challenge_valid) {
+                DEBUG(1, ("No challenge requested by client [%s/%s], "
+                          "cannot authenticate\n",
+                          r->in.computer_name,
+                          r->in.account_name));
                 return NT_STATUS_ACCESS_DENIED;
+        }
 …
                                            r->in.computer_name,
                                            r->in.secure_channel_type,
                                            &pipe_state->client_challenge,
                                            &pipe_state->server_challenge,
                                            mach_pwd,
+                                           &challenge.client_challenge,
+                                           &challenge.server_challenge,
+                                           curNtHash,
                                            r->in.credentials,
                                            r->out.return_credentials,
+                                           *r->in.negotiate_flags);
+        if (!creds) {
+                                           negotiate_flags);
+        if (creds == NULL && prevNtHash != NULL) {
+                /*
+                 * We fallback to the previous password for domain trusts.
+                 *
+                 * Note that lpcfg_old_password_allowed_period() doesn't
+                 * apply here.
+                 */
+                creds = netlogon_creds_server_init(mem_ctx,
+                                                   r->in.account_name,
+                                                   r->in.computer_name,
+                                                   r->in.secure_channel_type,
+                                                   &challenge.client_challenge,
+                                                   &challenge.server_challenge,
+                                                   prevNtHash,
+                                                   r->in.credentials,
+                                                   r->out.return_credentials,
+                                                   negotiate_flags);
+        }
+        if (creds == NULL) {
                 return NT_STATUS_ACCESS_DENIED;
+        }
 …
         nt_status = schannel_save_creds_state(mem_ctx,
                                               lpcfg_private_dir(dce_call->conn->dce_ctx->lp_ctx),
+                                              dce_call->conn->dce_ctx->lp_ctx,
                                               creds);
+        return nt_status;
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                ZERO_STRUCTP(r->out.return_credentials);
+                return nt_status;
+        }
+        *r->out.rid = samdb_result_rid_from_sid(mem_ctx, msgs[0],
+                                                "objectSid", 0);
+        return NT_STATUS_OK;
+}
 …
  * If schannel is required for this call test that it actually is available.
  */
 static NTSTATUS schannel_check_required(struct dcerpc_auth *auth_info,
+static NTSTATUS schannel_check_required(const struct dcesrv_auth *auth_info,
                                         const char *computer_name,
                                         bool integrity, bool privacy)
 …
+{
         NTSTATUS nt_status;
         struct dcerpc_auth *auth_info = dce_call->conn->auth_state.auth_info;
         bool schannel_global_required = false; /* Should be lpcfg_schannel_server() == true */
+        int schannel = lpcfg_server_schannel(dce_call->conn->dce_ctx->lp_ctx);
+        bool schannel_global_required = (schannel == true);
         if (schannel_global_required) {
                 nt_status = schannel_check_required(auth_info,
+                nt_status = schannel_check_required(&dce_call->conn->auth_state,
                                                     computer_name,
                                                     true, false);
 …
         nt_status = schannel_check_creds_state(mem_ctx,
                                                lpcfg_private_dir(dce_call->conn->dce_ctx->lp_ctx),
+                                               dce_call->conn->dce_ctx->lp_ctx,
                                                computer_name,
                                                received_authenticator,
 …
+        }
         nt_status = samdb_result_passwords(mem_ctx,
                                            dce_call->conn->dce_ctx->lp_ctx,
                                            res[0], NULL, &oldNtHash);
+        nt_status = samdb_result_passwords_no_lockout(mem_ctx,
+                                                      dce_call->conn->dce_ctx->lp_ctx,
+                                                      res[0], NULL, &oldNtHash);
         if (!NT_STATUS_IS_OK(nt_status) || !oldNtHash) {
                 return NT_STATUS_WRONG_PASSWORD;
 …
         nt_status = samdb_set_password_sid(sam_ctx, mem_ctx,
                                            creds->sid,
+                                           NULL, /* Don't have version */
                                            NULL, /* Don't have plaintext */
                                            NULL, r->in.new_password,
 …
         struct ldb_message **res;
         struct samr_Password *oldLmHash, *oldNtHash;
+        struct NL_PASSWORD_VERSION version = {};
+        const uint32_t *new_version = NULL;
         NTSTATUS nt_status;
         DATA_BLOB new_password;
         int ret;
         struct samr_CryptPassword password_buf;
 …
         memcpy(password_buf.data, r->in.new_password->data, 512);
         SIVAL(password_buf.data, 512, r->in.new_password->length);
+        netlogon_creds_arcfour_crypt(creds, password_buf.data, 516);
+        if (creds->negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                netlogon_creds_aes_decrypt(creds, password_buf.data, 516);
+        } else {
+                netlogon_creds_arcfour_crypt(creds, password_buf.data, 516);
+        }
+        switch (creds->secure_channel_type) {
+        case SEC_CHAN_DOMAIN:
+        case SEC_CHAN_DNS_DOMAIN: {
+                uint32_t len = IVAL(password_buf.data, 512);
+                if (len <= 500) {
+                        uint32_t ofs = 500 - len;
+                        uint8_t *p;
+                        p = password_buf.data + ofs;
+                        version.ReservedField = IVAL(p, 0);
+                        version.PasswordVersionNumber = IVAL(p, 4);
+                        version.PasswordVersionPresent = IVAL(p, 8);
+                        if (version.PasswordVersionPresent == NETLOGON_PASSWORD_VERSION_NUMBER_PRESENT) {
+                                new_version = &version.PasswordVersionNumber;
+                        }
+                }}
+                break;
+        default:
+                break;
+        }
         if (!extract_pw_from_buffer(mem_ctx, password_buf.data, &new_password)) {
 …
+        }
         nt_status = samdb_result_passwords(mem_ctx,
                                            dce_call->conn->dce_ctx->lp_ctx,
                                            res[0], &oldLmHash, &oldNtHash);
+        nt_status = samdb_result_passwords_no_lockout(mem_ctx,
+                                                      dce_call->conn->dce_ctx->lp_ctx,
+                                                      res[0], &oldLmHash, &oldNtHash);
         if (!NT_STATUS_IS_OK(nt_status) || (!oldLmHash && !oldNtHash)) {
                 return NT_STATUS_WRONG_PASSWORD;
 …
         nt_status = samdb_set_password_sid(sam_ctx, mem_ctx,
                                            creds->sid,
+                                           new_version,
                                            &new_password, /* we have plaintext */
                                            NULL, NULL,
 …
                                         struct netr_LogonSamLogonEx *r, struct netlogon_creds_CredentialState *creds)
+{
+        struct auth_context *auth_context;
+        struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        const char *workgroup = lpcfg_workgroup(lp_ctx);
+        struct auth4_context *auth_context;
         struct auth_usersupplied_info *user_info;
         struct auth_user_info_dc *user_info_dc;
         NTSTATUS nt_status;
-        static const char zeros[16];
         struct netr_SamBaseInfo *sam;
         struct netr_SamInfo2 *sam2;
 …
         user_info = talloc_zero(mem_ctx, struct auth_usersupplied_info);
         NT_STATUS_HAVE_NO_MEMORY(user_info);
+        netlogon_creds_decrypt_samlogon_logon(creds,
+                                              r->in.logon_level,
+                                              r->in.logon);
         switch (r->in.logon_level) {
 …
         case NetlogonInteractiveTransitiveInformation:
         case NetlogonServiceTransitiveInformation:
-                if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
-                        netlogon_creds_arcfour_crypt(creds,
-                                            r->in.logon->password->lmpassword.hash,
-                                            sizeof(r->in.logon->password->lmpassword.hash));
-                        netlogon_creds_arcfour_crypt(creds,
-                                            r->in.logon->password->ntpassword.hash,
-                                            sizeof(r->in.logon->password->ntpassword.hash));
-                } else {
-                        netlogon_creds_des_decrypt(creds, &r->in.logon->password->lmpassword);
-                        netlogon_creds_des_decrypt(creds, &r->in.logon->password->ntpassword);
+                }
                 /* TODO: we need to deny anonymous access here */
 …
                 user_info->password.response.nt = data_blob_talloc(mem_ctx, r->in.logon->network->nt.data, r->in.logon->network->nt.length);
+                nt_status = NTLMv2_RESPONSE_verify_netlogon_creds(
+                                        user_info->client.account_name,
+                                        user_info->client.domain_name,
+                                        user_info->password.response.nt,
+                                        creds, workgroup);
+                NT_STATUS_NOT_OK_RETURN(nt_status);
                 break;
 …
         case NetlogonGenericInformation:
+        {
+                if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
+                        netlogon_creds_arcfour_crypt(creds,
+                                            r->in.logon->generic->data, r->in.logon->generic->length);
+                if (creds->negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                        /* OK */
+                } else if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
+                        /* OK */
                 } else {
                         /* Using DES to verify kerberos tickets makes no sense */
 …
                                                 r->in.logon->generic->length);
+                        /*
+                         * TODO: make this async and avoid
+                         * dcerpc_binding_handle_set_sync_ev()
+                         */
+                        dcerpc_binding_handle_set_sync_ev(irpc_handle,
+                                                          dce_call->event_ctx);
                         status = dcerpc_kdc_check_generic_kerberos_r(irpc_handle,
                                                                      mem_ctx,
 …
         case 6:
+                if (dce_call->conn->auth_state.auth_level < DCERPC_AUTH_LEVEL_PRIVACY) {
+                        return NT_STATUS_INVALID_PARAMETER;
+                }
                 nt_status = auth_convert_user_info_dc_saminfo3(mem_ctx,
                                                            user_info_dc,
 …
+        }
+        /* Don't crypt an all-zero key, it would give away the NETLOGON pipe session key */
+        /* It appears that level 6 is not individually encrypted */
+        if ((r->in.validation_level != 6) &&
+            memcmp(sam->key.key, zeros, sizeof(sam->key.key)) != 0) {
+                /* This key is sent unencrypted without the ARCFOUR flag set */
+                if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
+                        netlogon_creds_arcfour_crypt(creds,
+                                            sam->key.key,
+                                            sizeof(sam->key.key));
+                }
+        }
+        /* Don't crypt an all-zero key, it would give away the NETLOGON pipe session key */
+        /* It appears that level 6 is not individually encrypted */
+        if ((r->in.validation_level != 6) &&
+            memcmp(sam->LMSessKey.key, zeros, sizeof(sam->LMSessKey.key)) != 0) {
+                if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
+                        netlogon_creds_arcfour_crypt(creds,
+                                            sam->LMSessKey.key,
+                                            sizeof(sam->LMSessKey.key));
+                } else {
+                        netlogon_creds_des_encrypt_LMKey(creds,
+                                                &sam->LMSessKey);
+                }
+        }
+        netlogon_creds_encrypt_samlogon_validation(creds,
+                                                   r->in.validation_level,
+                                                   r->out.validation);
         /* TODO: Describe and deal with these flags */
 …
         nt_status = schannel_get_creds_state(mem_ctx,
                                              lpcfg_private_dir(dce_call->conn->dce_ctx->lp_ctx),
+                                             dce_call->conn->dce_ctx->lp_ctx,
                                              r->in.computer_name, &creds);
         if (!NT_STATUS_IS_OK(nt_status)) {
 …
+        }
+        if (!dce_call->conn->auth_state.auth_info ||
+            dce_call->conn->auth_state.auth_info->auth_type != DCERPC_AUTH_TYPE_SCHANNEL) {
+        if (dce_call->conn->auth_state.auth_type != DCERPC_AUTH_TYPE_SCHANNEL) {
                 return NT_STATUS_ACCESS_DENIED;
+        }
 …
                                        r->in.domainname);
         if (domain_dn == NULL) {
                 return WERR_DS_UNAVAILABLE;
+                return WERR_NO_SUCH_DOMAIN;
+        }
 …
+}
+struct dcesrv_netr_LogonControl_base_state {
+        struct dcesrv_call_state *dce_call;
+        TALLOC_CTX *mem_ctx;
+        struct netr_LogonControl2Ex r;
+        struct {
+                struct netr_LogonControl *l;
+                struct netr_LogonControl2 *l2;
+                struct netr_LogonControl2Ex *l2ex;
+        } _r;
+};
+static void dcesrv_netr_LogonControl_base_done(struct tevent_req *subreq);
+static WERROR dcesrv_netr_LogonControl_base_call(struct dcesrv_netr_LogonControl_base_state *state)
+{
+        struct dcesrv_connection *conn = state->dce_call->conn;
+        struct loadparm_context *lp_ctx = state->dce_call->conn->dce_ctx->lp_ctx;
+        struct auth_session_info *session_info = conn->auth_state.session_info;
+        enum security_user_level security_level;
+        struct dcerpc_binding_handle *irpc_handle;
+        struct tevent_req *subreq;
+        bool ok;
+        /* TODO: check for WERR_INVALID_COMPUTERNAME ? */
+        if (state->_r.l != NULL) {
+                /*
+                 * netr_LogonControl
+                 */
+                if (state->r.in.level == 0x00000002) {
+                        return WERR_NOT_SUPPORTED;
+                } else if (state->r.in.level != 0x00000001) {
+                        return WERR_INVALID_LEVEL;
+                }
+                switch (state->r.in.function_code) {
+                case NETLOGON_CONTROL_QUERY:
+                case NETLOGON_CONTROL_REPLICATE:
+                case NETLOGON_CONTROL_SYNCHRONIZE:
+                case NETLOGON_CONTROL_PDC_REPLICATE:
+                case NETLOGON_CONTROL_BREAKPOINT:
+                case NETLOGON_CONTROL_BACKUP_CHANGE_LOG:
+                case NETLOGON_CONTROL_TRUNCATE_LOG:
+                        break;
+                default:
+                        return WERR_NOT_SUPPORTED;
+                }
+        }
+        if (state->r.in.level < 0x00000001) {
+                return WERR_INVALID_LEVEL;
+        }
+        if (state->r.in.level > 0x00000004) {
+                return WERR_INVALID_LEVEL;
+        }
+        if (state->r.in.function_code == NETLOGON_CONTROL_QUERY) {
+                struct netr_NETLOGON_INFO_1 *info1 = NULL;
+                struct netr_NETLOGON_INFO_3 *info3 = NULL;
+                switch (state->r.in.level) {
+                case 0x00000001:
+                        info1 = talloc_zero(state->mem_ctx,
+                                            struct netr_NETLOGON_INFO_1);
+                        if (info1 == NULL) {
+                                return WERR_NOMEM;
+                        }
+                        state->r.out.query->info1 = info1;
+                        return WERR_OK;
+                case 0x00000003:
+                        info3 = talloc_zero(state->mem_ctx,
+                                            struct netr_NETLOGON_INFO_3);
+                        if (info3 == NULL) {
+                                return WERR_NOMEM;
+                        }
+                        state->r.out.query->info3 = info3;
+                        return WERR_OK;
+                default:
+                        return WERR_INVALID_PARAMETER;
+                }
+        }
+        /*
+         * Some validations are done before the access check
+         * and some after the access check
+         */
+        security_level = security_session_user_level(session_info, NULL);
+        if (security_level < SECURITY_ADMINISTRATOR) {
+                return WERR_ACCESS_DENIED;
+        }
+        if (state->_r.l2 != NULL) {
+                /*
+                 * netr_LogonControl2
+                 */
+                if (state->r.in.level == 0x00000004) {
+                        return WERR_INVALID_LEVEL;
+                }
+        }
+        switch (state->r.in.level) {
+        case 0x00000001:
+                break;
+        case 0x00000002:
+                switch (state->r.in.function_code) {
+                case NETLOGON_CONTROL_REDISCOVER:
+                case NETLOGON_CONTROL_TC_QUERY:
+                case NETLOGON_CONTROL_TC_VERIFY:
+                        break;
+                default:
+                        return WERR_INVALID_PARAMETER;
+                }
+                break;
+        case 0x00000003:
+                break;
+        case 0x00000004:
+                if (state->r.in.function_code != NETLOGON_CONTROL_FIND_USER) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                break;
+        default:
+                return WERR_INVALID_LEVEL;
+        }
+        switch (state->r.in.function_code) {
+        case NETLOGON_CONTROL_REDISCOVER:
+        case NETLOGON_CONTROL_TC_QUERY:
+        case NETLOGON_CONTROL_TC_VERIFY:
+                if (state->r.in.level != 2) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                if (state->r.in.data == NULL) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                if (state->r.in.data->domain == NULL) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                break;
+        case NETLOGON_CONTROL_CHANGE_PASSWORD:
+                if (state->r.in.level != 1) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                if (state->r.in.data == NULL) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                if (state->r.in.data->domain == NULL) {
+                        return WERR_INVALID_PARAMETER;
+                }
+                ok = lpcfg_is_my_domain_or_realm(lp_ctx,
+                                                 state->r.in.data->domain);
+                if (!ok) {
+                        struct ldb_context *sam_ctx;
+                        sam_ctx = samdb_connect(state, state->dce_call->event_ctx,
+                                                lp_ctx, system_session(lp_ctx), 0);
+                        if (sam_ctx == NULL) {
+                                return WERR_DS_UNAVAILABLE;
+                        }
+                        /*
+                         * Secrets for trusted domains can only be triggered on
+                         * the PDC.
+                         */
+                        ok = samdb_is_pdc(sam_ctx);
+                        TALLOC_FREE(sam_ctx);
+                        if (!ok) {
+                                return WERR_INVALID_DOMAIN_ROLE;
+                        }
+                }
+                break;
+        default:
+                return WERR_NOT_SUPPORTED;
+        }
+        irpc_handle = irpc_binding_handle_by_name(state,
+                                                  state->dce_call->msg_ctx,
+                                                  "winbind_server",
+                                                  &ndr_table_winbind);
+        if (irpc_handle == NULL) {
+                DEBUG(0,("Failed to get binding_handle for winbind_server task\n"));
+                state->dce_call->fault_code = DCERPC_FAULT_CANT_PERFORM;
+                return WERR_SERVICE_NOT_FOUND;
+        }
+        /*
+         * 60 seconds timeout should be enough
+         */
+        dcerpc_binding_handle_set_timeout(irpc_handle, 60);
+        subreq = dcerpc_winbind_LogonControl_send(state,
+                                                  state->dce_call->event_ctx,
+                                                  irpc_handle,
+                                                  state->r.in.function_code,
+                                                  state->r.in.level,
+                                                  state->r.in.data,
+                                                  state->r.out.query);
+        if (subreq == NULL) {
+                return WERR_NOMEM;
+        }
+        state->dce_call->state_flags |= DCESRV_CALL_STATE_FLAG_ASYNC;
+        tevent_req_set_callback(subreq,
+                                dcesrv_netr_LogonControl_base_done,
+                                state);
+        return WERR_OK;
+}
+static void dcesrv_netr_LogonControl_base_done(struct tevent_req *subreq)
+{
+        struct dcesrv_netr_LogonControl_base_state *state =
+                tevent_req_callback_data(subreq,
+                struct dcesrv_netr_LogonControl_base_state);
+        NTSTATUS status;
+        status = dcerpc_winbind_LogonControl_recv(subreq, state->mem_ctx,
+                                                  &state->r.out.result);
+        TALLOC_FREE(subreq);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
+                state->r.out.result = WERR_TIMEOUT;
+        } else if (!NT_STATUS_IS_OK(status)) {
+                state->dce_call->fault_code = DCERPC_FAULT_CANT_PERFORM;
+                DEBUG(0,(__location__ ": IRPC callback failed %s\n",
+                         nt_errstr(status)));
+        }
+        if (state->_r.l2ex != NULL) {
+                struct netr_LogonControl2Ex *r = state->_r.l2ex;
+                r->out.result = state->r.out.result;
+        } else if (state->_r.l2 != NULL) {
+                struct netr_LogonControl2 *r = state->_r.l2;
+                r->out.result = state->r.out.result;
+        } else if (state->_r.l != NULL) {
+                struct netr_LogonControl *r = state->_r.l;
+                r->out.result = state->r.out.result;
+        }
+        status = dcesrv_reply(state->dce_call);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,(__location__ ": dcesrv_reply() failed - %s\n", nt_errstr(status)));
+        }
+}
+/*
+  netr_LogonControl
+*/
+static WERROR dcesrv_netr_LogonControl(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct netr_LogonControl *r)
+{
+        struct dcesrv_netr_LogonControl_base_state *state;
+        WERROR werr;
+        state = talloc_zero(mem_ctx, struct dcesrv_netr_LogonControl_base_state);
+        if (state == NULL) {
+                return WERR_NOMEM;
+        }
+        state->dce_call = dce_call;
+        state->mem_ctx = mem_ctx;
+        state->r.in.logon_server = r->in.logon_server;
+        state->r.in.function_code = r->in.function_code;
+        state->r.in.level = r->in.level;
+        state->r.in.data = NULL;
+        state->r.out.query = r->out.query;
+        state->_r.l = r;
+        werr = dcesrv_netr_LogonControl_base_call(state);
+        if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
+                return werr;
+        }
+        return werr;
+}
+/*
+  netr_LogonControl2
+*/
+static WERROR dcesrv_netr_LogonControl2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct netr_LogonControl2 *r)
+{
+        struct dcesrv_netr_LogonControl_base_state *state;
+        WERROR werr;
+        state = talloc_zero(mem_ctx, struct dcesrv_netr_LogonControl_base_state);
+        if (state == NULL) {
+                return WERR_NOMEM;
+        }
+        state->dce_call = dce_call;
+        state->mem_ctx = mem_ctx;
+        state->r.in.logon_server = r->in.logon_server;
+        state->r.in.function_code = r->in.function_code;
+        state->r.in.level = r->in.level;
+        state->r.in.data = r->in.data;
+        state->r.out.query = r->out.query;
+        state->_r.l2 = r;
+        werr = dcesrv_netr_LogonControl_base_call(state);
+        if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
+                return werr;
+        }
+        return werr;
+}
 /*
 …
                        struct netr_LogonControl2Ex *r)
+{
+        return WERR_NOT_SUPPORTED;
+}
+/*
+  netr_LogonControl
+*/
+static WERROR dcesrv_netr_LogonControl(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct netr_LogonControl *r)
+{
+        struct netr_LogonControl2Ex r2;
+        struct dcesrv_netr_LogonControl_base_state *state;
         WERROR werr;
+        if (r->in.level == 0x00000001) {
+                ZERO_STRUCT(r2);
+                r2.in.logon_server = r->in.logon_server;
+                r2.in.function_code = r->in.function_code;
+                r2.in.level = r->in.level;
+                r2.in.data = NULL;
+                r2.out.query = r->out.query;
+                werr = dcesrv_netr_LogonControl2Ex(dce_call, mem_ctx, &r2);
+        } else if (r->in.level == 0x00000002) {
+                werr = WERR_NOT_SUPPORTED;
+        } else {
+                werr = WERR_UNKNOWN_LEVEL;
+        }
+        return werr;
+}
+/*
+  netr_LogonControl2
+*/
+static WERROR dcesrv_netr_LogonControl2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct netr_LogonControl2 *r)
+{
+        struct netr_LogonControl2Ex r2;
+        WERROR werr;
+        ZERO_STRUCT(r2);
+        r2.in.logon_server = r->in.logon_server;
+        r2.in.function_code = r->in.function_code;
+        r2.in.level = r->in.level;
+        r2.in.data = r->in.data;
+        r2.out.query = r->out.query;
+        werr = dcesrv_netr_LogonControl2Ex(dce_call, mem_ctx, &r2);
+        state = talloc_zero(mem_ctx, struct dcesrv_netr_LogonControl_base_state);
+        if (state == NULL) {
+                return WERR_NOMEM;
+        }
+        state->dce_call = dce_call;
+        state->mem_ctx = mem_ctx;
+        state->r = *r;
+        state->_r.l2ex = r;
+        werr = dcesrv_netr_LogonControl_base_call(state);
+        if (dce_call->state_flags & DCESRV_CALL_STATE_FLAG_ASYNC) {
+                return werr;
+        }
         return werr;
 …
                        struct netr_LogonGetCapabilities *r)
+{
+        /* we don't support AES yet */
+        return NT_STATUS_NOT_IMPLEMENTED;
+        struct netlogon_creds_CredentialState *creds;
+        NTSTATUS status;
+        status = dcesrv_netr_creds_server_step_check(dce_call,
+                                                     mem_ctx,
+                                                     r->in.computer_name,
+                                                     r->in.credential,
+                                                     r->out.return_authenticator,
+                                                     &creds);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,(__location__ " Bad credentials - error\n"));
+        }
+        NT_STATUS_NOT_OK_RETURN(status);
+        if (r->in.query_level != 1) {
+                return NT_STATUS_NOT_SUPPORTED;
+        }
+        r->out.capabilities->server_capabilities = creds->negotiate_flags;
+        return NT_STATUS_OK;
+}
 …
+        }
+        /*
+         * We assume to be a DC when we get called over NETLOGON. Hence we
+         * get our site name always by using "samdb_server_site_name()"
+         * and not "samdb_client_site_name()".
+         */
         *r->out.site = samdb_server_site_name(sam_ctx, mem_ctx);
         W_ERROR_HAVE_NO_MEMORY(*r->out.site);
 …
                 domain_info->workstation_flags =
+                        r->in.query->workstation_info->workstation_flags;
+                        r->in.query->workstation_info->workstation_flags & (
+                        NETR_WS_FLAG_HANDLES_SPN_UPDATE | NETR_WS_FLAG_HANDLES_INBOUND_TRUSTS);
                 r->out.info->domain_info = domain_info;
 …
   netr_ServerPasswordGet
 */
 static WERROR dcesrv_netr_ServerPasswordGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+static NTSTATUS dcesrv_netr_ServerPasswordGet(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                        struct netr_ServerPasswordGet *r)
+{
 …
         struct netr_DsRGetDCNameInfo *info;
         struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        const struct tsocket_address *local_address;
+        char *local_addr = NULL;
         const struct tsocket_address *remote_address;
         char *addr = NULL;
+        char *remote_addr = NULL;
         const char *server_site_name;
         char *guid_str;
 …
         const char *dc_name = NULL;
         const char *domain_name = NULL;
+        const char *pdc_ip;
         ZERO_STRUCTP(r->out.info);
 …
+        }
+        local_address = dcesrv_connection_get_local_address(dce_call->conn);
+        if (tsocket_address_is_inet(local_address, "ip")) {
+                local_addr = tsocket_address_inet_addr_string(local_address, mem_ctx);
+                W_ERROR_HAVE_NO_MEMORY(local_addr);
+        }
         remote_address = dcesrv_connection_get_remote_address(dce_call->conn);
         if (tsocket_address_is_inet(remote_address, "ip")) {
                 addr = tsocket_address_inet_addr_string(remote_address, mem_ctx);
                 W_ERROR_HAVE_NO_MEMORY(addr);
+                remote_addr = tsocket_address_inet_addr_string(remote_address, mem_ctx);
+                W_ERROR_HAVE_NO_MEMORY(remote_addr);
+        }
 …
                                                  NULL, guid_str,
                                                  r->in.client_account,
                                                  r->in.mask, addr,
+                                                 r->in.mask, remote_addr,
                                                  NETLOGON_NT_VERSION_5EX_WITH_IP,
                                                  lp_ctx, &response, true);
 …
+        }
+        /*
+         * According to MS-NRPC 2.2.1.2.1 we should set the "DS_DNS_FOREST_ROOT"
+         * (O) flag when the returned forest name is in DNS format. This is here
+         * always the case (see below).
+         */
+        response.data.nt5_ex.server_type |= DS_DNS_FOREST_ROOT;
         if (r->in.flags & DS_RETURN_DNS_NAME) {
                 dc_name = response.data.nt5_ex.pdc_dns_name;
                 domain_name = response.data.nt5_ex.dns_domain;
+                /*
+                 * According to MS-NRPC 2.2.1.2.1 we should set the
+                 * "DS_DNS_CONTROLLER" (M) and "DS_DNS_DOMAIN" (N) flags when
+                 * the returned information is in DNS form.
+                 */
+                response.data.nt5_ex.server_type |=
+                        DS_DNS_CONTROLLER | DS_DNS_DOMAIN;
         } else if (r->in.flags & DS_RETURN_FLAT_NAME) {
                 dc_name = response.data.nt5_ex.pdc_name;
 …
         info = talloc(mem_ctx, struct netr_DsRGetDCNameInfo);
         W_ERROR_HAVE_NO_MEMORY(info);
+        info->dc_unc           = talloc_asprintf(mem_ctx, "\\\\%s", dc_name);
+        info->dc_unc = talloc_asprintf(mem_ctx, "%s%s",
+                        dc_name[0] != '\\'? "\\\\":"",
+                        talloc_strdup(mem_ctx, dc_name));
         W_ERROR_HAVE_NO_MEMORY(info->dc_unc);
+        info->dc_address = talloc_asprintf(mem_ctx, "\\\\%s",
+                                           response.data.nt5_ex.sockaddr.pdc_ip);
+        pdc_ip = local_addr;
+        if (pdc_ip == NULL) {
+                pdc_ip = "127.0.0.1";
+        }
+        info->dc_address = talloc_asprintf(mem_ctx, "\\\\%s", pdc_ip);
         W_ERROR_HAVE_NO_MEMORY(info->dc_address);
         info->dc_address_type  = DS_ADDRESS_TYPE_INET; /* TODO: make this dynamic? for ipv6 */
+        info->dc_address_type  = DS_ADDRESS_TYPE_INET;
         info->domain_guid      = response.data.nt5_ex.domain_uuid;
         info->domain_name      = domain_name;
         info->forest_name      = response.data.nt5_ex.forest;
         info->dc_flags         = response.data.nt5_ex.server_type;
+        if (r->in.flags & DS_RETURN_DNS_NAME) {
+                /* As MS-NRPC.pdf in 2.2.1.2.1 the DS_DNS_CONTROLLER flag should be
+                 * returned if we are returning info->dc_unc containing a FQDN.
+                 * This attribute is called DomainControllerName in the specs,
+                 * it seems that we decide to return FQDN or netbios depending on
+                 * DS_RETURN_DNS_NAME.
+                 */
+                info->dc_flags |= DS_DNS_CONTROLLER;
+        }
         info->dc_site_name     = response.data.nt5_ex.server_site;
         info->client_site_name = response.data.nt5_ex.client_site;
 …
-#define GET_CHECK_STR(dest, mem, msg, attr) \
-do {\
-        const char *s; \
-        s = ldb_msg_find_attr_as_string(msg, attr, NULL); \
-        if (!s) { \
-                DEBUG(0, ("DB Error, TustedDomain entry (%s) " \
-                          "without flatname\n", \
-                          ldb_dn_get_linearized(msg->dn))); \
-                continue; \
-        } \
-        dest = talloc_strdup(mem, s); \
-        W_ERROR_HAVE_NO_MEMORY(dest); \
-} while(0)
 static WERROR fill_trusted_domains_array(TALLOC_CTX *mem_ctx,
                                          struct ldb_context *sam_ctx,
 …
                 W_ERROR_HAVE_NO_MEMORY(trusts->array);
+                GET_CHECK_STR(trusts->array[n].netbios_name, trusts,
+                              dom_res[i], "flatname");
+                GET_CHECK_STR(trusts->array[n].dns_name, trusts,
+                              dom_res[i], "trustPartner");
+                trusts->array[n].netbios_name = talloc_steal(trusts->array, ldb_msg_find_attr_as_string(dom_res[i], "flatname", NULL));
+                if (!trusts->array[n].netbios_name) {
+                        DEBUG(0, ("DB Error, TrustedDomain entry (%s) "
+                                  "without flatname\n",
+                                  ldb_dn_get_linearized(dom_res[i]->dn)));
+                }
+                trusts->array[n].dns_name = talloc_steal(trusts->array, ldb_msg_find_attr_as_string(dom_res[i], "trustPartner", NULL));
                 trusts->array[n].trust_flags = flags;
 …
                                                   "trustAttributes", 0);
                 if ((trusts->array[n].trust_type == NETR_TRUST_TYPE_MIT) ||
                     (trusts->array[n].trust_type == NETR_TRUST_TYPE_DCE)) {
+                if ((trusts->array[n].trust_type == LSA_TRUST_TYPE_MIT) ||
+                    (trusts->array[n].trust_type == LSA_TRUST_TYPE_DCE)) {
                         struct dom_sid zero_sid;
                         ZERO_STRUCT(zero_sid);
 …
                 /* we are always the root domain for now */
                 trusts->array[n].parent_index = 0;
                 trusts->array[n].trust_type = NETR_TRUST_TYPE_UPLEVEL;
+                trusts->array[n].trust_type = LSA_TRUST_TYPE_UPLEVEL;
                 trusts->array[n].trust_attributes = 0;
                 trusts->array[n].sid = samdb_result_dom_sid(mem_ctx,
 …
+static NTSTATUS dcesrv_netr_ServerGetTrustInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct netr_ServerGetTrustInfo *r);
 /*
   netr_ServerTrustPasswordsGet
 …
                        struct netr_ServerTrustPasswordsGet *r)
+{
+        DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
+static WERROR fill_forest_trust_array(TALLOC_CTX *mem_ctx,
+                                      struct ldb_context *sam_ctx,
+                                      struct loadparm_context *lp_ctx,
+                                      struct lsa_ForestTrustInformation *info)
+{
+        struct lsa_ForestTrustDomainInfo *domain_info;
+        struct lsa_ForestTrustRecord *e;
+        struct ldb_message **dom_res;
+        const char * const dom_attrs[] = { "objectSid", NULL };
+        int ret;
+        /* we need to provide 2 entries:
+         * 1. the Root Forest name
+         * 2. the Domain Information
+         */
+        info->count = 2;
+        info->entries = talloc_array(info, struct lsa_ForestTrustRecord *, 2);
+        W_ERROR_HAVE_NO_MEMORY(info->entries);
+        /* Forest root info */
+        e = talloc(info, struct lsa_ForestTrustRecord);
+        W_ERROR_HAVE_NO_MEMORY(e);
+        e->flags = 0;
+        e->type = LSA_FOREST_TRUST_TOP_LEVEL_NAME;
+        e->time = 0; /* so far always 0 in trces. */
+        e->forest_trust_data.top_level_name.string = samdb_forest_name(sam_ctx,
+                                                                       mem_ctx);
+        W_ERROR_HAVE_NO_MEMORY(e->forest_trust_data.top_level_name.string);
+        info->entries[0] = e;
+        /* Domain info */
+        e = talloc(info, struct lsa_ForestTrustRecord);
+        W_ERROR_HAVE_NO_MEMORY(e);
+        /* get our own domain info */
+        ret = gendb_search_dn(sam_ctx, mem_ctx, NULL, &dom_res, dom_attrs);
+        if (ret != 1) {
+                return WERR_GENERAL_FAILURE;
+        }
+        /* TODO: check if disabled and set flags accordingly */
+        e->flags = 0;
+        e->type = LSA_FOREST_TRUST_DOMAIN_INFO;
+        e->time = 0; /* so far always 0 in traces. */
+        domain_info = &e->forest_trust_data.domain_info;
+        domain_info->domain_sid = samdb_result_dom_sid(info, dom_res[0],
+                                                       "objectSid");
+        domain_info->dns_domain_name.string = lpcfg_dnsdomain(lp_ctx);
+        domain_info->netbios_domain_name.string = lpcfg_workgroup(lp_ctx);
+        info->entries[1] = e;
+        talloc_free(dom_res);
+        return WERR_OK;
+        struct netr_ServerGetTrustInfo r2 = {};
+        struct netr_TrustInfo *_ti = NULL;
+        NTSTATUS status;
+        r2.in.server_name = r->in.server_name;
+        r2.in.account_name = r->in.account_name;
+        r2.in.secure_channel_type = r->in.secure_channel_type;
+        r2.in.computer_name = r->in.computer_name;
+        r2.in.credential = r->in.credential;
+        r2.out.return_authenticator = r->out.return_authenticator;
+        r2.out.new_owf_password = r->out.new_owf_password;
+        r2.out.old_owf_password = r->out.old_owf_password;
+        r2.out.trust_info = &_ti;
+        status = dcesrv_netr_ServerGetTrustInfo(dce_call, mem_ctx, &r2);
+        r->out.return_authenticator = r2.out.return_authenticator;
+        r->out.new_owf_password = r2.out.new_owf_password;
+        r->out.old_owf_password = r2.out.old_owf_password;
+        return status;
+}
 …
   netr_DsRGetForestTrustInformation
 */
+struct dcesrv_netr_DsRGetForestTrustInformation_state {
+        struct dcesrv_call_state *dce_call;
+        TALLOC_CTX *mem_ctx;
+        struct netr_DsRGetForestTrustInformation *r;
+};
+static void dcesrv_netr_DsRGetForestTrustInformation_done(struct tevent_req *subreq);
 static WERROR dcesrv_netr_DsRGetForestTrustInformation(struct dcesrv_call_state *dce_call,
                                                        TALLOC_CTX *mem_ctx,
 …
+{
         struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        struct lsa_ForestTrustInformation *info, **info_ptr;
+        struct ldb_context *sam_ctx;
+        WERROR werr;
+        struct dcesrv_connection *conn = dce_call->conn;
+        struct auth_session_info *session_info = conn->auth_state.session_info;
+        enum security_user_level security_level;
+        struct ldb_context *sam_ctx = NULL;
+        struct dcesrv_netr_DsRGetForestTrustInformation_state *state = NULL;
+        struct dcerpc_binding_handle *irpc_handle = NULL;
+        struct tevent_req *subreq = NULL;
+        struct ldb_dn *domain_dn = NULL;
+        struct ldb_dn *forest_dn = NULL;
+        int cmp;
+        int forest_level;
+        security_level = security_session_user_level(session_info, NULL);
+        if (security_level < SECURITY_USER) {
+                return WERR_ACCESS_DENIED;
+        }
         if (r->in.flags & 0xFFFFFFFE) {
 …
+        }
+        domain_dn = ldb_get_default_basedn(sam_ctx);
+        if (domain_dn == NULL) {
+                return WERR_GENERAL_FAILURE;
+        }
+        forest_dn = ldb_get_root_basedn(sam_ctx);
+        if (forest_dn == NULL) {
+                return WERR_GENERAL_FAILURE;
+        }
+        cmp = ldb_dn_compare(domain_dn, forest_dn);
+        if (cmp != 0) {
+                return WERR_NERR_ACFNOTLOADED;
+        }
+        forest_level = dsdb_forest_functional_level(sam_ctx);
+        if (forest_level < DS_DOMAIN_FUNCTION_2003) {
+                return WERR_INVALID_FUNCTION;
+        }
         if (r->in.flags & DS_GFTI_UPDATE_TDO) {
                 if (!samdb_is_pdc(sam_ctx)) {
 …
                         return WERR_INVALID_FLAGS;
+                }
+                /* TODO: establish an schannel connection with
+                 * r->in.trusted_domain_name and perform a
+                 * netr_GetForestTrustInformation call against it */
+                /* for now return not implementd */
+                return WERR_CALL_NOT_IMPLEMENTED;
+        }
+        /* TODO: check r->in.server_name is our name */
+        info_ptr = talloc(mem_ctx, struct lsa_ForestTrustInformation *);
+        W_ERROR_HAVE_NO_MEMORY(info_ptr);
+        info = talloc_zero(info_ptr, struct lsa_ForestTrustInformation);
+        W_ERROR_HAVE_NO_MEMORY(info);
+        werr = fill_forest_trust_array(mem_ctx, sam_ctx, lp_ctx, info);
+        W_ERROR_NOT_OK_RETURN(werr);
+        *info_ptr = info;
+        r->out.forest_trust_info = info_ptr;
+        }
+        if (r->in.trusted_domain_name == NULL) {
+                NTSTATUS status;
+                /*
+                 * information about our own domain
+                 */
+                status = dsdb_trust_xref_forest_info(mem_ctx, sam_ctx,
+                                                r->out.forest_trust_info);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return ntstatus_to_werror(status);
+                }
+                return WERR_OK;
+        }
+        /*
+         * Forward the request to winbindd
+         */
+        state = talloc_zero(mem_ctx,
+                        struct dcesrv_netr_DsRGetForestTrustInformation_state);
+        if (state == NULL) {
+                return WERR_NOMEM;
+        }
+        state->dce_call = dce_call;
+        state->mem_ctx = mem_ctx;
+        state->r = r;
+        irpc_handle = irpc_binding_handle_by_name(state,
+                                                  state->dce_call->msg_ctx,
+                                                  "winbind_server",
+                                                  &ndr_table_winbind);
+        if (irpc_handle == NULL) {
+                DEBUG(0,("Failed to get binding_handle for winbind_server task\n"));
+                state->dce_call->fault_code = DCERPC_FAULT_CANT_PERFORM;
+                return WERR_SERVICE_NOT_FOUND;
+        }
+        /*
+         * 60 seconds timeout should be enough
+         */
+        dcerpc_binding_handle_set_timeout(irpc_handle, 60);
+        subreq = dcerpc_winbind_GetForestTrustInformation_send(state,
+                                                state->dce_call->event_ctx,
+                                                irpc_handle,
+                                                r->in.trusted_domain_name,
+                                                r->in.flags,
+                                                r->out.forest_trust_info);
+        if (subreq == NULL) {
+                return WERR_NOMEM;
+        }
+        state->dce_call->state_flags |= DCESRV_CALL_STATE_FLAG_ASYNC;
+        tevent_req_set_callback(subreq,
+                                dcesrv_netr_DsRGetForestTrustInformation_done,
+                                state);
         return WERR_OK;
+}
+static void dcesrv_netr_DsRGetForestTrustInformation_done(struct tevent_req *subreq)
+{
+        struct dcesrv_netr_DsRGetForestTrustInformation_state *state =
+                tevent_req_callback_data(subreq,
+                struct dcesrv_netr_DsRGetForestTrustInformation_state);
+        NTSTATUS status;
+        status = dcerpc_winbind_GetForestTrustInformation_recv(subreq,
+                                                        state->mem_ctx,
+                                                        &state->r->out.result);
+        TALLOC_FREE(subreq);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_IO_TIMEOUT)) {
+                state->r->out.result = WERR_TIMEOUT;
+        } else if (!NT_STATUS_IS_OK(status)) {
+                state->dce_call->fault_code = DCERPC_FAULT_CANT_PERFORM;
+                DEBUG(0,(__location__ ": IRPC callback failed %s\n",
+                         nt_errstr(status)));
+        }
+        status = dcesrv_reply(state->dce_call);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0,(__location__ ": dcesrv_reply() failed - %s\n", nt_errstr(status)));
+        }
+}
 /*
 …
+{
         struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        struct netlogon_creds_CredentialState *creds;
+        struct lsa_ForestTrustInformation *info, **info_ptr;
+        struct ldb_context *sam_ctx;
+        struct netlogon_creds_CredentialState *creds = NULL;
+        struct ldb_context *sam_ctx = NULL;
+        struct ldb_dn *domain_dn = NULL;
+        struct ldb_dn *forest_dn = NULL;
+        int cmp;
+        int forest_level;
         NTSTATUS status;
-        WERROR werr;
         status = dcesrv_netr_creds_server_step_check(dce_call,
 …
                                 dce_call->conn->auth_state.session_info, 0);
         if (sam_ctx == NULL) {
                 return NT_STATUS_UNSUCCESSFUL;
+                return NT_STATUS_INTERNAL_ERROR;
+        }
         /* TODO: check r->in.server_name is our name */
+        info_ptr = talloc(mem_ctx, struct lsa_ForestTrustInformation *);
+        if (!info_ptr) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        info = talloc_zero(info_ptr, struct lsa_ForestTrustInformation);
+        if (!info) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        werr = fill_forest_trust_array(mem_ctx, sam_ctx, lp_ctx, info);
+        if (!W_ERROR_IS_OK(werr)) {
+                return werror_to_ntstatus(werr);
+        }
+        *info_ptr = info;
+        r->out.forest_trust_info = info_ptr;
+        domain_dn = ldb_get_default_basedn(sam_ctx);
+        if (domain_dn == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        forest_dn = ldb_get_root_basedn(sam_ctx);
+        if (forest_dn == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+        cmp = ldb_dn_compare(domain_dn, forest_dn);
+        if (cmp != 0) {
+                return NT_STATUS_INVALID_DOMAIN_STATE;
+        }
+        forest_level = dsdb_forest_functional_level(sam_ctx);
+        if (forest_level < DS_DOMAIN_FUNCTION_2003) {
+                return NT_STATUS_INVALID_DOMAIN_STATE;
+        }
+        status = dsdb_trust_xref_forest_info(mem_ctx, sam_ctx,
+                                             r->out.forest_trust_info);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         return NT_STATUS_OK;
 …
                        struct netr_ServerGetTrustInfo *r)
+{
+        DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+        struct loadparm_context *lp_ctx = dce_call->conn->dce_ctx->lp_ctx;
+        struct netlogon_creds_CredentialState *creds = NULL;
+        struct ldb_context *sam_ctx = NULL;
+        const char * const attrs[] = {
+                "unicodePwd",
+                "sAMAccountName",
+                "userAccountControl",
+                NULL
+        };
+        struct ldb_message **res = NULL;
+        struct samr_Password *curNtHash = NULL, *prevNtHash = NULL;
+        NTSTATUS nt_status;
+        int ret;
+        const char *asid = NULL;
+        uint32_t uac = 0;
+        const char *aname = NULL;
+        struct ldb_message *tdo_msg = NULL;
+        const char * const tdo_attrs[] = {
+                "trustAuthIncoming",
+                "trustAttributes",
+                NULL
+        };
+        struct netr_TrustInfo *trust_info = NULL;
+        ZERO_STRUCTP(r->out.new_owf_password);
+        ZERO_STRUCTP(r->out.old_owf_password);
+        nt_status = dcesrv_netr_creds_server_step_check(dce_call,
+                                                        mem_ctx,
+                                                        r->in.computer_name,
+                                                        r->in.credential,
+                                                        r->out.return_authenticator,
+                                                        &creds);
+        if (!NT_STATUS_IS_OK(nt_status)) {
+                return nt_status;
+        }
+        /* TODO: check r->in.server_name is our name */
+        if (strcasecmp_m(r->in.account_name, creds->account_name) != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        if (r->in.secure_channel_type != creds->secure_channel_type) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        if (strcasecmp_m(r->in.computer_name, creds->computer_name) != 0) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+        sam_ctx = samdb_connect(mem_ctx, dce_call->event_ctx,
+                                lp_ctx, system_session(lp_ctx), 0);
+        if (sam_ctx == NULL) {
+                return NT_STATUS_INVALID_SYSTEM_SERVICE;
+        }
+        asid = ldap_encode_ndr_dom_sid(mem_ctx, creds->sid);
+        if (asid == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        ret = gendb_search(sam_ctx, mem_ctx, NULL, &res, attrs,
+                           "(&(objectClass=user)(objectSid=%s))",
+                           asid);
+        if (ret != 1) {
+                return NT_STATUS_ACCOUNT_DISABLED;
+        }
+        switch (creds->secure_channel_type) {
+        case SEC_CHAN_DNS_DOMAIN:
+        case SEC_CHAN_DOMAIN:
+                uac = ldb_msg_find_attr_as_uint(res[0], "userAccountControl", 0);
+                if (uac & UF_ACCOUNTDISABLE) {
+                        return NT_STATUS_ACCOUNT_DISABLED;
+                }
+                if (!(uac & UF_INTERDOMAIN_TRUST_ACCOUNT)) {
+                        return NT_STATUS_ACCOUNT_DISABLED;
+                }
+                aname = ldb_msg_find_attr_as_string(res[0], "sAMAccountName", NULL);
+                if (aname == NULL) {
+                        return NT_STATUS_ACCOUNT_DISABLED;
+                }
+                nt_status = dsdb_trust_search_tdo_by_type(sam_ctx,
+                                                SEC_CHAN_DOMAIN, aname,
+                                                tdo_attrs, mem_ctx, &tdo_msg);
+                if (NT_STATUS_EQUAL(nt_status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+                        return NT_STATUS_ACCOUNT_DISABLED;
+                }
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
+                nt_status = dsdb_trust_get_incoming_passwords(tdo_msg, mem_ctx,
+                                                              &curNtHash,
+                                                              &prevNtHash);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
+                trust_info = talloc_zero(mem_ctx, struct netr_TrustInfo);
+                if (trust_info == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                trust_info->count = 1;
+                trust_info->data = talloc_array(trust_info, uint32_t,
+                                                trust_info->count);
+                if (trust_info->data == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                trust_info->data[0] = ldb_msg_find_attr_as_uint(tdo_msg,
+                                                        "trustAttributes",
+);
+                break;
+        default:
+                nt_status = samdb_result_passwords_no_lockout(mem_ctx, lp_ctx,
+                                                              res[0],
+                                                              NULL, &curNtHash);
+                if (!NT_STATUS_IS_OK(nt_status)) {
+                        return nt_status;
+                }
+                prevNtHash = talloc(mem_ctx, struct samr_Password);
+                if (prevNtHash == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                E_md4hash("", prevNtHash->hash);
+                break;
+        }
+        if (curNtHash != NULL) {
+                *r->out.new_owf_password = *curNtHash;
+                netlogon_creds_des_encrypt(creds, r->out.new_owf_password);
+        }
+        if (prevNtHash != NULL) {
+                *r->out.old_owf_password = *prevNtHash;
+                netlogon_creds_des_encrypt(creds, r->out.old_owf_password);
+        }
+        if (trust_info != NULL) {
+                *r->out.trust_info = trust_info;
+        }
+        return NT_STATUS_OK;
+}

vendor/current/source4/rpc_server/remote/dcesrv_remote.c

-              r740
+              r988
 #include "param/param.h"
+NTSTATUS dcerpc_server_remote_init(void);
 struct dcesrv_remote_private {
 …
         domain = lpcfg_parm_string(dce_call->conn->dce_ctx->lp_ctx, NULL, "dceprc_remote", "domain");
         table = ndr_table_by_uuid(&iface->syntax_id.uuid); /* FIXME: What about if_version ? */
+        table = ndr_table_by_syntax(&iface->syntax_id);
         if (!table) {
                 dce_call->fault_code = DCERPC_FAULT_UNK_IF;
 …
                 return status;
+        }
+        /* If we already have a remote association group ID, then use that */
+        if (dce_call->conn->assoc_group->proxied_id != 0) {
+                status = dcerpc_binding_set_assoc_group_id(b,
+                        dce_call->conn->assoc_group->proxied_id);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("dcerpc_binding_set_assoc_group_id() - %s'\n",
+                                  nt_errstr(status)));
+                        return status;
+                }
+        }
+        status = dcerpc_binding_set_abstract_syntax(b, &iface->syntax_id);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("dcerpc_binding_set_abstract_syntax() - %s'\n",
+                          nt_errstr(status)));
+                return status;
+        }
         DEBUG(3, ("Using binding %s\n", dcerpc_binding_string(dce_call->context, b)));
-        /* If we already have a remote association group ID, then use that */
-        if (dce_call->context->assoc_group->proxied_id != 0) {
-                b->assoc_group_id = dce_call->context->assoc_group->proxied_id;
+        }
-        b->object.if_version = if_version;
         pipe_conn_req = dcerpc_pipe_connect_b_send(dce_call->context, b, table,
 …
+        }
+        if (dce_call->context->assoc_group->proxied_id == 0) {
+                dce_call->context->assoc_group->proxied_id = priv->c_pipe->assoc_group_id;
+        if (dce_call->conn->assoc_group->proxied_id == 0) {
+                dce_call->conn->assoc_group->proxied_id =
+                        dcerpc_binding_get_assoc_group_id(priv->c_pipe->binding);
+        }
 …
         if (opnum >= table->num_calls) {
+                dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+                return NT_STATUS_NET_WRITE_FAULT;
+        }
+        /*
+         * We don't have support for calls with pipes.
+         */
+        if (table->calls[opnum].in_pipes.num_pipes != 0) {
+                dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
+                return NT_STATUS_NET_WRITE_FAULT;
+        }
+        if (table->calls[opnum].out_pipes.num_pipes != 0) {
                 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
                 return NT_STATUS_NET_WRITE_FAULT;
 …
+{
         unsigned int i;
         const char **ifaces = (const char **)str_list_make(dce_ctx, lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_remote", "interfaces"),NULL);
+        char **ifaces = str_list_make(dce_ctx, lpcfg_parm_string(dce_ctx->lp_ctx, NULL, "dcerpc_remote", "interfaces"),NULL);
         if (!ifaces) {

vendor/current/source4/rpc_server/samr/dcesrv_samr.c

-              r740
+              r988
 #include "libds/common/flag_mapping.h"
+#define DCESRV_INTERFACE_SAMR_BIND(call, iface) \
+       dcesrv_interface_samr_bind(call, iface)
+static NTSTATUS dcesrv_interface_samr_bind(struct dcesrv_call_state *dce_call,
+                                             const struct dcesrv_interface *iface)
+{
+        return dcesrv_interface_bind_reject_connect(dce_call, iface);
+}
 /* these query macros make samr_Query[User|Group|Alias]Info a bit easier to read */
 …
         info->field = samdb_result_force_password_change(sam_ctx, mem_ctx, \
                                                          a_state->domain_state->domain_dn, msg);
+#define QUERY_BPWDCT(msg, field, attr) \
+        info->field = samdb_result_effective_badPwdCount(sam_ctx, mem_ctx, \
+                                                         a_state->domain_state->domain_dn, msg);
 #define QUERY_LHOURS(msg, field, attr) \
         info->field = samdb_result_logon_hours(mem_ctx, msg, attr);
 #define QUERY_AFLAGS(msg, field, attr) \
+        info->field = samdb_result_acct_flags(sam_ctx, mem_ctx, msg, a_state->domain_state->domain_dn);
+#define QUERY_PARAMETERS(msg, field, attr) \
+        info->field = samdb_result_parameters(mem_ctx, msg, attr);
+        info->field = samdb_result_acct_flags(msg, attr);
 …
 } while (0)
-#define CHECK_FOR_MULTIPLES(value, flag, poss_flags)    \
-        do { \
-                if ((value & flag) && ((value & flag) != (value & (poss_flags)))) { \
-                        return NT_STATUS_INVALID_PARAMETER;             \
-                }                                                       \
-        } while (0)                                                     \
 /* Set account flags, discarding flags that cannot be set with SAMR */
 #define SET_AFLAGS(msg, field, attr) do {                               \
         struct ldb_message_element *set_el;                             \
+        if ((r->in.info->field & (ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST)) == 0) { \
+                return NT_STATUS_INVALID_PARAMETER; \
+        }                                                               \
+        CHECK_FOR_MULTIPLES(r->in.info->field, ACB_NORMAL, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
+        CHECK_FOR_MULTIPLES(r->in.info->field, ACB_DOMTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
+        CHECK_FOR_MULTIPLES(r->in.info->field, ACB_WSTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
+        CHECK_FOR_MULTIPLES(r->in.info->field, ACB_SVRTRUST, ACB_NORMAL | ACB_DOMTRUST | ACB_WSTRUST | ACB_SVRTRUST); \
+        if (samdb_msg_add_acct_flags(sam_ctx, mem_ctx, msg, attr, (r->in.info->field & ~(ACB_AUTOLOCK|ACB_PW_EXPIRED))) != 0) { \
+        if (samdb_msg_add_acct_flags(sam_ctx, mem_ctx, msg, attr, r->in.info->field) != 0) { \
                 return NT_STATUS_NO_MEMORY;                             \
         }                                                               \
 …
                                  struct samr_EnumDomains *r)
+{
-        struct samr_connect_state *c_state;
         struct dcesrv_handle *h;
         struct samr_SamArray *array;
 …
         DCESRV_PULL_HANDLE(h, r->in.connect_handle, SAMR_HANDLE_CONNECT);
-        c_state = h->data;
         *r->out.resume_handle = 2;
 …
 );
         switch (state->role) {
         case ROLE_DOMAIN_CONTROLLER:
+        case ROLE_ACTIVE_DIRECTORY_DC:
                 /* This pulls the NetBIOS name from the
                    cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
 …
+                }
                 break;
+        case ROLE_DOMAIN_PDC:
+        case ROLE_DOMAIN_BDC:
+        case ROLE_AUTO:
+                return NT_STATUS_INTERNAL_ERROR;
         case ROLE_DOMAIN_MEMBER:
                 info->role = SAMR_ROLE_DOMAIN_MEMBER;
 …
         switch (state->role) {
         case ROLE_DOMAIN_CONTROLLER:
+        case ROLE_ACTIVE_DIRECTORY_DC:
                 /* This pulls the NetBIOS name from the
                    cn=NTDS Settings,cn=<NETBIOS name of PDC>,....
 …
+                }
                 break;
+        case ROLE_DOMAIN_PDC:
+        case ROLE_DOMAIN_BDC:
+        case ROLE_AUTO:
+                return NT_STATUS_INTERNAL_ERROR;
         case ROLE_DOMAIN_MEMBER:
                 info->role = SAMR_ROLE_DOMAIN_MEMBER;
 …
                          ldb_dn_get_linearized(d_state->domain_dn),
                          ldb_errstring(sam_ctx)));
+                /* we really need samdb.c to return NTSTATUS */
+                return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
+        }
+        status = dsdb_add_user(d_state->sam_ctx, mem_ctx, account_name, r->in.acct_flags, &sid, &dn);
+        status = dsdb_add_user(d_state->sam_ctx, mem_ctx, account_name, r->in.acct_flags, NULL,
+                               &sid, &dn);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
 …
         a_state = talloc(mem_ctx, struct samr_account_state);
         if (!a_state) {
-                ldb_transaction_cancel(d_state->sam_ctx);
                 return NT_STATUS_NO_MEMORY;
+        }
 …
         /* a simple wrapper around samr_CreateUser2 works nicely */
+        r2.in.domain_handle = r->in.domain_handle;
+        r2.in.account_name = r->in.account_name;
+        r2.in.acct_flags = ACB_NORMAL;
+        r2.in.access_mask = r->in.access_mask;
+        r2.out.user_handle = r->out.user_handle;
+        r2.out.access_granted = &access_granted;
+        r2.out.rid = r->out.rid;
+        r2 = (struct samr_CreateUser2) {
+                .in.domain_handle = r->in.domain_handle,
+                .in.account_name = r->in.account_name,
+                .in.acct_flags = ACB_NORMAL,
+                .in.access_mask = r->in.access_mask,
+                .out.user_handle = r->out.user_handle,
+                .out.access_granted = &access_granted,
+                .out.rid = r->out.rid
+        };
         return dcesrv_samr_CreateUser2(dce_call, mem_ctx, &r2);
 …
                 /* Check if a mask has been requested */
                 if (r->in.acct_flags
+                    && ((samdb_result_acct_flags(d_state->sam_ctx, mem_ctx,
+                                                 res[i], d_state->domain_dn) & r->in.acct_flags) == 0)) {
+                    && ((samdb_result_acct_flags(res[i], NULL) & r->in.acct_flags) == 0)) {
                         continue;
+                }
 …
         /* search for the group record */
+        ret = gendb_search(d_state->sam_ctx,
+                           mem_ctx, d_state->domain_dn, &msgs, attrs,
+                           "(&(objectSid=%s)(objectClass=group)"
+                           "(|(groupType=%d)(groupType=%d)))",
+                           ldap_encode_ndr_dom_sid(mem_ctx, sid),
+                           GTYPE_SECURITY_UNIVERSAL_GROUP,
+                           GTYPE_SECURITY_GLOBAL_GROUP);
+        if (d_state->builtin) {
+                ret = gendb_search(d_state->sam_ctx,
+                                   mem_ctx, d_state->domain_dn, &msgs, attrs,
+                                   "(&(objectSid=%s)(objectClass=group)"
+                                   "(groupType=%d))",
+                                   ldap_encode_ndr_dom_sid(mem_ctx, sid),
+                                   GTYPE_SECURITY_BUILTIN_LOCAL_GROUP);
+        } else {
+                ret = gendb_search(d_state->sam_ctx,
+                                   mem_ctx, d_state->domain_dn, &msgs, attrs,
+                                   "(&(objectSid=%s)(objectClass=group)"
+                                   "(|(groupType=%d)(groupType=%d)))",
+                                   ldap_encode_ndr_dom_sid(mem_ctx, sid),
+                                   GTYPE_SECURITY_UNIVERSAL_GROUP,
+                                   GTYPE_SECURITY_GLOBAL_GROUP);
+        }
         if (ret == 0) {
                 return NT_STATUS_NO_SUCH_GROUP;
 …
         struct samr_account_state *g_state;
         struct ldb_message *msg;
-        struct ldb_context *sam_ctx;
         int ret;
 …
         g_state = h->data;
-        sam_ctx = g_state->sam_ctx;
         msg = ldb_msg_new(mem_ctx);
 …
         ret = ldb_modify(g_state->sam_ctx, msg);
         if (ret != LDB_SUCCESS) {
+                /* we really need samdb.c to return NTSTATUS */
+                return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
                                                                 memberdn);
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
                 return NT_STATUS_ACCESS_DENIED;
         default:
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
+}
 …
         ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
                 return NT_STATUS_ACCESS_DENIED;
         default:
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
+}
 …
         struct samr_account_state *a_state;
         struct ldb_message *msg;
-        struct ldb_context *sam_ctx;
         int ret;
 …
         a_state = h->data;
-        sam_ctx = a_state->sam_ctx;
         msg = ldb_msg_new(mem_ctx);
 …
         ret = ldb_modify(a_state->sam_ctx, msg);
         if (ret != LDB_SUCCESS) {
+                /* we really need samdb.c to return NTSTATUS */
+                return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
         ret = ldb_delete(a_state->sam_ctx, a_state->account_dn);
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
                                  ldb_dn_alloc_linearized(mem_ctx, memberdn));
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
                 return NT_STATUS_ACCESS_DENIED;
         default:
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
+}
 …
                                                                  memberdn);
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
                 return NT_STATUS_ACCESS_DENIED;
         default:
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
+}
 …
                           ldb_dn_get_linearized(a_state->account_dn),
                           ldb_errstring(a_state->sam_ctx)));
                 return NT_STATUS_UNSUCCESSFUL;
+                return dsdb_ldb_err_to_ntstatus(ret);
+        }
 …
         const char * const *attrs = NULL;
         union samr_UserInfo *info;
+        NTSTATUS status;
         *r->out.info = NULL;
 …
                                                       "logonHours",
                                                       "badPwdCount",
+                                                      "badPasswordTime",
                                                       "logonCount",
                                                       "userAccountControl",
+                                                      "msDS-User-Account-Control-Computed",
                                                       NULL};
                 attrs = attrs2;
 …
                                                       "logonHours",
                                                       "badPwdCount",
+                                                      "badPasswordTime",
                                                       "logonCount",
                                                       "pwdLastSet",
                                                       "accountExpires",
                                                       "userAccountControl",
+                                                      "msDS-User-Account-Control-Computed",
                                                       NULL};
                 attrs = attrs2;
 …
+        {
                 static const char * const attrs2[] = {"userAccountControl",
+                                                      "msDS-User-Account-Control-Computed",
                                                       "pwdLastSet",
                                                       NULL};
 …
                                                       "primaryGroupID",
                                                       "userAccountControl",
+                                                      "msDS-User-Account-Control-Computed",
                                                       "logonHours",
                                                       "badPwdCount",
+                                                      "badPasswordTime",
                                                       "logonCount",
                                                       "countryCode",
 …
                 QUERY_FPASSC(msg, info3.force_password_change, "pwdLastSet");
                 QUERY_LHOURS(msg, info3.logon_hours,           "logonHours");
+                /* level 3 gives the raw badPwdCount value */
                 QUERY_UINT  (msg, info3.bad_password_count,    "badPwdCount");
                 QUERY_UINT  (msg, info3.logon_count,           "logonCount");
                 QUERY_AFLAGS(msg, info3.acct_flags,            "userAccountControl");
+                QUERY_AFLAGS(msg, info3.acct_flags,            "msDS-User-Account-Control-Computed");
                 break;
 …
                 QUERY_UINT64(msg, info5.last_logoff,           "lastLogoff");
                 QUERY_LHOURS(msg, info5.logon_hours,           "logonHours");
                 QUERY_UINT  (msg, info5.bad_password_count,    "badPwdCount");
+                QUERY_BPWDCT(msg, info5.bad_password_count,    "badPwdCount");
                 QUERY_UINT  (msg, info5.logon_count,           "logonCount");
                 QUERY_UINT64(msg, info5.last_password_change,  "pwdLastSet");
                 QUERY_UINT64(msg, info5.acct_expiry,           "accountExpires");
                 QUERY_AFLAGS(msg, info5.acct_flags,            "userAccountControl");
+                QUERY_AFLAGS(msg, info5.acct_flags,            "msDS-User-Account-Control-Computed");
                 break;
 …
         case 16:
                 QUERY_AFLAGS(msg, info16.acct_flags,    "userAccountControl");
+                QUERY_AFLAGS(msg, info16.acct_flags,    "msDS-User-Account-Control-Computed");
                 break;
 …
         case 20:
+                QUERY_PARAMETERS(msg, info20.parameters,    "userParameters");
+                status = samdb_result_parameters(mem_ctx, msg, "userParameters", &info->info20.parameters);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(info);
+                        return status;
+                }
                 break;
 …
                 QUERY_STRING(msg, info21.workstations,         "userWorkstations");
                 QUERY_STRING(msg, info21.comment,              "comment");
+                QUERY_PARAMETERS(msg, info21.parameters,       "userParameters");
+                status = samdb_result_parameters(mem_ctx, msg, "userParameters", &info->info21.parameters);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(info);
+                        return status;
+                }
                 QUERY_RID   (msg, info21.rid,                  "objectSid");
                 QUERY_UINT  (msg, info21.primary_gid,          "primaryGroupID");
                 QUERY_AFLAGS(msg, info21.acct_flags,           "userAccountControl");
+                QUERY_AFLAGS(msg, info21.acct_flags,           "msDS-User-Account-Control-Computed");
                 info->info21.fields_present = 0x08FFFFFF;
                 QUERY_LHOURS(msg, info21.logon_hours,          "logonHours");
                 QUERY_UINT  (msg, info21.bad_password_count,   "badPwdCount");
+                QUERY_BPWDCT(msg, info21.bad_password_count,   "badPwdCount");
                 QUERY_UINT  (msg, info21.logon_count,          "logonCount");
                 if ((info->info21.acct_flags & ACB_PW_EXPIRED) != 0) {
 …
                 if (r->in.info->info26.password_expired > 0) {
+                        NTTIME t = 0;
                         struct ldb_message_element *set_el;
+                        if (samdb_msg_add_uint64(sam_ctx, mem_ctx, msg, "pwdLastSet", 0) != LDB_SUCCESS) {
+                        if (r->in.info->info26.password_expired
+                                        == PASS_DONT_CHANGE_AT_NEXT_LOGON) {
+                                unix_to_nt_time(&t, time(NULL));
+                        }
+                        if (samdb_msg_add_uint64(sam_ctx, mem_ctx, msg,
+                                                 "pwdLastSet", t) != LDB_SUCCESS) {
                                 return NT_STATUS_NO_MEMORY;
+                        }
 …
                                  ldb_errstring(a_state->sam_ctx)));
+                        /* we really need samdb.c to return NTSTATUS */
+                        return NT_STATUS_UNSUCCESSFUL;
+                        return dsdb_ldb_err_to_ntstatus(ret);
+                }
+        }
 …
         struct samr_RidWithAttributeArray *array;
         int i, count;
+        char membersidstr[DOM_SID_STR_BUFLEN];
         DCESRV_PULL_HANDLE(h, r->in.user_handle, SAMR_HANDLE_USER);
 …
         a_state = h->data;
         d_state = a_state->domain_state;
+        dom_sid_string_buf(a_state->account_sid,
+                           membersidstr, sizeof(membersidstr)),
         count = samdb_search_domain(a_state->sam_ctx, mem_ctx,
                                     d_state->domain_dn, &res,
                                     attrs, d_state->domain_sid,
+                                    "(&(member=%s)(|(grouptype=%d)(grouptype=%d))(objectclass=group))",
+                                    ldb_dn_get_linearized(a_state->account_dn),
+                                    "(&(member=<SID=%s>)"
+                                     "(|(grouptype=%d)(grouptype=%d))"
+                                     "(objectclass=group))",
+                                    membersidstr,
                                     GTYPE_SECURITY_UNIVERSAL_GROUP,
                                     GTYPE_SECURITY_GLOBAL_GROUP);
 …
         /* search for all requested objects in all domains. This could
            possibly be cached and resumed based on resume_key */
         ret = dsdb_search(d_state->sam_ctx, mem_ctx, &res, NULL,
+        ret = dsdb_search(d_state->sam_ctx, mem_ctx, &res, ldb_get_default_basedn(d_state->sam_ctx),
                           LDB_SCOPE_SUBTREE, attrs, 0, "%s", filter);
         if (ret != LDB_SUCCESS) {
 …
                                 objectsid->sub_auths[objectsid->num_auths-1];
                         entriesGeneral[count].acct_flags =
+                                samdb_result_acct_flags(d_state->sam_ctx,
+                                                        mem_ctx,
+                                                        res->msgs[i],
+                                                        d_state->domain_dn);
+                                samdb_result_acct_flags(res->msgs[i], NULL);
                         entriesGeneral[count].account_name.string =
                                 ldb_msg_find_attr_as_string(res->msgs[i],
 …
                         /* No idea why we need to or in ACB_NORMAL here, but this is what Win2k3 seems to do... */
                         entriesFull[count].acct_flags =
+                                samdb_result_acct_flags(d_state->sam_ctx,
+                                                        mem_ctx,
+                                                        res->msgs[i],
+                                                        d_state->domain_dn) | ACB_NORMAL;
+                                samdb_result_acct_flags(res->msgs[i],
+                                                        NULL) | ACB_NORMAL;
                         entriesFull[count].account_name.string =
                                 ldb_msg_find_attr_as_string(res->msgs[i],
 …
         for (i=0; i<count; i++) {
                 struct ldb_message *mod;
+                int ret;
                 mod = ldb_msg_new(mem_ctx);
 …
                         return NT_STATUS_NO_MEMORY;
+                if (ldb_modify(d_state->sam_ctx, mod) != LDB_SUCCESS)
+                        return NT_STATUS_UNSUCCESSFUL;
+                ret = ldb_modify(d_state->sam_ctx, mod);
                 talloc_free(mod);
+                if (ret != LDB_SUCCESS) {
+                        return dsdb_ldb_err_to_ntstatus(ret);
+                }
+        }
 …
         NTSTATUS status;
+        r1.in.user_handle = r->in.user_handle;
+        r1.in.level  = r->in.level;
+        r1.out.info  = r->out.info;
+        r1 = (struct samr_QueryUserInfo) {
+                .in.user_handle = r->in.user_handle,
+                .in.level  = r->in.level,
+                .out.info  = r->out.info
+        };
         status = dcesrv_samr_QueryUserInfo(dce_call, mem_ctx, &r1);
 …
         enum samr_ValidationStatus res;
         NTSTATUS status;
+        enum dcerpc_transport_t transport =
+                dcerpc_binding_get_transport(dce_call->conn->endpoint->ep_description);
+        if (transport != NCACN_IP_TCP && transport != NCALRPC) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
+        if (dce_call->conn->auth_state.auth_level != DCERPC_AUTH_LEVEL_PRIVACY) {
+                DCESRV_FAULT(DCERPC_FAULT_ACCESS_DENIED);
+        }
         (*r->out.rep) = talloc_zero(mem_ctx, union samr_ValidatePasswordRep);

vendor/current/source4/rpc_server/samr/dcesrv_samr.h

r740	r988
21	21
22	22	#include "param/param.h"
	23	#include "libds/common/roles.h"
23	24
24	25	/*

vendor/current/source4/rpc_server/samr/samr_password.c

-              r860
+              r988
 #include "libcli/auth/libcli_auth.h"
 #include "../lib/util/util_ldb.h"
+#include "rpc_server/samr/proto.h"
+#include "auth/auth_sam.h"
 /*
 …
         int ret;
         struct ldb_message **res;
+        const char * const attrs[] = { "objectSid", "dBCSPwd", NULL };
+        const char * const attrs[] = { "objectSid", "dBCSPwd",
+                                       "userAccountControl",
+                                       "msDS-User-Account-Control-Computed",
+                                       "badPwdCount", "badPasswordTime",
+                                       NULL };
         struct samr_Password *lm_pwd;
         DATA_BLOB lm_pwd_blob;
 …
         struct samr_Password lm_verifier;
         size_t unicode_pw_len;
+        size_t converted_size = 0;
         if (pwbuf == NULL) {
 …
                            mem_ctx, NULL, &res, attrs,
                            "(&(sAMAccountName=%s)(objectclass=user))",
                            r->in.account->string);
+                           ldb_binary_encode_string(mem_ctx, r->in.account->string));
         if (ret != 1) {
                 /* Don't give the game away:  (don't allow anonymous users to prove the existance of usernames) */
 …
         status = samdb_result_passwords(mem_ctx, dce_call->conn->dce_ctx->lp_ctx,
                                         res[0], &lm_pwd, NULL);
+        if (!NT_STATUS_IS_OK(status) || !lm_pwd) {
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        } else if (!lm_pwd) {
                 return NT_STATUS_WRONG_PASSWORD;
+        }
 …
         if (!extract_pw_from_buffer(mem_ctx, pwbuf->data, &new_password)) {
                 DEBUG(3,("samr: failed to decode password buffer\n"));
+                return NT_STATUS_WRONG_PASSWORD;
+        }
+        if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
+                authsam_update_bad_pwd_count(sam_ctx, res[0], ldb_get_default_basedn(sam_ctx));
+                return NT_STATUS_WRONG_PASSWORD;
+        }
+        if (!convert_string_talloc_handle(mem_ctx, lpcfg_iconv_handle(dce_call->conn->dce_ctx->lp_ctx),
                                   CH_DOS, CH_UNIX,
                                   (const char *)new_password.data,
                                   new_password.length,
                                   (void **)&new_pass, NULL, false)) {
+                                  (void **)&new_pass, &converted_size)) {
                 DEBUG(3,("samr: failed to convert incoming password buffer to unix charset\n"));
+                return NT_STATUS_WRONG_PASSWORD;
+        }
+        if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
+                authsam_update_bad_pwd_count(sam_ctx, res[0], ldb_get_default_basedn(sam_ctx));
+                return NT_STATUS_WRONG_PASSWORD;
+        }
+        if (!convert_string_talloc_handle(mem_ctx, lpcfg_iconv_handle(dce_call->conn->dce_ctx->lp_ctx),
                                                CH_DOS, CH_UTF16,
                                                (const char *)new_password.data,
                                                new_password.length,
                                                (void **)&new_unicode_password.data, &unicode_pw_len, false)) {
+                                               (void **)&new_unicode_password.data, &unicode_pw_len)) {
                 DEBUG(3,("samr: failed to convert incoming password buffer to UTF16 charset\n"));
+                authsam_update_bad_pwd_count(sam_ctx, res[0], ldb_get_default_basedn(sam_ctx));
                 return NT_STATUS_WRONG_PASSWORD;
+        }
 …
         E_old_pw_hash(new_lm_hash, lm_pwd->hash, lm_verifier.hash);
         if (memcmp(lm_verifier.hash, r->in.hash->hash, 16) != 0) {
+                authsam_update_bad_pwd_count(sam_ctx, res[0], ldb_get_default_basedn(sam_ctx));
                 return NT_STATUS_WRONG_PASSWORD;
+        }
 …
         DATA_BLOB new_password;
         struct ldb_context *sam_ctx = NULL;
         struct ldb_dn *user_dn;
+        struct ldb_dn *user_dn = NULL;
         int ret;
         struct ldb_message **res;
+        const char * const attrs[] = { "unicodePwd", "dBCSPwd", NULL };
+        const char * const attrs[] = { "unicodePwd", "dBCSPwd",
+                                       "userAccountControl",
+                                       "msDS-User-Account-Control-Computed",
+                                       "badPwdCount", "badPasswordTime",
+                                       "objectSid", NULL };
         struct samr_Password *nt_pwd, *lm_pwd;
         DATA_BLOB nt_pwd_blob;
 …
                            mem_ctx, NULL, &res, attrs,
                            "(&(sAMAccountName=%s)(objectclass=user))",
                            r->in.account->string);
+                           ldb_binary_encode_string(mem_ctx, r->in.account->string));
         if (ret != 1) {
                 /* Don't give the game away:  (don't allow anonymous users to prove the existance of usernames) */
 …
         if (lm_pwd && r->in.lm_verifier != NULL) {
                 char *new_pass;
+                if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(dce_call->conn->dce_ctx->lp_ctx),
+                size_t converted_size = 0;
+                if (!convert_string_talloc_handle(mem_ctx, lpcfg_iconv_handle(dce_call->conn->dce_ctx->lp_ctx),
                                           CH_UTF16, CH_UNIX,
                                           (const char *)new_password.data,
                                           new_password.length,
                                           (void **)&new_pass, NULL, false)) {
+                                          (void **)&new_pass, &converted_size)) {
                         E_deshash(new_pass, new_lm_hash);
                         E_old_pw_hash(new_nt_hash, lm_pwd->hash, lm_verifier.hash);
 …
 failed:
+        /* Only update the badPwdCount if we found the user */
+        if (user_dn != NULL && NT_STATUS_EQUAL(status, NT_STATUS_WRONG_PASSWORD)) {
+                authsam_update_bad_pwd_count(sam_ctx, res[0], ldb_get_default_basedn(sam_ctx));
+        }
         reject = talloc_zero(mem_ctx, struct userPwdChangeFailureInformation);
         if (reject != NULL) {
 …
         nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
         if (!NT_STATUS_IS_OK(nt_status)) {
+                return nt_status;
+                DEBUG(3,("samr: failed to get session key: %s "
+                         "=> NT_STATUS_WRONG_PASSWORD\n",
+                        nt_errstr(nt_status)));
+                return NT_STATUS_WRONG_PASSWORD;
+        }
 …
         nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
         if (!NT_STATUS_IS_OK(nt_status)) {
+                return nt_status;
+                DEBUG(3,("samr: failed to get session key: %s "
+                         "=> NT_STATUS_WRONG_PASSWORD\n",
+                        nt_errstr(nt_status)));
+                return NT_STATUS_WRONG_PASSWORD;
+        }
 …
+{
         struct samr_Password *d_lm_pwd_hash = NULL, *d_nt_pwd_hash = NULL;
+        uint8_t random_session_key[16] = { 0, };
         DATA_BLOB session_key = data_blob(NULL, 0);
         DATA_BLOB in, out;
 …
         nt_status = dcesrv_fetch_session_key(dce_call->conn, &session_key);
+        if (NT_STATUS_EQUAL(nt_status, NT_STATUS_NO_USER_SESSION_KEY)) {
+                DEBUG(3,("samr: failed to get session key: %s "
+                         "=> use a random session key\n",
+                         nt_errstr(nt_status)));
+                /*
+                 * Windows just uses a random key
+                 */
+                generate_random_buffer(random_session_key,
+                                       sizeof(random_session_key));
+                session_key = data_blob_const(random_session_key,
+                                              sizeof(random_session_key));
+                nt_status = NT_STATUS_OK;
+        }
         if (!NT_STATUS_IS_OK(nt_status)) {
                 return nt_status;

vendor/current/source4/rpc_server/service_rpc.c

-              r740
+              r988
 #include "smbd/process_model.h"
+NTSTATUS server_service_rpc_init(void);
 /*
 …
         for (e=dce_ctx->endpoint_list;e;e=e->next) {
+                enum dcerpc_transport_t transport =
+                        dcerpc_binding_get_transport(e->ep_description);
+                if (transport == NCACN_HTTP) {
+                        /*
+                         * We don't support ncacn_http yet
+                         */
+                        continue;
+                }
                 status = dcesrv_add_ep(dce_ctx, task->lp_ctx, e, task->event_ctx, model_ops);
                 if (!NT_STATUS_IS_OK(status)) goto failed;
+        }
+        irpc_add_name(task->msg_ctx, "rpc_server");
         return;
 failed:

vendor/current/source4/rpc_server/spoolss/dcesrv_spoolss.c

-              r740
+              r988
         status = ntptr_init_context(dce_call->context, dce_call->conn->event_ctx, dce_call->conn->dce_ctx->lp_ctx,
                                     lpcfg_ntptr_providor(dce_call->conn->dce_ctx->lp_ctx), &ntptr);
+                                    "simple_ldb", &ntptr);
         NT_STATUS_NOT_OK_RETURN(status);
 …
         r2->in.devmode_ctr      = r->in.devmode_ctr;
         r2->in.access_mask      = r->in.access_mask;
+        r2->in.level            = 1;
+        r2->in.userlevel.level1 = NULL;
+        r2->in.userlevel_ctr.level      = 1;
+        r2->in.userlevel_ctr.user_info.level1 = NULL;
         r2->out.handle          = r->out.handle;
 …
+{
         struct dcerpc_pipe *p;
+        char *binding_string;
         struct dcerpc_binding *binding;
         NTSTATUS status;
 …
          * TODO: for now just open a connection to the client and drop it again
          *       to keep the w2k3 PrintServer
          *       happy to allow to open the Add Printer GUI
+         *       happy to allow one to open the Add Printer GUI
          *       and the torture suite passing
          */
+        binding = talloc_zero(mem_ctx, struct dcerpc_binding);
+        binding->transport = NCACN_NP;
+        if (strncmp(r->in.local_machine, "\\\\", 2))
+        if (strncmp(r->in.local_machine, "\\\\", 2)) {
                 return WERR_INVALID_COMPUTERNAME;
+        binding->host = r->in.local_machine+2;
+        }
+        binding_string = talloc_asprintf(mem_ctx, "ncacn_np:%s",
+                                         r->in.local_machine+2);
+        if (binding_string == NULL) {
+                return WERR_NOMEM;
+        }
+        status = dcerpc_parse_binding(mem_ctx, binding_string, &binding);
+        if (!NT_STATUS_IS_OK(status)) {
+                return ntstatus_to_werror(status);
+        }
         creds = cli_credentials_init_anon(mem_ctx); /* FIXME: Use machine credentials instead ? */
 …
 /*
   spoolss_61
 */
 static WERROR dcesrv_spoolss_61(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
                        struct spoolss_61 *r)
+  spoolss_RpcSendRecvBidiData
+*/
+static WERROR dcesrv_spoolss_RpcSendRecvBidiData(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct spoolss_RpcSendRecvBidiData *r)
+{
         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 …
+/*
+  spoolss_RpcGetJobNamedPropertyValue
+*/
+static WERROR dcesrv_spoolss_RpcGetJobNamedPropertyValue(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct spoolss_RpcGetJobNamedPropertyValue *r)
+{
+        DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
+/*
+  spoolss_RpcSetJobNamedProperty
+*/
+static WERROR dcesrv_spoolss_RpcSetJobNamedProperty(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct spoolss_RpcSetJobNamedProperty *r)
+{
+        DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
+/*
+  spoolss_RpcDeleteJobNamedProperty
+*/
+static WERROR dcesrv_spoolss_RpcDeleteJobNamedProperty(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct spoolss_RpcDeleteJobNamedProperty *r)
+{
+        DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
+/*
+  spoolss_RpcEnumJobNamedProperties
+*/
+static WERROR dcesrv_spoolss_RpcEnumJobNamedProperties(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
+                       struct spoolss_RpcEnumJobNamedProperties *r)
+{
+        DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
+}
 /* include the generated boilerplate */

vendor/current/source4/rpc_server/srvsvc/dcesrv_srvsvc.c

-              r740
+              r988
                 W_ERROR_HAVE_NO_MEMORY(info->info1->name);
                 info->info1->type       = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
                 info->info1->comment    = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
+                info->info1->comment    = share_string_option(mem_ctx, scfg, SHARE_COMMENT, "");
                 W_ERROR_HAVE_NO_MEMORY(info->info1->comment);
 …
                 W_ERROR_HAVE_NO_MEMORY(info->info2->name);
                 info->info2->type               = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
                 info->info2->comment            = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
+                info->info2->comment            = share_string_option(mem_ctx, scfg, SHARE_COMMENT, "");
                 W_ERROR_HAVE_NO_MEMORY(info->info2->comment);
                 info->info2->permissions        = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 …
                 info->info2->path               = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
                 W_ERROR_HAVE_NO_MEMORY(info->info2->path);
                 info->info2->password           = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
+                info->info2->password           = share_string_option(mem_ctx, scfg, SHARE_PASSWORD, NULL);
                 return WERR_OK;
 …
                 W_ERROR_HAVE_NO_MEMORY(info->info501->name);
                 info->info501->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
                 info->info501->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
+                info->info501->comment          = share_string_option(mem_ctx, scfg, SHARE_COMMENT, "");
                 W_ERROR_HAVE_NO_MEMORY(info->info501->comment);
                 info->info501->csc_policy       = share_int_option(scfg, SHARE_CSC_POLICY, SHARE_CSC_POLICY_DEFAULT);
 …
                 W_ERROR_HAVE_NO_MEMORY(info->info502->name);
                 info->info502->type             = dcesrv_common_get_share_type(mem_ctx, dce_ctx, scfg);
                 info->info502->comment          = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_COMMENT, ""));
+                info->info502->comment          = share_string_option(mem_ctx, scfg, SHARE_COMMENT, "");
                 W_ERROR_HAVE_NO_MEMORY(info->info502->comment);
                 info->info502->permissions      = dcesrv_common_get_share_permissions(mem_ctx, dce_ctx, scfg);
 …
                 info->info502->path             = dcesrv_common_get_share_path(mem_ctx, dce_ctx, scfg);
                 W_ERROR_HAVE_NO_MEMORY(info->info502->path);
                 info->info502->password         = talloc_strdup(mem_ctx, share_string_option(scfg, SHARE_PASSWORD, NULL));
+                info->info502->password         = share_string_option(mem_ctx, scfg, SHARE_PASSWORD, NULL);
                 info->info502->sd_buf.sd        = dcesrv_common_get_security_descriptor(mem_ctx, dce_ctx, scfg);
 …
                         return ntstatus_to_werror(nterr);
+                }
                 path = share_string_option(scfg, SHARE_PATH, NULL);
+                path = share_string_option(mem_ctx, scfg, SHARE_PATH, NULL);
                 if (!path) continue;
                 if (strcmp(device, path) == 0) {
                         type = share_string_option(scfg, SHARE_TYPE, NULL);
+                if (strcmp(device, path) == 0) {
+                        type = share_string_option(mem_ctx, scfg, SHARE_TYPE, NULL);
                         if (!type) continue;
 …
                 info101->version_minor  = server_info->version_minor;
                 info101->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
                 info101->comment        = talloc_strdup(mem_ctx, lpcfg_serverstring(dce_ctx->lp_ctx));
+                info101->comment        = lpcfg_server_string(dce_ctx->lp_ctx, mem_ctx);
                 W_ERROR_HAVE_NO_MEMORY(info101->comment);
 …
                 info102->version_minor  = server_info->version_minor;
                 info102->server_type    = dcesrv_common_get_server_type(mem_ctx, dce_call->event_ctx, dce_ctx);
                 info102->comment        = talloc_strdup(mem_ctx, lpcfg_serverstring(dce_ctx->lp_ctx));
+                info102->comment        = lpcfg_server_string(dce_ctx->lp_ctx, mem_ctx);
                 W_ERROR_HAVE_NO_MEMORY(info102->comment);

vendor/current/source4/rpc_server/srvsvc/srvsvc_ntvfs.c

-              r740
+              r988
 #include "rpc_server/dcerpc_server.h"
 #include "param/param.h"
+#include "rpc_server/srvsvc/proto.h"
 struct srvsvc_ntvfs_ctx {
 …
         struct share_context *sctx;
         struct share_config *scfg;
         const char *sharetype;
+        char *sharetype;
         union smb_tcon tcon;
         const struct tsocket_address *local_address;
 …
         /* work out what sort of connection this is */
         sharetype = share_string_option(scfg, SHARE_TYPE, SHARE_TYPE_DEFAULT);
+        sharetype = share_string_option(mem_ctx, scfg, SHARE_TYPE, SHARE_TYPE_DEFAULT);
         if (sharetype && strcmp(sharetype, "IPC") == 0) {
                 type = NTVFS_IPC;
 …
                 type = NTVFS_DISK;
+        }
+        TALLOC_FREE(sharetype);
         c = talloc(mem_ctx, struct srvsvc_ntvfs_ctx);

vendor/current/source4/rpc_server/unixinfo/dcesrv_unixinfo.c

-              r740
+              r988
 #include "system/passwd.h"
-static NTSTATUS dcerpc_unixinfo_bind(struct dcesrv_call_state *dce_call,
-                                     const struct dcesrv_interface *iface)
+{
-        struct wbc_context *wbc_ctx;
-        wbc_ctx = wbc_init(dce_call->context, dce_call->msg_ctx,
-                           dce_call->event_ctx);
-        NT_STATUS_HAVE_NO_MEMORY(wbc_ctx);
-        dce_call->context->private_data = wbc_ctx;
-        return NT_STATUS_OK;
+}
-#define DCESRV_INTERFACE_UNIXINFO_BIND dcerpc_unixinfo_bind
 static NTSTATUS dcesrv_unixinfo_SidToUid(struct dcesrv_call_state *dce_call,
                                   TALLOC_CTX *mem_ctx,
 …
+{
         NTSTATUS status;
-        struct wbc_context *wbc_ctx = talloc_get_type_abort(
-                                                dce_call->context->private_data,
-                                                struct wbc_context);
         struct id_map *ids;
-        struct composite_context *ctx;
         DEBUG(5, ("dcesrv_unixinfo_SidToUid called\n"));
 …
         ids->status = ID_UNKNOWN;
         ZERO_STRUCT(ids->xid);
+        ctx = wbc_sids_to_xids_send(wbc_ctx, ids, 1, ids);
+        NT_STATUS_HAVE_NO_MEMORY(ctx);
+        status = wbc_sids_to_xids_recv(ctx, &ids);
+        status = wbc_sids_to_xids(dce_call->event_ctx, ids, 1);
         NT_STATUS_NOT_OK_RETURN(status);
 …
                                   struct unixinfo_UidToSid *r)
+{
-        struct wbc_context *wbc_ctx = talloc_get_type_abort(
-                                                dce_call->context->private_data,
-                                                struct wbc_context);
         struct id_map *ids;
-        struct composite_context *ctx;
         uint32_t uid;
         NTSTATUS status;
 …
         ids->xid.type = ID_TYPE_UID;
+        ctx = wbc_xids_to_sids_send(wbc_ctx, ids, 1, ids);
+        NT_STATUS_HAVE_NO_MEMORY(ctx);
+        status = wbc_xids_to_sids_recv(ctx, &ids);
+        status = wbc_xids_to_sids(dce_call->event_ctx, ids, 1);
         NT_STATUS_NOT_OK_RETURN(status);
 …
+{
         NTSTATUS status;
-        struct wbc_context *wbc_ctx = talloc_get_type_abort(
-                                                dce_call->context->private_data,
-                                                struct wbc_context);
         struct id_map *ids;
-        struct composite_context *ctx;
         DEBUG(5, ("dcesrv_unixinfo_SidToGid called\n"));
 …
         ids->status = ID_UNKNOWN;
         ZERO_STRUCT(ids->xid);
+        ctx = wbc_sids_to_xids_send(wbc_ctx, ids, 1, ids);
+        NT_STATUS_HAVE_NO_MEMORY(ctx);
+        status = wbc_sids_to_xids_recv(ctx, &ids);
+        status = wbc_sids_to_xids(dce_call->event_ctx, ids, 1);
         NT_STATUS_NOT_OK_RETURN(status);
 …
                                   struct unixinfo_GidToSid *r)
+{
-        struct wbc_context *wbc_ctx = talloc_get_type_abort(
-                                                dce_call->context->private_data,
-                                                struct wbc_context);
         struct id_map *ids;
-        struct composite_context *ctx;
         uint32_t gid;
         NTSTATUS status;
 …
         ids->xid.type = ID_TYPE_GID;
+        ctx = wbc_xids_to_sids_send(wbc_ctx, ids, 1, ids);
+        NT_STATUS_HAVE_NO_MEMORY(ctx);
+        status = wbc_xids_to_sids_recv(ctx, &ids);
+        status = wbc_xids_to_sids(dce_call->event_ctx, ids, 1);
         NT_STATUS_NOT_OK_RETURN(status);

vendor/current/source4/rpc_server/winreg/rpc_winreg.c

r740	r988
43	43	if (!W_ERROR_IS_OK(err)) {
44	44	DEBUG(0, ("Error opening registry: %s\n", win_errstr(err)));
45		return ~~NT_STATUS_UNSUCCESSFUL~~;
	45	return werror_to_ntstatus(err);
46	46	}
47	47

vendor/current/source4/rpc_server/wscript_build

-              r740
+              r988
         source='common/server_info.c common/share_info.c',
         autoproto='common/share.h',
+        deps='ldb'
+        deps='ldb',
+        enabled=bld.AD_DC_BUILD_IS_ENABLED()
+        )
 bld.SAMBA_SUBSYSTEM('DCERPC_COMMON',
         source='common/forward.c common/reply.c dcesrv_auth.c',
+        source='common/forward.c common/reply.c dcesrv_auth.c common/loadparm.c',
         autoproto='common/proto.h',
+        deps='ldb DCERPC_SHARE samba_server_gensec'
+        deps='ldb DCERPC_SHARE samba_server_gensec',
+        enabled=bld.AD_DC_BUILD_IS_ENABLED()
+        )
+bld.SAMBA_LIBRARY('dcerpc_server',
+        source='dcerpc_server.c dcesrv_mgmt.c handles.c',
+        pc_files='dcerpc_server.pc',
+        deps='LIBCLI_AUTH ndr samba_server_gensec dcerpc_remote service auth',
+        public_deps='dcerpc',
+        autoproto='dcerpc_server_proto.h',
+        public_headers='dcerpc_server.h',
+        vnum='0.0.1',
+        enabled=bld.AD_DC_BUILD_IS_ENABLED()
+        )
 bld.SAMBA_MODULE('dcerpc_rpcecho',
 …
         subsystem='dcerpc_server',
         init_function='dcerpc_server_samr_init',
         deps='samdb DCERPC_COMMON ndr-standard'
+        deps='samdb DCERPC_COMMON ndr-standard auth4_sam'
+        )
 …
         subsystem='dcerpc_server',
         init_function='dcerpc_server_netlogon_init',
         deps='DCERPC_COMMON RPC_NDR_IRPC COMMON_SCHANNEL ndr-standard auth4_sam samba-hostconfig CLDAPD'
+        deps='DCERPC_COMMON RPC_NDR_IRPC COMMON_SCHANNEL ndr-standard auth4_sam samba-hostconfig DSDB_MODULE_HELPERS'
+        )
 …
         subsystem='dcerpc_server',
         init_function='dcerpc_server_lsa_init',
         deps='samdb DCERPC_COMMON ndr-standard LIBCLI_AUTH NDR_DSSETUP com_err security kdc-policy'
+        deps='samdb DCERPC_COMMON ndr-standard LIBCLI_AUTH NDR_DSSETUP com_err samba-security UTIL_LSARPC'
+        )
+bld.SAMBA_MODULE('dcerpc_backupkey',
+        source='backupkey/dcesrv_backupkey.c ',
+        autoproto='backupkey/proto.h',
+        subsystem='dcerpc_server',
+        init_function='dcerpc_server_backupkey_init',
+        deps='samdb DCERPC_COMMON NDR_BACKUPKEY RPC_NDR_BACKUPKEY'
+        )
+if bld.CONFIG_SET('HAVE_GNUTLS_3_4_7'):
+        bld.SAMBA_MODULE('dcerpc_backupkey',
+                source='backupkey/dcesrv_backupkey.c ',
+                autoproto='backupkey/proto.h',
+                subsystem='dcerpc_server',
+                init_function='dcerpc_server_backupkey_init',
+                deps='samdb DCERPC_COMMON NDR_BACKUPKEY RPC_NDR_BACKUPKEY gnutls',
+                )
+else:
+        bld.SAMBA_MODULE('dcerpc_backupkey',
+                source='backupkey/dcesrv_backupkey_heimdal.c ',
+                autoproto='backupkey/proto.h',
+                subsystem='dcerpc_server',
+                init_function='dcerpc_server_backupkey_init',
+                deps='samdb DCERPC_COMMON NDR_BACKUPKEY RPC_NDR_BACKUPKEY krb5 hx509 hcrypto gnutls gcrypt',
+                )
 …
         subsystem='dcerpc_server',
         init_function='dcerpc_server_drsuapi_init',
         deps='samdb DCERPC_COMMON NDR_DRSUAPI security'
+        deps='samdb DCERPC_COMMON NDR_DRSUAPI samba-security'
+        )
 …
+        )
+bld.SAMBA_LIBRARY('dcerpc_server',
+        source='dcerpc_server.c dcesrv_mgmt.c handles.c',
+        pc_files='dcerpc_server.pc',
+        deps='LIBCLI_AUTH ndr samba_server_gensec dcerpc_remote service',
+        public_deps='dcerpc',
+        autoproto='dcerpc_server_proto.h',
+        public_headers='dcerpc_server.h',
+        vnum='0.0.1'
+        )
+bld.SAMBA_MODULE('dcerpc_dnsserver',
+    source='dnsserver/dcerpc_dnsserver.c dnsserver/dnsutils.c dnsserver/dnsdata.c dnsserver/dnsdb.c',
+    subsystem='dcerpc_server',
+    init_function='dcerpc_server_dnsserver_init',
+    deps='DCERPC_COMMON'
+    )
 bld.SAMBA_MODULE('service_dcerpc',

Context Navigation

Legend:

vendor/current/source4/rpc_server/backupkey/dcesrv_backupkey.c

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

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

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

vendor/current/source4/rpc_server/dcerpc_server.c

vendor/current/source4/rpc_server/dcerpc_server.h

vendor/current/source4/rpc_server/dcerpc_server.pc.in

vendor/current/source4/rpc_server/dcesrv_auth.c

vendor/current/source4/rpc_server/dcesrv_mgmt.c

vendor/current/source4/rpc_server/drsuapi/addentry.c

vendor/current/source4/rpc_server/drsuapi/dcesrv_drsuapi.c

vendor/current/source4/rpc_server/drsuapi/drsutil.c

vendor/current/source4/rpc_server/drsuapi/getncchanges.c

vendor/current/source4/rpc_server/drsuapi/updaterefs.c

vendor/current/source4/rpc_server/drsuapi/writespn.c

vendor/current/source4/rpc_server/echo/rpc_echo.c

vendor/current/source4/rpc_server/epmapper/rpc_epmapper.c

vendor/current/source4/rpc_server/handles.c

vendor/current/source4/rpc_server/lsa/dcesrv_lsa.c

vendor/current/source4/rpc_server/lsa/lsa.h

vendor/current/source4/rpc_server/lsa/lsa_init.c

vendor/current/source4/rpc_server/lsa/lsa_lookup.c

vendor/current/source4/rpc_server/netlogon/dcerpc_netlogon.c

vendor/current/source4/rpc_server/remote/dcesrv_remote.c

vendor/current/source4/rpc_server/samr/dcesrv_samr.c

vendor/current/source4/rpc_server/samr/dcesrv_samr.h

vendor/current/source4/rpc_server/samr/samr_password.c

vendor/current/source4/rpc_server/service_rpc.c

vendor/current/source4/rpc_server/spoolss/dcesrv_spoolss.c

vendor/current/source4/rpc_server/srvsvc/dcesrv_srvsvc.c

vendor/current/source4/rpc_server/srvsvc/srvsvc_ntvfs.c

vendor/current/source4/rpc_server/unixinfo/dcesrv_unixinfo.c

vendor/current/source4/rpc_server/winreg/rpc_winreg.c

vendor/current/source4/rpc_server/wscript_build

Download in other formats: