Changeset 988 for vendor/current/libcli

vendor/current/libcli/auth/credentials.c

-              r746
+              r988
 /*
+/*
    Unix SMB/CIFS implementation.
 …
    Copyright (C) Andrew Tridgell 1997-2003
    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004
    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/>.
 …
                                       struct netr_Credential *out)
+{
+        des_crypt112(out->data, in->data, creds->session_key, 1);
+        if (creds->negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                AES_KEY key;
+                uint8_t iv[AES_BLOCK_SIZE];
+                AES_set_encrypt_key(creds->session_key, 128, &key);
+                ZERO_STRUCT(iv);
+                aes_cfb8_encrypt(in->data, out->data, 8, &key, iv, AES_ENCRYPT);
+        } else {
+                des_crypt112(out->data, in->data, creds->session_key, 1);
+        }
+}
 …
         memset(zero, 0, sizeof(zero));
         hmac_md5_init_rfc2104(machine_password->hash, sizeof(machine_password->hash), &ctx);
+        hmac_md5_init_rfc2104(machine_password->hash, sizeof(machine_password->hash), &ctx);
         MD5Init(&md5);
         MD5Update(&md5, zero, sizeof(zero));
 …
+}
+/*
+  initialise the credentials state for AES/HMAC-SHA256-style 128 bit session keys
+  this call is made after the netr_ServerReqChallenge call
+*/
+static void netlogon_creds_init_hmac_sha256(struct netlogon_creds_CredentialState *creds,
+                                            const struct netr_Credential *client_challenge,
+                                            const struct netr_Credential *server_challenge,
+                                            const struct samr_Password *machine_password)
+{
+        struct HMACSHA256Context ctx;
+        uint8_t digest[SHA256_DIGEST_LENGTH];
+        ZERO_STRUCT(creds->session_key);
+        hmac_sha256_init(machine_password->hash,
+                         sizeof(machine_password->hash),
+                         &ctx);
+        hmac_sha256_update(client_challenge->data, 8, &ctx);
+        hmac_sha256_update(server_challenge->data, 8, &ctx);
+        hmac_sha256_final(digest, &ctx);
+        memcpy(creds->session_key, digest, sizeof(creds->session_key));
+        ZERO_STRUCT(digest);
+        ZERO_STRUCT(ctx);
+}
 static void netlogon_creds_first_step(struct netlogon_creds_CredentialState *creds,
                                       const struct netr_Credential *client_challenge,
 …
         struct netr_Credential time_cred;
         DEBUG(5,("\tseed        %08x:%08x\n",
+        DEBUG(5,("\tseed        %08x:%08x\n",
                  IVAL(creds->seed.data, 0), IVAL(creds->seed.data, 4)));
 …
         netlogon_creds_step_crypt(creds, &time_cred, &creds->client);
         DEBUG(5,("\tCLIENT      %08x:%08x\n",
+        DEBUG(5,("\tCLIENT      %08x:%08x\n",
                  IVAL(creds->client.data, 0), IVAL(creds->client.data, 4)));
 …
         SIVAL(time_cred.data, 4, IVAL(creds->seed.data, 4));
         DEBUG(5,("\tseed+time+1 %08x:%08x\n",
+        DEBUG(5,("\tseed+time+1 %08x:%08x\n",
                  IVAL(time_cred.data, 0), IVAL(time_cred.data, 4)));
         netlogon_creds_step_crypt(creds, &time_cred, &creds->server);
         DEBUG(5,("\tSERVER      %08x:%08x\n",
+        DEBUG(5,("\tSERVER      %08x:%08x\n",
                  IVAL(creds->server.data, 0), IVAL(creds->server.data, 4)));
 …
         data_blob_free(&session_key);
+}
+/*
+  AES encrypt a password buffer using the session key
+*/
+void netlogon_creds_aes_encrypt(struct netlogon_creds_CredentialState *creds, uint8_t *data, size_t len)
+{
+        AES_KEY key;
+        uint8_t iv[AES_BLOCK_SIZE];
+        AES_set_encrypt_key(creds->session_key, 128, &key);
+        ZERO_STRUCT(iv);
+        aes_cfb8_encrypt(data, data, len, &key, iv, AES_ENCRYPT);
+}
+/*
+  AES decrypt a password buffer using the session key
+*/
+void netlogon_creds_aes_decrypt(struct netlogon_creds_CredentialState *creds, uint8_t *data, size_t len)
+{
+        AES_KEY key;
+        uint8_t iv[AES_BLOCK_SIZE];
+        AES_set_encrypt_key(creds->session_key, 128, &key);
+        ZERO_STRUCT(iv);
+        aes_cfb8_encrypt(data, data, len, &key, iv, AES_DECRYPT);
+}
 …
   credentials
 */
 struct netlogon_creds_CredentialState *netlogon_creds_client_init(TALLOC_CTX *mem_ctx,
+struct netlogon_creds_CredentialState *netlogon_creds_client_init(TALLOC_CTX *mem_ctx,
                                                                   const char *client_account,
+                                                                  const char *client_computer_name,
+                                                                  const char *client_computer_name,
+                                                                  uint16_t secure_channel_type,
                                                                   const struct netr_Credential *client_challenge,
                                                                   const struct netr_Credential *server_challenge,
 …
+{
         struct netlogon_creds_CredentialState *creds = talloc_zero(mem_ctx, struct netlogon_creds_CredentialState);
         if (!creds) {
                 return NULL;
+        }
         creds->sequence = time(NULL);
         creds->negotiate_flags = negotiate_flags;
+        creds->secure_channel_type = secure_channel_type;
         creds->computer_name = talloc_strdup(creds, client_computer_name);
 …
         dump_data_pw("Machine Pass", machine_password->hash, sizeof(machine_password->hash));
+        if (negotiate_flags & NETLOGON_NEG_128BIT) {
+        if (negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                netlogon_creds_init_hmac_sha256(creds,
+                                                client_challenge,
+                                                server_challenge,
+                                                machine_password);
+        } else if (negotiate_flags & NETLOGON_NEG_STRONG_KEYS) {
                 netlogon_creds_init_128bit(creds, client_challenge, server_challenge, machine_password);
         } else {
 …
  */
 struct netlogon_creds_CredentialState *netlogon_creds_client_init_session_key(TALLOC_CTX *mem_ctx,
+struct netlogon_creds_CredentialState *netlogon_creds_client_init_session_key(TALLOC_CTX *mem_ctx,
                                                                               const uint8_t session_key[16])
+{
 …
                 return NULL;
+        }
         memcpy(creds->session_key, session_key, 16);
 …
   current client and server credentials and the seed
   produce the next authenticator in the sequence ready to send to
+  produce the next authenticator in the sequence ready to send to
   the server
 */
 void netlogon_creds_client_authenticator(struct netlogon_creds_CredentialState *creds,
                                 struct netr_Authenticator *next)
+{
+{
+        uint32_t t32n = (uint32_t)time(NULL);
+        /*
+         * we always increment and ignore an overflow here
+         */
         creds->sequence += 2;
+        if (t32n > creds->sequence) {
+                /*
+                 * we may increment more
+                 */
+                creds->sequence = t32n;
+        } else {
+                uint32_t d = creds->sequence - t32n;
+                if (d >= INT32_MAX) {
+                        /*
+                         * got an overflow of time_t vs. uint32_t
+                         */
+                        creds->sequence = t32n;
+                }
+        }
         netlogon_creds_step(creds);
 …
                         const struct netr_Credential *received_credentials)
+{
         if (!received_credentials ||
+        if (!received_credentials ||
             memcmp(received_credentials->data, creds->server.data, 8) != 0) {
                 DEBUG(2,("credentials check failed\n"));
 …
   credentials
 */
 struct netlogon_creds_CredentialState *netlogon_creds_server_init(TALLOC_CTX *mem_ctx,
+struct netlogon_creds_CredentialState *netlogon_creds_server_init(TALLOC_CTX *mem_ctx,
                                                                   const char *client_account,
                                                                   const char *client_computer_name,
+                                                                  const char *client_computer_name,
                                                                   uint16_t secure_channel_type,
                                                                   const struct netr_Credential *client_challenge,
                                                                   const struct netr_Credential *server_challenge,
                                                                   const struct samr_Password *machine_password,
                                                                   struct netr_Credential *credentials_in,
+                                                                  const struct netr_Credential *credentials_in,
                                                                   struct netr_Credential *credentials_out,
                                                                   uint32_t negotiate_flags)
+{
         struct netlogon_creds_CredentialState *creds = talloc_zero(mem_ctx, struct netlogon_creds_CredentialState);
         if (!creds) {
                 return NULL;
+        }
         creds->negotiate_flags = negotiate_flags;
         creds->secure_channel_type = secure_channel_type;
+        dump_data_pw("Client chall", client_challenge->data, sizeof(client_challenge->data));
+        dump_data_pw("Server chall", server_challenge->data, sizeof(server_challenge->data));
+        dump_data_pw("Machine Pass", machine_password->hash, sizeof(machine_password->hash));
         creds->computer_name = talloc_strdup(creds, client_computer_name);
 …
+        }
+        if (negotiate_flags & NETLOGON_NEG_128BIT) {
+                netlogon_creds_init_128bit(creds, client_challenge, server_challenge,
+        if (negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                netlogon_creds_init_hmac_sha256(creds,
+                                                client_challenge,
+                                                server_challenge,
+                                                machine_password);
+        } else if (negotiate_flags & NETLOGON_NEG_STRONG_KEYS) {
+                netlogon_creds_init_128bit(creds, client_challenge, server_challenge,
                                            machine_password);
         } else {
                 netlogon_creds_init_64bit(creds, client_challenge, server_challenge,
+                netlogon_creds_init_64bit(creds, client_challenge, server_challenge,
                                           machine_password);
+        }
         netlogon_creds_first_step(creds, client_challenge, server_challenge);
+        dump_data_pw("Session key", creds->session_key, 16);
+        dump_data_pw("Client Credential ", creds->client.data, 8);
+        dump_data_pw("Server Credential ", creds->server.data, 8);
+        dump_data_pw("Credentials in", credentials_in->data, sizeof(credentials_in->data));
         /* And before we leak information about the machine account
 …
         *credentials_out = creds->server;
+        dump_data_pw("Credentials out", credentials_out->data, sizeof(credentials_out->data));
         return creds;
+}
 NTSTATUS netlogon_creds_server_step_check(struct netlogon_creds_CredentialState *creds,
                                  struct netr_Authenticator *received_authenticator,
                                  struct netr_Authenticator *return_authenticator)
+                                 const struct netr_Authenticator *received_authenticator,
+                                 struct netr_Authenticator *return_authenticator)
+{
         if (!received_authenticator || !return_authenticator) {
 …
+        }
-        /* TODO: this may allow the a replay attack on a non-signed
-           connection. Should we check that this is increasing? */
         creds->sequence = received_authenticator->timestamp;
         netlogon_creds_step(creds);
         if (netlogon_creds_server_check_internal(creds, &received_authenticator->cred)) {
                 return_authenticator->cred = creds->server;
                 return_authenticator->timestamp = creds->sequence;
+                return_authenticator->timestamp = 0;
                 return NT_STATUS_OK;
         } else {
 …
+}
+void netlogon_creds_decrypt_samlogon(struct netlogon_creds_CredentialState *creds,
+                            uint16_t validation_level,
+                            union netr_Validation *validation)
+static void netlogon_creds_crypt_samlogon_validation(struct netlogon_creds_CredentialState *creds,
+                                                     uint16_t validation_level,
+                                                     union netr_Validation *validation,
+                                                     bool do_encrypt)
+{
         static const char zeros[16];
         struct netr_SamBaseInfo *base = NULL;
+        if (validation == NULL) {
+                return;
+        }
         switch (validation_level) {
         case 2:
 …
         if (validation_level == 6) {
                 /* they aren't encrypted! */
+        } else if (creds->negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                /* Don't crypt an all-zero key, it would give away the NETLOGON pipe session key */
+                if (memcmp(base->key.key, zeros,
+                           sizeof(base->key.key)) != 0) {
+                        if (do_encrypt) {
+                                netlogon_creds_aes_encrypt(creds,
+                                            base->key.key,
+                                            sizeof(base->key.key));
+                        } else {
+                                netlogon_creds_aes_decrypt(creds,
+                                            base->key.key,
+                                            sizeof(base->key.key));
+                        }
+                }
+                if (memcmp(base->LMSessKey.key, zeros,
+                           sizeof(base->LMSessKey.key)) != 0) {
+                        if (do_encrypt) {
+                                netlogon_creds_aes_encrypt(creds,
+                                            base->LMSessKey.key,
+                                            sizeof(base->LMSessKey.key));
+                        } else {
+                                netlogon_creds_aes_decrypt(creds,
+                                            base->LMSessKey.key,
+                                            sizeof(base->LMSessKey.key));
+                        }
+                }
         } else if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
+                if (memcmp(base->key.key, zeros,
+                /* Don't crypt an all-zero key, it would give away the NETLOGON pipe session key */
+                if (memcmp(base->key.key, zeros,
                            sizeof(base->key.key)) != 0) {
                         netlogon_creds_arcfour_crypt(creds,
                                             base->key.key,
+                        netlogon_creds_arcfour_crypt(creds,
+                                            base->key.key,
                                             sizeof(base->key.key));
+                }
                 if (memcmp(base->LMSessKey.key, zeros,
+                if (memcmp(base->LMSessKey.key, zeros,
                            sizeof(base->LMSessKey.key)) != 0) {
                         netlogon_creds_arcfour_crypt(creds,
                                             base->LMSessKey.key,
+                        netlogon_creds_arcfour_crypt(creds,
+                                            base->LMSessKey.key,
                                             sizeof(base->LMSessKey.key));
+                }
         } else {
+                if (memcmp(base->LMSessKey.key, zeros,
+                /* Don't crypt an all-zero key, it would give away the NETLOGON pipe session key */
+                if (memcmp(base->LMSessKey.key, zeros,
                            sizeof(base->LMSessKey.key)) != 0) {
+                        netlogon_creds_des_decrypt_LMKey(creds,
+                        if (do_encrypt) {
+                                netlogon_creds_des_encrypt_LMKey(creds,
                                                 &base->LMSessKey);
+                }
+        }
+}
+                        } else {
+                                netlogon_creds_des_decrypt_LMKey(creds,
+                                                &base->LMSessKey);
+                        }
+                }
+        }
+}
+void netlogon_creds_decrypt_samlogon_validation(struct netlogon_creds_CredentialState *creds,
+                                                uint16_t validation_level,
+                                                union netr_Validation *validation)
+{
+        netlogon_creds_crypt_samlogon_validation(creds, validation_level,
+                                                        validation, false);
+}
+void netlogon_creds_encrypt_samlogon_validation(struct netlogon_creds_CredentialState *creds,
+                                                uint16_t validation_level,
+                                                union netr_Validation *validation)
+{
+        netlogon_creds_crypt_samlogon_validation(creds, validation_level,
+                                                        validation, true);
+}
+static void netlogon_creds_crypt_samlogon_logon(struct netlogon_creds_CredentialState *creds,
+                                                enum netr_LogonInfoClass level,
+                                                union netr_LogonLevel *logon,
+                                                bool do_encrypt)
+{
+        static const char zeros[16];
+        if (logon == NULL) {
+                return;
+        }
+        switch (level) {
+        case NetlogonInteractiveInformation:
+        case NetlogonInteractiveTransitiveInformation:
+        case NetlogonServiceInformation:
+        case NetlogonServiceTransitiveInformation:
+                if (logon->password == NULL) {
+                        return;
+                }
+                if (creds->negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                        uint8_t *h;
+                        h = logon->password->lmpassword.hash;
+                        if (memcmp(h, zeros, 16) != 0) {
+                                if (do_encrypt) {
+                                        netlogon_creds_aes_encrypt(creds, h, 16);
+                                } else {
+                                        netlogon_creds_aes_decrypt(creds, h, 16);
+                                }
+                        }
+                        h = logon->password->ntpassword.hash;
+                        if (memcmp(h, zeros, 16) != 0) {
+                                if (do_encrypt) {
+                                        netlogon_creds_aes_encrypt(creds, h, 16);
+                                } else {
+                                        netlogon_creds_aes_decrypt(creds, h, 16);
+                                }
+                        }
+                } else if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
+                        uint8_t *h;
+                        h = logon->password->lmpassword.hash;
+                        if (memcmp(h, zeros, 16) != 0) {
+                                netlogon_creds_arcfour_crypt(creds, h, 16);
+                        }
+                        h = logon->password->ntpassword.hash;
+                        if (memcmp(h, zeros, 16) != 0) {
+                                netlogon_creds_arcfour_crypt(creds, h, 16);
+                        }
+                } else {
+                        struct samr_Password *p;
+                        p = &logon->password->lmpassword;
+                        if (memcmp(p->hash, zeros, 16) != 0) {
+                                if (do_encrypt) {
+                                        netlogon_creds_des_encrypt(creds, p);
+                                } else {
+                                        netlogon_creds_des_decrypt(creds, p);
+                                }
+                        }
+                        p = &logon->password->ntpassword;
+                        if (memcmp(p->hash, zeros, 16) != 0) {
+                                if (do_encrypt) {
+                                        netlogon_creds_des_encrypt(creds, p);
+                                } else {
+                                        netlogon_creds_des_decrypt(creds, p);
+                                }
+                        }
+                }
+                break;
+        case NetlogonNetworkInformation:
+        case NetlogonNetworkTransitiveInformation:
+                break;
+        case NetlogonGenericInformation:
+                if (logon->generic == NULL) {
+                        return;
+                }
+                if (creds->negotiate_flags & NETLOGON_NEG_SUPPORTS_AES) {
+                        if (do_encrypt) {
+                                netlogon_creds_aes_encrypt(creds,
+                                                logon->generic->data,
+                                                logon->generic->length);
+                        } else {
+                                netlogon_creds_aes_decrypt(creds,
+                                                logon->generic->data,
+                                                logon->generic->length);
+                        }
+                } else if (creds->negotiate_flags & NETLOGON_NEG_ARCFOUR) {
+                        netlogon_creds_arcfour_crypt(creds,
+                                                     logon->generic->data,
+                                                     logon->generic->length);
+                } else {
+                        /* Using DES to verify kerberos tickets makes no sense */
+                }
+                break;
+        }
+}
+void netlogon_creds_decrypt_samlogon_logon(struct netlogon_creds_CredentialState *creds,
+                                           enum netr_LogonInfoClass level,
+                                           union netr_LogonLevel *logon)
+{
+        netlogon_creds_crypt_samlogon_logon(creds, level, logon, false);
+}
+void netlogon_creds_encrypt_samlogon_logon(struct netlogon_creds_CredentialState *creds,
+                                           enum netr_LogonInfoClass level,
+                                           union netr_LogonLevel *logon)
+{
+        netlogon_creds_crypt_samlogon_logon(creds, level, logon, true);
+}
+union netr_LogonLevel *netlogon_creds_shallow_copy_logon(TALLOC_CTX *mem_ctx,
+                                        enum netr_LogonInfoClass level,
+                                        const union netr_LogonLevel *in)
+{
+        union netr_LogonLevel *out;
+        if (in == NULL) {
+                return NULL;
+        }
+        out = talloc(mem_ctx, union netr_LogonLevel);
+        if (out == NULL) {
+                return NULL;
+        }
+        *out = *in;
+        switch (level) {
+        case NetlogonInteractiveInformation:
+        case NetlogonInteractiveTransitiveInformation:
+        case NetlogonServiceInformation:
+        case NetlogonServiceTransitiveInformation:
+                if (in->password == NULL) {
+                        return out;
+                }
+                out->password = talloc(out, struct netr_PasswordInfo);
+                if (out->password == NULL) {
+                        talloc_free(out);
+                        return NULL;
+                }
+                *out->password = *in->password;
+                return out;
+        case NetlogonNetworkInformation:
+        case NetlogonNetworkTransitiveInformation:
+                break;
+        case NetlogonGenericInformation:
+                if (in->generic == NULL) {
+                        return out;
+                }
+                out->generic = talloc(out, struct netr_GenericInfo);
+                if (out->generic == NULL) {
+                        talloc_free(out);
+                        return NULL;
+                }
+                *out->generic = *in->generic;
+                if (in->generic->data == NULL) {
+                        return out;
+                }
+                if (in->generic->length == 0) {
+                        return out;
+                }
+                out->generic->data = talloc_memdup(out->generic,
+                                                   in->generic->data,
+                                                   in->generic->length);
+                if (out->generic->data == NULL) {
+                        talloc_free(out);
+                        return NULL;
+                }
+                return out;
+        }
+        return out;
+}
 /*

vendor/current/libcli/auth/credentials.h

r740	r988
69	69	#define NETLOGON_NEG_AUTH2_ADS_FLAGS (0x200fbffb \| NETLOGON_NEG_ARCFOUR \| NETLOGON_NEG_128BIT \| NETLOGON_NEG_SCHANNEL)
70	70
71		~~#define NETLOGON_NEG_AUTH2_RODC_FLAGS (NETLOGON_NEG_AUTH2_ADS_FLAGS \| NETLOGON_NEG_RODC_PASSTHROUGH)~~
72

vendor/current/libcli/auth/msrpc_parse.c

-              r740
+              r988
                         if (!ret) {
                                 va_end(ap);
                                 return map_nt_error_from_unix(errno);
+                                return map_nt_error_from_unix_common(errno);
+                        }
                         pointers[i].length = n;
 …
                         if (!ret) {
                                 va_end(ap);
                                 return map_nt_error_from_unix(errno);
+                                return map_nt_error_from_unix_common(errno);
+                        }
                         pointers[i].length = n;
 …
                         if (!ret) {
                                 va_end(ap);
                                 return map_nt_error_from_unix(errno);
+                                return map_nt_error_from_unix_common(errno);
+                        }
                         pointers[i].length = n;
 …
                         n = pointers[i].length;
                         SSVAL(blob->data, data_ofs, n); data_ofs += 2;
+                        if (n >= 0) {
+                                memcpy(blob->data+data_ofs, pointers[i].data, n);
+                        }
+                        memcpy(blob->data+data_ofs, pointers[i].data, n);
                         data_ofs += n;
                         break;
 …
                                         if (!convert_string_talloc(mem_ctx, CH_UTF16, CH_UNIX,
                                                                    blob->data + ptr, len1,
                                                                    ps, &pull_len, false)) {
+                                                                   ps, &pull_len)) {
                                                 ret = false;
                                                 goto cleanup;
 …
                                         if (!convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX,
                                                                    blob->data + ptr, len1,
                                                                    ps, &pull_len, false)) {
+                                                                   ps, &pull_len)) {
                                                 ret = false;
                                                 goto cleanup;

vendor/current/libcli/auth/ntlm_check.c

-              r746
+              r988
                 char *unix_pw = NULL;
                 bool lm_ok;
+                size_t converted_size = 0;
                 DEBUG(4,("ntlm_password_check: checking plaintext passwords for user %s\n",
 …
                     (convert_string_talloc(mem_ctx, CH_DOS, CH_UNIX,
                                           lm_response->data, lm_response->length,
                                            (void *)&unix_pw, NULL, false))) {
+                                           (void *)&unix_pw, &converted_size))) {
                         if (E_deshash(unix_pw, client_lm.hash)) {
                                 lm_ok = true;
 …
                                  &tmp_sess_key)) {
                 if (nt_response->length > 24) {
                         /* If NTLMv2 authentication has preceeded us
+                        /* If NTLMv2 authentication has preceded us
                          * (even if it failed), then use the session
                          * key from that.  See the RPC-SAMLOGON
 …
                                  &tmp_sess_key)) {
                 if (nt_response->length > 24) {
                         /* If NTLMv2 authentication has preceeded us
+                        /* If NTLMv2 authentication has preceded us
                          * (even if it failed), then use the session
                          * key from that.  See the RPC-SAMLOGON
 …
                                  &tmp_sess_key)) {
                 if (nt_response->length > 24) {
                         /* If NTLMv2 authentication has preceeded us
+                        /* If NTLMv2 authentication has preceded us
                          * (even if it failed), then use the session
                          * key from that.  See the RPC-SAMLOGON

vendor/current/libcli/auth/proto.h

-              r919
+              r988
 void netlogon_creds_des_decrypt(struct netlogon_creds_CredentialState *creds, struct samr_Password *pass);
 void netlogon_creds_arcfour_crypt(struct netlogon_creds_CredentialState *creds, uint8_t *data, size_t len);
+void netlogon_creds_aes_encrypt(struct netlogon_creds_CredentialState *creds, uint8_t *data, size_t len);
+void netlogon_creds_aes_decrypt(struct netlogon_creds_CredentialState *creds, uint8_t *data, size_t len);
 /*****************************************************************
 …
                                                                   const char *client_account,
                                                                   const char *client_computer_name,
+                                                                  uint16_t secure_channel_type,
                                                                   const struct netr_Credential *client_challenge,
                                                                   const struct netr_Credential *server_challenge,
 …
                                                                   const struct netr_Credential *server_challenge,
                                                                   const struct samr_Password *machine_password,
                                                                   struct netr_Credential *credentials_in,
+                                                                  const struct netr_Credential *credentials_in,
                                                                   struct netr_Credential *credentials_out,
                                                                   uint32_t negotiate_flags);
 NTSTATUS netlogon_creds_server_step_check(struct netlogon_creds_CredentialState *creds,
                                  struct netr_Authenticator *received_authenticator,
+                                 const struct netr_Authenticator *received_authenticator,
                                  struct netr_Authenticator *return_authenticator) ;
+void netlogon_creds_decrypt_samlogon(struct netlogon_creds_CredentialState *creds,
+                            uint16_t validation_level,
+                            union netr_Validation *validation) ;
+void netlogon_creds_decrypt_samlogon_validation(struct netlogon_creds_CredentialState *creds,
+                                                uint16_t validation_level,
+                                                union netr_Validation *validation);
+void netlogon_creds_encrypt_samlogon_validation(struct netlogon_creds_CredentialState *creds,
+                                                uint16_t validation_level,
+                                                union netr_Validation *validation);
+void netlogon_creds_decrypt_samlogon_logon(struct netlogon_creds_CredentialState *creds,
+                                           enum netr_LogonInfoClass level,
+                                           union netr_LogonLevel *logon);
+void netlogon_creds_encrypt_samlogon_logon(struct netlogon_creds_CredentialState *creds,
+                                           enum netr_LogonInfoClass level,
+                                           union netr_LogonLevel *logon);
+union netr_LogonLevel *netlogon_creds_shallow_copy_logon(TALLOC_CTX *mem_ctx,
+                                        enum netr_LogonInfoClass level,
+                                        const union netr_LogonLevel *in);
 /* The following definitions come from /home/jeremy/src/samba/git/master/source3/../source4/../libcli/auth/session.c  */
 …
                   uint8_t kr_buf[16]);
 void SMBOWFencrypt(const uint8_t passwd[16], const uint8_t *c8, uint8_t p24[24]);
 void SMBNTencrypt_hash(const uint8_t nt_hash[16], uint8_t *c8, uint8_t *p24);
 void SMBNTencrypt(const char *passwd, uint8_t *c8, uint8_t *p24);
+void SMBNTencrypt_hash(const uint8_t nt_hash[16], const uint8_t *c8, uint8_t *p24);
+void SMBNTencrypt(const char *passwd, const uint8_t *c8, uint8_t *p24);
 void SMBOWFencrypt_ntv2(const uint8_t kr[16],
                         const DATA_BLOB *srv_chal,
 …
                            const char *user, const char *domain, const uint8_t nt_hash[16],
                            const DATA_BLOB *server_chal,
+                           const NTTIME *server_timestamp,
                            const DATA_BLOB *names_blob,
                            DATA_BLOB *lm_response, DATA_BLOB *nt_response,
 …
 bool extract_pw_from_buffer(TALLOC_CTX *mem_ctx,
                             uint8_t in_buffer[516], DATA_BLOB *new_pass);
+struct wkssvc_PasswordBuffer;
 void encode_wkssvc_join_password_buffer(TALLOC_CTX *mem_ctx,
                                         const char *pwd,

vendor/current/libcli/auth/schannel.h

-              r414
+              r988
 #include "libcli/auth/libcli_auth.h"
 #include "libcli/auth/schannel_state.h"
-enum schannel_position {
-        SCHANNEL_STATE_START = 0,
-        SCHANNEL_STATE_UPDATE_1
-};
-struct schannel_state {
-        enum schannel_position state;
-        uint32_t seq_num;
-        bool initiator;
-        struct netlogon_creds_CredentialState *creds;
-};
 #include "libcli/auth/schannel_proto.h"

vendor/current/libcli/auth/schannel_proto.h

-              r740
+              r988
 struct schannel_state;
+struct tdb_wrap *open_schannel_session_store(TALLOC_CTX *mem_ctx,
+                                             const char *private_dir);
+NTSTATUS netsec_incoming_packet(struct schannel_state *state,
+                                TALLOC_CTX *mem_ctx,
+                                bool do_unseal,
+                                uint8_t *data, size_t length,
+                                const DATA_BLOB *sig);
+uint32_t netsec_outgoing_sig_size(struct schannel_state *state);
+NTSTATUS netsec_outgoing_packet(struct schannel_state *state,
+                                TALLOC_CTX *mem_ctx,
+                                bool do_seal,
+                                uint8_t *data, size_t length,
+                                DATA_BLOB *sig);
+struct db_context *open_schannel_session_store(TALLOC_CTX *mem_ctx,
+                                               struct loadparm_context *lp_ctx);
 #endif

vendor/current/libcli/auth/schannel_state.h

-              r740
+              r988
 NTSTATUS schannel_get_creds_state(TALLOC_CTX *mem_ctx,
                                   const char *db_priv_dir,
+                                  struct loadparm_context *lp_ctx,
                                   const char *computer_name,
                                   struct netlogon_creds_CredentialState **creds);
 NTSTATUS schannel_save_creds_state(TALLOC_CTX *mem_ctx,
                                    const char *db_priv_dir,
+                                   struct loadparm_context *lp_ctx,
                                    struct netlogon_creds_CredentialState *creds);
 NTSTATUS schannel_check_creds_state(TALLOC_CTX *mem_ctx,
                                     const char *db_priv_dir,
+                                    struct loadparm_context *lp_ctx,
                                     const char *computer_name,
                                     struct netr_Authenticator *received_authenticator,

vendor/current/libcli/auth/schannel_state_tdb.c

-              r914
+              r988
 #include "includes.h"
 #include "system/filesys.h"
 #include <tdb.h>
+#include "../lib/tdb/include/tdb.h"
 #include "../lib/util/util_tdb.h"
+#include "../lib/param/param.h"
 #include "../libcli/auth/schannel.h"
 #include "../librpc/gen_ndr/ndr_schannel.h"
 #include "lib/util/tdb_wrap.h"
+#include "lib/dbwrap/dbwrap.h"
 #define SECRETS_SCHANNEL_STATE "SECRETS/SCHANNEL"
 …
 *******************************************************************************/
 struct tdb_wrap *open_schannel_session_store(TALLOC_CTX *mem_ctx,
                                              const char *private_dir)
+{
         struct tdb_wrap *tdb_sc = NULL;
         char *fname = talloc_asprintf(mem_ctx, "%s/schannel_store.tdb", private_dir);
+struct db_context *open_schannel_session_store(TALLOC_CTX *mem_ctx,
+                                               struct loadparm_context *lp_ctx)
+{
+        struct db_context *db_sc = NULL;
+        char *fname = lpcfg_private_db_path(mem_ctx, lp_ctx, "schannel_store");
         if (!fname) {
 …
+        }
+        tdb_sc = tdb_wrap_open(mem_ctx, fname, 0, TDB_CLEAR_IF_FIRST|TDB_NOSYNC, O_RDWR|O_CREAT, 0600);
+        if (!tdb_sc) {
+        db_sc = dbwrap_local_open(mem_ctx, lp_ctx, fname, 0,
+                                  TDB_CLEAR_IF_FIRST|TDB_NOSYNC, O_RDWR|O_CREAT,
+, DBWRAP_LOCK_ORDER_NONE,
+                                  DBWRAP_FLAG_NONE);
+        if (!db_sc) {
                 DEBUG(0,("open_schannel_session_store: Failed to open %s - %s\n",
                          fname, strerror(errno)));
 …
         TALLOC_FREE(fname);
         return tdb_sc;
+        return db_sc;
+}
 …
 static
 NTSTATUS schannel_store_session_key_tdb(struct tdb_wrap *tdb_sc,
+NTSTATUS schannel_store_session_key_tdb(struct db_context *db_sc,
                                         TALLOC_CTX *mem_ctx,
                                         struct netlogon_creds_CredentialState *creds)
 …
         DATA_BLOB blob;
         TDB_DATA value;
-        int ret;
         char *keystr;
         char *name_upper;
+        NTSTATUS status;
+        if (strlen(creds->computer_name) > 15) {
+                /*
+                 * We may want to check for a completely
+                 * valid netbios name.
+                 */
+                return STATUS_BUFFER_OVERFLOW;
+        }
         name_upper = strupper_talloc(mem_ctx, creds->computer_name);
 …
         value.dsize = blob.length;
         ret = tdb_store_bystring(tdb_sc->tdb, keystr, value, TDB_REPLACE);
         if (ret != TDB_SUCCESS) {
+        status = dbwrap_store_bystring(db_sc, keystr, value, TDB_REPLACE);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("Unable to add %s to session key db - %s\n",
                          keystr, tdb_errorstr(tdb_sc->tdb)));
+                         keystr, nt_errstr(status)));
                 talloc_free(keystr);
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
+                return status;
+        }
 …
 static
 NTSTATUS schannel_fetch_session_key_tdb(struct tdb_wrap *tdb_sc,
+NTSTATUS schannel_fetch_session_key_tdb(struct db_context *db_sc,
                                         TALLOC_CTX *mem_ctx,
                                         const char *computer_name,
 …
+        }
         value = tdb_fetch_bystring(tdb_sc->tdb, keystr);
         if (!value.dptr) {
+        status = dbwrap_fetch_bystring(db_sc, keystr, keystr, &value);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(10,("schannel_fetch_session_key_tdb: Failed to find entry with key %s\n",
                         keystr ));
-                status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
                 goto done;
+        }
 …
         talloc_free(keystr);
-        SAFE_FREE(value.dptr);
         if (!NT_STATUS_IS_OK(status)) {
 …
 NTSTATUS schannel_get_creds_state(TALLOC_CTX *mem_ctx,
                                   const char *db_priv_dir,
+                                  struct loadparm_context *lp_ctx,
                                   const char *computer_name,
                                   struct netlogon_creds_CredentialState **_creds)
+{
         TALLOC_CTX *tmpctx;
         struct tdb_wrap *tdb_sc;
+        struct db_context *db_sc;
         struct netlogon_creds_CredentialState *creds;
         NTSTATUS status;
 …
+        }
         tdb_sc = open_schannel_session_store(tmpctx, db_priv_dir);
         if (!tdb_sc) {
+        db_sc = open_schannel_session_store(tmpctx, lp_ctx);
+        if (!db_sc) {
                 return NT_STATUS_ACCESS_DENIED;
+        }
         status = schannel_fetch_session_key_tdb(tdb_sc, tmpctx,
+        status = schannel_fetch_session_key_tdb(db_sc, tmpctx,
                                                 computer_name, &creds);
         if (NT_STATUS_IS_OK(status)) {
 …
 NTSTATUS schannel_save_creds_state(TALLOC_CTX *mem_ctx,
                                    const char *db_priv_dir,
+                                   struct loadparm_context *lp_ctx,
                                    struct netlogon_creds_CredentialState *creds)
+{
         TALLOC_CTX *tmpctx;
         struct tdb_wrap *tdb_sc;
+        struct db_context *db_sc;
         NTSTATUS status;
 …
+        }
         tdb_sc = open_schannel_session_store(tmpctx, db_priv_dir);
         if (!tdb_sc) {
+        db_sc = open_schannel_session_store(tmpctx, lp_ctx);
+        if (!db_sc) {
                 return NT_STATUS_ACCESS_DENIED;
+        }
         status = schannel_store_session_key_tdb(tdb_sc, tmpctx, creds);
+        status = schannel_store_session_key_tdb(db_sc, tmpctx, creds);
         talloc_free(tmpctx);
 …
 NTSTATUS schannel_check_creds_state(TALLOC_CTX *mem_ctx,
                                     const char *db_priv_dir,
+                                    struct loadparm_context *lp_ctx,
                                     const char *computer_name,
                                     struct netr_Authenticator *received_authenticator,
 …
+{
         TALLOC_CTX *tmpctx;
         struct tdb_wrap *tdb_sc;
+        struct db_context *db_sc;
         struct netlogon_creds_CredentialState *creds;
         NTSTATUS status;
+        int ret;
+        char *name_upper = NULL;
+        char *keystr = NULL;
+        struct db_record *record;
+        TDB_DATA key;
         if (creds_out != NULL) {
 …
+        }
+        tdb_sc = open_schannel_session_store(tmpctx, db_priv_dir);
+        if (!tdb_sc) {
+        name_upper = strupper_talloc(tmpctx, computer_name);
+        if (!name_upper) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        keystr = talloc_asprintf(tmpctx, "%s/%s",
+                                 SECRETS_SCHANNEL_STATE, name_upper);
+        if (!keystr) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+        key = string_term_tdb_data(keystr);
+        db_sc = open_schannel_session_store(tmpctx, lp_ctx);
+        if (!db_sc) {
                 status = NT_STATUS_ACCESS_DENIED;
                 goto done;
+        }
         ret = tdb_transaction_start(tdb_sc->tdb);
         if (ret != 0) {
+        record = dbwrap_fetch_locked(db_sc, tmpctx, key);
+        if (!record) {
                 status = NT_STATUS_INTERNAL_DB_CORRUPTION;
                 goto done;
 …
          * update the structure */
         status = schannel_fetch_session_key_tdb(tdb_sc, tmpctx,
+        status = schannel_fetch_session_key_tdb(db_sc, tmpctx,
                                                 computer_name, &creds);
         if (!NT_STATUS_IS_OK(status)) {
-                tdb_transaction_cancel(tdb_sc->tdb);
                 goto done;
+        }
 …
                                                   return_authenticator);
         if (!NT_STATUS_IS_OK(status)) {
+                tdb_transaction_cancel(tdb_sc->tdb);
+                goto done;
+        }
+        status = schannel_store_session_key_tdb(tdb_sc, tmpctx, creds);
+        if (!NT_STATUS_IS_OK(status)) {
+                tdb_transaction_cancel(tdb_sc->tdb);
+                goto done;
+        }
+        tdb_transaction_commit(tdb_sc->tdb);
+                goto done;
+        }
+        status = schannel_store_session_key_tdb(db_sc, tmpctx, creds);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
         if (creds_out) {

vendor/current/libcli/auth/smbencrypt.c

-              r919
+              r988
 bool E_deshash(const char *passwd, uint8_t p16[16])
+{
+        bool ret = true;
+        char dospwd[256];
+        bool ret;
+        uint8_t dospwd[14];
+        TALLOC_CTX *frame = talloc_stackframe();
+        size_t converted_size;
+        char *tmpbuf;
         ZERO_STRUCT(dospwd);
+        /* Password must be converted to DOS charset - null terminated, uppercase. */
+        push_string(dospwd, passwd, sizeof(dospwd), STR_ASCII|STR_UPPER|STR_TERMINATE);
+        /* Only the first 14 chars are considered, password need not be null terminated. */
+        tmpbuf = strupper_talloc(frame, passwd);
+        if (tmpbuf == NULL) {
+                /* Too many callers don't check this result, we need to fill in the buffer with something */
+                strlcpy((char *)dospwd, passwd ? passwd : "", sizeof(dospwd));
+                E_P16(dospwd, p16);
+                talloc_free(frame);
+                return false;
+        }
+        ZERO_STRUCT(dospwd);
+        ret = convert_string_error(CH_UNIX, CH_DOS, tmpbuf, strlen(tmpbuf), dospwd, sizeof(dospwd), &converted_size);
+        talloc_free(frame);
+        /* Only the first 14 chars are considered, password need not
+         * be null terminated.  We do this in the error and success
+         * case to avoid returning a fixed 'password' buffer, but
+         * callers should not use it when E_deshash returns false */
         E_P16((const uint8_t *)dospwd, p16);
-        if (strlen(dospwd) > 14) {
-                ret = false;
+        }
         ZERO_STRUCT(dospwd);
 …
 /* Does the des encryption. */
 void SMBNTencrypt_hash(const uint8_t nt_hash[16], uint8_t *c8, uint8_t *p24)
+void SMBNTencrypt_hash(const uint8_t nt_hash[16], const uint8_t *c8, uint8_t *p24)
+{
         uint8_t p21[21];
 …
 /* Does the NT MD4 hash then des encryption. Plaintext version of the above. */
 void SMBNTencrypt(const char *passwd, uint8_t *c8, uint8_t *p24)
+void SMBNTencrypt(const char *passwd, const uint8_t *c8, uint8_t *p24)
+{
         uint8_t nt_hash[16];
 …
+}
+static DATA_BLOB NTLMv2_generate_client_data(TALLOC_CTX *mem_ctx, const DATA_BLOB *names_blob)
+static DATA_BLOB NTLMv2_generate_client_data(TALLOC_CTX *mem_ctx,
+                                             NTTIME nttime,
+                                             const DATA_BLOB *names_blob)
+{
         uint8_t client_chal[8];
         DATA_BLOB response = data_blob(NULL, 0);
         uint8_t long_date[8];
-        NTTIME nttime;
-        unix_to_nt_time(&nttime, time(NULL));
         generate_random_buffer(client_chal, sizeof(client_chal));
 …
                                           const uint8_t ntlm_v2_hash[16],
                                           const DATA_BLOB *server_chal,
+                                          NTTIME nttime,
                                           const DATA_BLOB *names_blob)
+{
 …
         /* generate some data to pass into the response function - including
            the hostname and domain name of the server */
         ntlmv2_client_data = NTLMv2_generate_client_data(mem_ctx, names_blob);
+        ntlmv2_client_data = NTLMv2_generate_client_data(mem_ctx, nttime, names_blob);
         /* Given that data, and the challenge from the server, generate a response */
 …
                            const char *user, const char *domain, const uint8_t nt_hash[16],
                            const DATA_BLOB *server_chal,
+                           const NTTIME *server_timestamp,
                            const DATA_BLOB *names_blob,
                            DATA_BLOB *lm_response, DATA_BLOB *nt_response,
 …
         if (nt_response) {
+                const NTTIME *nttime = server_timestamp;
+                NTTIME _now = 0;
+                if (nttime == NULL) {
+                        struct timeval tv_now = timeval_current();
+                        _now = timeval_to_nttime(&tv_now);
+                        nttime = &_now;
+                }
                 *nt_response = NTLMv2_generate_response(mem_ctx,
+                                                        ntlm_v2_hash, server_chal,
+                                                        ntlm_v2_hash,
+                                                        server_chal,
+                                                        *nttime,
                                                         names_blob);
                 if (user_session_key) {
 …
         if (lm_response) {
+                *lm_response = LMv2_generate_response(mem_ctx,
+                                                      ntlm_v2_hash, server_chal);
+                if (server_timestamp != NULL) {
+                        *lm_response = data_blob_talloc_zero(mem_ctx, 24);
+                } else {
+                        *lm_response = LMv2_generate_response(mem_ctx,
+                                                              ntlm_v2_hash,
+                                                              server_chal);
+                }
                 if (lm_session_key) {
                         *lm_session_key = data_blob_talloc(mem_ctx, NULL, 16);
 …
         return SMBNTLMv2encrypt_hash(mem_ctx,
+                                     user, domain, nt_hash, server_chal, names_blob,
+                                     user, domain, nt_hash,
+                                     server_chal, NULL, names_blob,
                                      lm_response, nt_response, lm_session_key, user_session_key);
+}
 …
+                }
-#ifdef SAMBA4_INTERNAL_HEIMDAL /* smbtorture4 for make test */
                 cmp = strcasecmp_m(a, v);
-#else /* smbd */
-                cmp = StrCaseCmp(a, v);
-#endif
                 if (cmp != 0) {
                         DEBUG(2,("%s: NTLMv2_RESPONSE with "
 …
                 v = av_nb_dn->Value.AvNbDomainName;
-#ifdef SAMBA4_INTERNAL_HEIMDAL /* smbtorture4 for make test */
                 cmp = strcasecmp_m(workgroup, v);
-#else /* smbd */
-                cmp = StrCaseCmp(workgroup, v);
-#endif
                 if (cmp != 0) {
                         DEBUG(2,("%s: NTLMv2_RESPONSE with "
 …
                                    byte_len,
                                    (void *)pp_new_pwrd,
+                                   new_pw_len,
+                                   false)) {
+                                   new_pw_len)) {
                 DEBUG(0, ("decode_pw_buffer: failed to convert incoming password\n"));
                 return false;
 …
         if (!pwd_buf) {
                 return WERR_BAD_PASSWORD;
+                return WERR_INVALID_PASSWORD;
+        }
         if (session_key->length != 16) {
                 DEBUG(10,("invalid session key\n"));
                 return WERR_BAD_PASSWORD;
+                return WERR_INVALID_PASSWORD;
+        }
 …
         if (!decode_pw_buffer(mem_ctx, buffer, pwd, &pwd_len, CH_UTF16)) {
                 data_blob_free(&confounded_session_key);
                 return WERR_BAD_PASSWORD;
+                return WERR_INVALID_PASSWORD;
+        }

vendor/current/libcli/auth/spnego.h

-              r740
+              r988
         SPNEGO_ACCEPT_INCOMPLETE = 1,
         SPNEGO_REJECT = 2,
+        SPNEGO_NONE_RESULT = 3
+        SPNEGO_REQUEST_MIC = 3,
+        /*
+         * The max value is 0xff (255) on the wire
+         */
+        SPNEGO_NONE_RESULT = 256
 };
 struct spnego_negTokenInit {
         const char **mechTypes;
+        const char * const *mechTypes;
         DATA_BLOB reqFlags;
         uint8_t reqFlagsPadding;
 …
 struct spnego_negTokenTarg {
         uint8_t negResult;
+        enum spnego_negResult negResult;
         const char *supportedMech;
         DATA_BLOB responseToken;

vendor/current/libcli/auth/spnego_parse.c

-              r740
+              r988
         ZERO_STRUCTP(token);
         asn1_start_tag(asn1, ASN1_CONTEXT(0));
         asn1_start_tag(asn1, ASN1_SEQUENCE(0));
         while (!asn1->has_error && 0 < asn1_tag_remaining(asn1)) {
+        if (!asn1_start_tag(asn1, ASN1_CONTEXT(0))) return false;
+        if (!asn1_start_tag(asn1, ASN1_SEQUENCE(0))) return false;
+        while (!asn1_has_error(asn1) && 0 < asn1_tag_remaining(asn1)) {
                 int i;
                 uint8_t context;
                 if (!asn1_peek_uint8(asn1, &context)) {
                         asn1->has_error = true;
+                        asn1_set_error(asn1);
                         break;
+                }
 …
                 switch (context) {
                 /* Read mechTypes */
+                case ASN1_CONTEXT(0):
+                        asn1_start_tag(asn1, ASN1_CONTEXT(0));
+                        asn1_start_tag(asn1, ASN1_SEQUENCE(0));
+                        token->mechTypes = talloc(NULL, const char *);
+                        for (i = 0; !asn1->has_error &&
+                case ASN1_CONTEXT(0): {
+                        const char **mechTypes;
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(0))) return false;
+                        if (!asn1_start_tag(asn1, ASN1_SEQUENCE(0))) return false;
+                        mechTypes = talloc(mem_ctx, const char *);
+                        if (mechTypes == NULL) {
+                                asn1_set_error(asn1);
+                                return false;
+                        }
+                        for (i = 0; !asn1_has_error(asn1) &&
 < asn1_tag_remaining(asn1); i++) {
                                 char *oid;
+                                token->mechTypes = talloc_realloc(NULL,
+                                                                  token->mechTypes,
+                                                                  const char *, i+2);
+                                asn1_read_OID(asn1, token->mechTypes, &oid);
+                                token->mechTypes[i] = oid;
+                        }
+                        token->mechTypes[i] = NULL;
+                                const char **p;
+                                p = talloc_realloc(mem_ctx,
+                                                   mechTypes,
+                                                   const char *, i+2);
+                                if (p == NULL) {
+                                        talloc_free(mechTypes);
+                                        asn1_set_error(asn1);
+                                        return false;
+                                }
+                                mechTypes = p;
+                                if (!asn1_read_OID(asn1, mechTypes, &oid)) return false;
+                                mechTypes[i] = oid;
+                        }
+                        mechTypes[i] = NULL;
+                        token->mechTypes = mechTypes;
                         asn1_end_tag(asn1);
                         asn1_end_tag(asn1);
                         break;
+                }
                 /* Read reqFlags */
                 case ASN1_CONTEXT(1):
                         asn1_start_tag(asn1, ASN1_CONTEXT(1));
                         asn1_read_BitString(asn1, mem_ctx, &token->reqFlags,
                                             &token->reqFlagsPadding);
                         asn1_end_tag(asn1);
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(1))) return false;
+                        if (!asn1_read_BitString(asn1, mem_ctx, &token->reqFlags,
+                                            &token->reqFlagsPadding)) return false;
+                        if (!asn1_end_tag(asn1)) return false;
                         break;
                 /* Read mechToken */
                 case ASN1_CONTEXT(2):
                         asn1_start_tag(asn1, ASN1_CONTEXT(2));
                         asn1_read_OctetString(asn1, mem_ctx, &token->mechToken);
                         asn1_end_tag(asn1);
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(2))) return false;
+                        if (!asn1_read_OctetString(asn1, mem_ctx, &token->mechToken)) return false;
+                        if (!asn1_end_tag(asn1)) return false;
                         break;
                 /* Read mecListMIC */
 …
+                {
                         uint8_t type_peek;
                         asn1_start_tag(asn1, ASN1_CONTEXT(3));
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(3))) return false;
                         if (!asn1_peek_uint8(asn1, &type_peek)) {
                                 asn1->has_error = true;
+                                asn1_set_error(asn1);
                                 break;
+                        }
                         if (type_peek == ASN1_OCTET_STRING) {
                                 asn1_read_OctetString(asn1, mem_ctx,
                                                       &token->mechListMIC);
+                                if (!asn1_read_OctetString(asn1, mem_ctx,
+                                                      &token->mechListMIC)) return false;
                         } else {
                                 /* RFC 2478 says we have an Octet String here,
                                    but W2k sends something different... */
                                 char *mechListMIC;
                                 asn1_start_tag(asn1, ASN1_SEQUENCE(0));
                                 asn1_start_tag(asn1, ASN1_CONTEXT(0));
                                 asn1_read_GeneralString(asn1, mem_ctx, &mechListMIC);
                                 asn1_end_tag(asn1);
                                 asn1_end_tag(asn1);
+                                if (!asn1_start_tag(asn1, ASN1_SEQUENCE(0))) return false;
+                                if (!asn1_start_tag(asn1, ASN1_CONTEXT(0))) return false;
+                                if (!asn1_read_GeneralString(asn1, mem_ctx, &mechListMIC)) return false;
+                                if (!asn1_end_tag(asn1)) return false;
+                                if (!asn1_end_tag(asn1)) return false;
                                 token->targetPrincipal = mechListMIC;
+                        }
                         asn1_end_tag(asn1);
+                        if (!asn1_end_tag(asn1)) return false;
                         break;
+                }
                 default:
                         asn1->has_error = true;
                         break;
+                }
+        }
         asn1_end_tag(asn1);
         asn1_end_tag(asn1);
         return !asn1->has_error;
+                        asn1_set_error(asn1);
+                        break;
+                }
+        }
+        if (!asn1_end_tag(asn1)) return false;
+        if (!asn1_end_tag(asn1)) return false;
+        return !asn1_has_error(asn1);
+}
 static bool write_negTokenInit(struct asn1_data *asn1, struct spnego_negTokenInit *token)
+{
         asn1_push_tag(asn1, ASN1_CONTEXT(0));
         asn1_push_tag(asn1, ASN1_SEQUENCE(0));
+        if (!asn1_push_tag(asn1, ASN1_CONTEXT(0))) return false;
+        if (!asn1_push_tag(asn1, ASN1_SEQUENCE(0))) return false;
         /* Write mechTypes */
 …
                 int i;
                 asn1_push_tag(asn1, ASN1_CONTEXT(0));
                 asn1_push_tag(asn1, ASN1_SEQUENCE(0));
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(0))) return false;
+                if (!asn1_push_tag(asn1, ASN1_SEQUENCE(0))) return false;
                 for (i = 0; token->mechTypes[i]; i++) {
                         asn1_write_OID(asn1, token->mechTypes[i]);
+                }
                 asn1_pop_tag(asn1);
                 asn1_pop_tag(asn1);
+                        if (!asn1_write_OID(asn1, token->mechTypes[i])) return false;
+                }
+                if (!asn1_pop_tag(asn1)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
         /* write reqFlags */
         if (token->reqFlags.length > 0) {
                 asn1_push_tag(asn1, ASN1_CONTEXT(1));
                 asn1_write_BitString(asn1, token->reqFlags.data,
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(1))) return false;
+                if (!asn1_write_BitString(asn1, token->reqFlags.data,
                                      token->reqFlags.length,
                                      token->reqFlagsPadding);
                 asn1_pop_tag(asn1);
+                                     token->reqFlagsPadding)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
         /* write mechToken */
         if (token->mechToken.data) {
                 asn1_push_tag(asn1, ASN1_CONTEXT(2));
                 asn1_write_OctetString(asn1, token->mechToken.data,
                                        token->mechToken.length);
                 asn1_pop_tag(asn1);
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(2))) return false;
+                if (!asn1_write_OctetString(asn1, token->mechToken.data,
+                                       token->mechToken.length)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
         /* write mechListMIC */
         if (token->mechListMIC.data) {
                 asn1_push_tag(asn1, ASN1_CONTEXT(3));
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(3))) return false;
 #if 0
                 /* This is what RFC 2478 says ... */
 …
                 /* ... but unfortunately this is what Windows
                    sends/expects */
                 asn1_push_tag(asn1, ASN1_SEQUENCE(0));
                 asn1_push_tag(asn1, ASN1_CONTEXT(0));
                 asn1_push_tag(asn1, ASN1_GENERAL_STRING);
                 asn1_write(asn1, token->mechListMIC.data,
                            token->mechListMIC.length);
                 asn1_pop_tag(asn1);
                 asn1_pop_tag(asn1);
                 asn1_pop_tag(asn1);
+                if (!asn1_push_tag(asn1, ASN1_SEQUENCE(0))) return false;
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(0))) return false;
+                if (!asn1_push_tag(asn1, ASN1_GENERAL_STRING)) return false;
+                if (!asn1_write(asn1, token->mechListMIC.data,
+                           token->mechListMIC.length)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
 #endif
                 asn1_pop_tag(asn1);
+        }
         asn1_pop_tag(asn1);
         asn1_pop_tag(asn1);
         return !asn1->has_error;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
+        if (!asn1_pop_tag(asn1)) return false;
+        if (!asn1_pop_tag(asn1)) return false;
+        return !asn1_has_error(asn1);
+}
 …
         ZERO_STRUCTP(token);
         asn1_start_tag(asn1, ASN1_CONTEXT(1));
         asn1_start_tag(asn1, ASN1_SEQUENCE(0));
         while (!asn1->has_error && 0 < asn1_tag_remaining(asn1)) {
+        if (!asn1_start_tag(asn1, ASN1_CONTEXT(1))) return false;
+        if (!asn1_start_tag(asn1, ASN1_SEQUENCE(0))) return false;
+        while (!asn1_has_error(asn1) && 0 < asn1_tag_remaining(asn1)) {
                 uint8_t context;
+                uint8_t neg_result;
                 char *oid;
                 if (!asn1_peek_uint8(asn1, &context)) {
                         asn1->has_error = true;
+                        asn1_set_error(asn1);
                         break;
+                }
 …
                 switch (context) {
                 case ASN1_CONTEXT(0):
+                        asn1_start_tag(asn1, ASN1_CONTEXT(0));
+                        asn1_start_tag(asn1, ASN1_ENUMERATED);
+                        asn1_read_uint8(asn1, &token->negResult);
+                        asn1_end_tag(asn1);
+                        asn1_end_tag(asn1);
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(0))) return false;
+                        if (!asn1_start_tag(asn1, ASN1_ENUMERATED)) return false;
+                        if (!asn1_read_uint8(asn1, &neg_result)) return false;
+                        token->negResult = neg_result;
+                        if (!asn1_end_tag(asn1)) return false;
+                        if (!asn1_end_tag(asn1)) return false;
                         break;
                 case ASN1_CONTEXT(1):
                         asn1_start_tag(asn1, ASN1_CONTEXT(1));
                         asn1_read_OID(asn1, mem_ctx, &oid);
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(1))) return false;
+                        if (!asn1_read_OID(asn1, mem_ctx, &oid)) return false;
                         token->supportedMech = oid;
                         asn1_end_tag(asn1);
+                        if (!asn1_end_tag(asn1)) return false;
                         break;
                 case ASN1_CONTEXT(2):
                         asn1_start_tag(asn1, ASN1_CONTEXT(2));
                         asn1_read_OctetString(asn1, mem_ctx, &token->responseToken);
                         asn1_end_tag(asn1);
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(2))) return false;
+                        if (!asn1_read_OctetString(asn1, mem_ctx, &token->responseToken)) return false;
+                        if (!asn1_end_tag(asn1)) return false;
                         break;
                 case ASN1_CONTEXT(3):
                         asn1_start_tag(asn1, ASN1_CONTEXT(3));
                         asn1_read_OctetString(asn1, mem_ctx, &token->mechListMIC);
                         asn1_end_tag(asn1);
+                        if (!asn1_start_tag(asn1, ASN1_CONTEXT(3))) return false;
+                        if (!asn1_read_OctetString(asn1, mem_ctx, &token->mechListMIC)) return false;
+                        if (!asn1_end_tag(asn1)) return false;
                         break;
                 default:
                         asn1->has_error = true;
                         break;
+                }
+        }
         asn1_end_tag(asn1);
         asn1_end_tag(asn1);
         return !asn1->has_error;
+                        asn1_set_error(asn1);
+                        break;
+                }
+        }
+        if (!asn1_end_tag(asn1)) return false;
+        if (!asn1_end_tag(asn1)) return false;
+        return !asn1_has_error(asn1);
+}
 static bool write_negTokenTarg(struct asn1_data *asn1, struct spnego_negTokenTarg *token)
+{
         asn1_push_tag(asn1, ASN1_CONTEXT(1));
         asn1_push_tag(asn1, ASN1_SEQUENCE(0));
+        if (!asn1_push_tag(asn1, ASN1_CONTEXT(1))) return false;
+        if (!asn1_push_tag(asn1, ASN1_SEQUENCE(0))) return false;
         if (token->negResult != SPNEGO_NONE_RESULT) {
                 asn1_push_tag(asn1, ASN1_CONTEXT(0));
                 asn1_write_enumerated(asn1, token->negResult);
                 asn1_pop_tag(asn1);
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(0))) return false;
+                if (!asn1_write_enumerated(asn1, token->negResult)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
         if (token->supportedMech) {
                 asn1_push_tag(asn1, ASN1_CONTEXT(1));
                 asn1_write_OID(asn1, token->supportedMech);
                 asn1_pop_tag(asn1);
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(1))) return false;
+                if (!asn1_write_OID(asn1, token->supportedMech)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
         if (token->responseToken.data) {
                 asn1_push_tag(asn1, ASN1_CONTEXT(2));
                 asn1_write_OctetString(asn1, token->responseToken.data,
                                        token->responseToken.length);
                 asn1_pop_tag(asn1);
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(2))) return false;
+                if (!asn1_write_OctetString(asn1, token->responseToken.data,
+                                       token->responseToken.length)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
         if (token->mechListMIC.data) {
                 asn1_push_tag(asn1, ASN1_CONTEXT(3));
                 asn1_write_OctetString(asn1, token->mechListMIC.data,
                                       token->mechListMIC.length);
                 asn1_pop_tag(asn1);
+        }
         asn1_pop_tag(asn1);
         asn1_pop_tag(asn1);
         return !asn1->has_error;
+                if (!asn1_push_tag(asn1, ASN1_CONTEXT(3))) return false;
+                if (!asn1_write_OctetString(asn1, token->mechListMIC.data,
+                                      token->mechListMIC.length)) return false;
+                if (!asn1_pop_tag(asn1)) return false;
+        }
+        if (!asn1_pop_tag(asn1)) return false;
+        if (!asn1_pop_tag(asn1)) return false;
+        return !asn1_has_error(asn1);
+}
 …
+        }
         asn1_load(asn1, data);
+        if (!asn1_load(asn1, data)) goto err;
         if (!asn1_peek_uint8(asn1, &context)) {
                 asn1->has_error = true;
+                asn1_set_error(asn1);
         } else {
                 switch (context) {
                 case ASN1_APPLICATION(0):
                         asn1_start_tag(asn1, ASN1_APPLICATION(0));
                         asn1_check_OID(asn1, OID_SPNEGO);
+                        if (!asn1_start_tag(asn1, ASN1_APPLICATION(0))) goto err;
+                        if (!asn1_check_OID(asn1, OID_SPNEGO)) goto err;
                         if (read_negTokenInit(asn1, mem_ctx, &token->negTokenInit)) {
                                 token->type = SPNEGO_NEG_TOKEN_INIT;
+                        }
                         asn1_end_tag(asn1);
+                        if (!asn1_end_tag(asn1)) goto err;
                         break;
                 case ASN1_CONTEXT(1):
 …
                         break;
                 default:
+                        asn1->has_error = true;
+                        break;
+                }
+        }
+        if (!asn1->has_error) ret = asn1->ofs;
+                        asn1_set_error(asn1);
+                        break;
+                }
+        }
+        if (!asn1_has_error(asn1)) {
+                ret = asn1_current_ofs(asn1);
+        }
+  err:
         asn1_free(asn1);
 …
         switch (spnego->type) {
         case SPNEGO_NEG_TOKEN_INIT:
                 asn1_push_tag(asn1, ASN1_APPLICATION(0));
                 asn1_write_OID(asn1, OID_SPNEGO);
                 write_negTokenInit(asn1, &spnego->negTokenInit);
                 asn1_pop_tag(asn1);
+                if (!asn1_push_tag(asn1, ASN1_APPLICATION(0))) goto err;
+                if (!asn1_write_OID(asn1, OID_SPNEGO)) goto err;
+                if (!write_negTokenInit(asn1, &spnego->negTokenInit)) goto err;
+                if (!asn1_pop_tag(asn1)) goto err;
                 break;
         case SPNEGO_NEG_TOKEN_TARG:
 …
                 break;
         default:
+                asn1->has_error = true;
+                break;
+        }
+        if (!asn1->has_error) {
+                *blob = data_blob_talloc(mem_ctx, asn1->data, asn1->length);
+                ret = asn1->ofs;
+        }
+                asn1_set_error(asn1);
+                break;
+        }
+        if (!asn1_extract_blob(asn1, mem_ctx, blob)) {
+                goto err;
+        }
+        ret = asn1_current_ofs(asn1);
+  err:
         asn1_free(asn1);
 …
         case SPNEGO_NEG_TOKEN_INIT:
                 if (spnego->negTokenInit.mechTypes) {
                         talloc_free(spnego->negTokenInit.mechTypes);
+                        talloc_free(discard_const(spnego->negTokenInit.mechTypes));
+                }
                 data_blob_free(&spnego->negTokenInit.reqFlags);
 …
 bool spnego_write_mech_types(TALLOC_CTX *mem_ctx,
                              const char **mech_types,
+                             const char * const *mech_types,
                              DATA_BLOB *blob)
+{
+        bool ret = false;
         struct asn1_data *asn1 = asn1_init(mem_ctx);
 …
                 int i;
                 asn1_push_tag(asn1, ASN1_SEQUENCE(0));
+                if (!asn1_push_tag(asn1, ASN1_SEQUENCE(0))) goto err;
                 for (i = 0; mech_types[i]; i++) {
+                        asn1_write_OID(asn1, mech_types[i]);
+                }
+                asn1_pop_tag(asn1);
+        }
+        if (asn1->has_error) {
+                asn1_free(asn1);
+                return false;
+        }
+        *blob = data_blob_talloc(mem_ctx, asn1->data, asn1->length);
+        if (blob->length != asn1->length) {
+                asn1_free(asn1);
+                return false;
+        }
+                        if (!asn1_write_OID(asn1, mech_types[i])) goto err;
+                }
+                if (!asn1_pop_tag(asn1)) goto err;
+        }
+        if (asn1_has_error(asn1)) {
+                goto err;
+        }
+        if (!asn1_extract_blob(asn1, mem_ctx, blob)) {
+                goto err;
+        }
+        ret = true;
+  err:
         asn1_free(asn1);
         return true;
+}
+        return ret;
+}

vendor/current/libcli/auth/spnego_proto.h

r414	r988
25	25	bool spnego_free_data(struct spnego_data *spnego);
26	26	bool spnego_write_mech_types(TALLOC_CTX *mem_ctx,
27		const char **mech_types,
	27	const char * const *mech_types,
28	28	DATA_BLOB *blob);

vendor/current/libcli/auth/wscript_build

-              r919
+              r988
 bld.SAMBA_LIBRARY('cliauth',
                   source='',
                   deps='NTLMSSP_COMMON MSRPC_PARSE LIBCLI_AUTH COMMON_SCHANNEL PAM_ERRORS SPNEGO_PARSE',
+                  deps='MSRPC_PARSE LIBCLI_AUTH COMMON_SCHANNEL PAM_ERRORS SPNEGO_PARSE krb5samba samba-errors NTLM_CHECK UTIL_LSARPC',
                   private_library=True,
                   grouping_library=True)
-bld.SAMBA_SUBSYSTEM('NTLMSSP_COMMON',
-                    source='ntlmssp.c ntlmssp_ndr.c ntlmssp_server.c ntlmssp_sign.c ntlm_check.c',
-                    deps='samba-util NDR_NTLMSSP MSRPC_PARSE')
 bld.SAMBA_SUBSYSTEM('MSRPC_PARSE',
 …
+        )
+bld.SAMBA_SUBSYSTEM('NTLM_CHECK',
+                    source='ntlm_check.c',
+                    deps = 'talloc'
+                    )
 bld.SAMBA_SUBSYSTEM('LIBCLI_AUTH',
         source='credentials.c session.c smbencrypt.c smbdes.c',
         public_deps='MSRPC_PARSE NDR_NTLMSSP',
+        public_deps='MSRPC_PARSE',
         public_headers='credentials.h:domain_credentials.h'
+        )
 …
 bld.SAMBA_SUBSYSTEM('COMMON_SCHANNEL',
         source='schannel_state_tdb.c schannel_sign.c',
         deps='tdb-wrap UTIL_TDB'
+        source='schannel_state_tdb.c',
+        deps='dbwrap util_tdb samba-hostconfig NDR_NETLOGON'
+        )
+bld.SAMBA_SUBSYSTEM('NETLOGON_CREDS_CLI',
+        source='netlogon_creds_cli.c',
+        deps='dbwrap util_tdb tevent-util samba-hostconfig RPC_NDR_NETLOGON NDR_NETLOGON'
+        )
 bld.SAMBA_SUBSYSTEM('PAM_ERRORS',
 …
 bld.SAMBA_SUBSYSTEM('SPNEGO_PARSE',
                     source='spnego_parse.c',
                     deps='ASN1_UTIL')
+                    deps='asn1util')

vendor/current/libcli/cldap/cldap.c

-              r746
+              r988
         bool connected;
-        /*
-         * we allow sync requests only, if the caller
-         * did not pass an event context to cldap_socket_init()
-         */
-        struct {
-                bool allow_poll;
-                struct tevent_context *ctx;
-        } event;
         /* the queue for outgoing dgrams */
         struct tevent_queue *send_queue;
 …
         /* what to do with incoming request packets */
         struct {
+                struct tevent_context *ev;
                 void (*handler)(struct cldap_socket *,
                                 void *private_data,
 …
         struct {
+                struct tevent_context *ev;
                 struct cldap_socket *cldap;
         } caller;
 …
 static bool cldap_recvfrom_setup(struct cldap_socket *c)
+{
+        struct tevent_context *ev;
         if (c->recv_subreq) {
                 return true;
 …
+        }
+        c->recv_subreq = tdgram_recvfrom_send(c, c->event.ctx, c->sock);
+        ev = c->incoming.ev;
+        if (ev == NULL) {
+                ev = c->searches.list->caller.ev;
+        }
+        c->recv_subreq = tdgram_recvfrom_send(c, ev, c->sock);
         if (!c->recv_subreq) {
                 return false;
 …
         talloc_free(subreq);
         talloc_free(in);
-        /*TODO: call a dead socket handler */
-        return;
+}
 …
                                     struct cldap_incoming *in)
+{
-        DATA_BLOB blob;
         struct asn1_data *asn1;
         void *p;
 …
+        }
-        blob = data_blob_const(in->buf, in->len);
         asn1 = asn1_init(in);
         if (!asn1) {
 …
+        }
+        if (!asn1_load(asn1, blob)) {
+                goto nomem;
+        }
+        asn1_load_nocopy(asn1, in->buf, in->len);
         in->ldap_msg = talloc(in, struct ldap_message);
 …
         if (p == NULL) {
                 if (!c->incoming.handler) {
+                        goto done;
+                        TALLOC_FREE(in);
+                        return true;
+                }
 …
+        }
         search = talloc_get_type(p, struct cldap_search_state);
+        search = talloc_get_type_abort(p, struct cldap_search_state);
         search->response.in = talloc_move(search, &in);
         search->response.asn1 = asn1;
+        search->response.asn1->ofs = 0;
+        asn1_load_nocopy(search->response.asn1,
+                         search->response.in->buf, search->response.in->len);
         DLIST_REMOVE(c->searches.list, search);
+        cldap_recvfrom_setup(c);
+        if (cldap_recvfrom_setup(c)) {
+                tevent_req_done(search->req);
+                return true;
+        }
+        /*
+         * This request was ok, just defer the notify of the caller
+         * and then just fail the next request if needed
+         */
+        tevent_req_defer_callback(search->req, search->caller.ev);
         tevent_req_done(search->req);
+        return true;
+        status = NT_STATUS_NO_MEMORY;
+        /* in is NULL it this point */
+        goto nterror;
 nomem:
         in->recv_errno = ENOMEM;
 error:
         status = map_nt_error_from_unix(in->recv_errno);
+        status = map_nt_error_from_unix_common(in->recv_errno);
 nterror:
         TALLOC_FREE(in);
 …
         if (!c->connected) {
                 /* otherwise we just ignore the error */
                 goto done;
+                return false;
+        }
         if (!c->searches.list) {
+                goto done;
+        }
+        cldap_recvfrom_setup(c);
+                return false;
+        }
+        /*
+         * We might called tevent_req_done() for a successful
+         * search before, so we better deliver the failure
+         * after the success, that is why we better also
+         * use tevent_req_defer_callback() here.
+         */
+        tevent_req_defer_callback(c->searches.list->req,
+                                  c->searches.list->caller.ev);
         tevent_req_nterror(c->searches.list->req, status);
-        return true;
-done:
-        TALLOC_FREE(in);
         return false;
+}
 …
 */
 NTSTATUS cldap_socket_init(TALLOC_CTX *mem_ctx,
-                           struct tevent_context *ev,
                            const struct tsocket_address *local_addr,
                            const struct tsocket_address *remote_addr,
 …
+        }
-        if (!ev) {
-                ev = tevent_context_init(c);
-                if (!ev) {
-                        goto nomem;
+                }
-                c->event.allow_poll = true;
+        }
-        c->event.ctx = ev;
         if (!local_addr) {
                 /*
 …
                                                         &any);
                 if (ret != 0) {
                         status = map_nt_error_from_unix(errno);
+                        status = map_nt_error_from_unix_common(errno);
                         goto nterror;
+                }
 …
                                      c, &c->sock);
         if (ret != 0) {
                 status = map_nt_error_from_unix(errno);
+                status = map_nt_error_from_unix_common(errno);
                 goto nterror;
+        }
 …
 */
 NTSTATUS cldap_set_incoming_handler(struct cldap_socket *c,
+                                    struct tevent_context *ev,
                                     void (*handler)(struct cldap_socket *,
                                                     void *private_data,
 …
+        }
+        /* if sync requests are allowed, we don't allow an incoming handler */
+        if (c->event.allow_poll) {
+                return NT_STATUS_INVALID_PIPE_STATE;
+        }
+        c->incoming.ev = ev;
         c->incoming.handler = handler;
         c->incoming.private_data = private_data;
 …
+        }
+        if (cldap->incoming.ev == NULL) {
+                return NT_STATUS_INVALID_PIPE_STATE;
+        }
         if (!io->dest) {
                 return NT_STATUS_INVALID_ADDRESS;
 …
         subreq = tdgram_sendto_queue_send(state,
                                           cldap->event.ctx,
+                                          cldap->incoming.ev,
                                           cldap->sock,
                                           cldap->send_queue,
 …
 */
 struct tevent_req *cldap_search_send(TALLOC_CTX *mem_ctx,
+                                    struct cldap_socket *cldap,
+                                    const struct cldap_search *io)
+                                     struct tevent_context *ev,
+                                     struct cldap_socket *cldap,
+                                     const struct cldap_search *io)
+{
         struct tevent_req *req, *subreq;
 …
+        }
         ZERO_STRUCTP(state);
+        state->caller.ev = ev;
         state->req = req;
         state->caller.cldap = cldap;
 …
         end = now;
         for (i = 0; i < state->request.count; i++) {
+                end = tevent_timeval_add(&end, 0, state->request.delay);
+        }
+        if (!tevent_req_set_endtime(req, state->caller.cldap->event.ctx, end)) {
+                tevent_req_nomem(NULL, req);
+                end = tevent_timeval_add(&end, state->request.delay / 1000000,
+                                         state->request.delay % 1000000);
+        }
+        if (!tevent_req_set_endtime(req, state->caller.ev, end)) {
+                tevent_req_oom(req);
                 goto post;
+        }
         subreq = tdgram_sendto_queue_send(state,
                                           state->caller.cldap->event.ctx,
+                                          state->caller.ev,
                                           state->caller.cldap->sock,
                                           state->caller.cldap->send_queue,
 …
         tevent_req_set_callback(subreq, cldap_search_state_queue_done, req);
         DLIST_ADD_END(cldap->searches.list, state, struct cldap_search_state *);
+        DLIST_ADD_END(cldap->searches.list, state);
         return req;
  post:
         return tevent_req_post(req, cldap->event.ctx);
+        return tevent_req_post(req, state->caller.ev);
+}
 …
         if (ret == -1) {
                 NTSTATUS status;
                 status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 DLIST_REMOVE(state->caller.cldap->searches.list, state);
                 ZERO_STRUCT(state->caller.cldap);
 …
         /* wait for incoming traffic */
         if (!cldap_recvfrom_setup(state->caller.cldap)) {
                 tevent_req_nomem(NULL, req);
+                tevent_req_oom(req);
                 return;
+        }
 …
+        }
+        next = tevent_timeval_current_ofs(0, state->request.delay);
+        next = tevent_timeval_current_ofs(state->request.delay / 1000000,
+                                          state->request.delay % 1000000);
         subreq = tevent_wakeup_send(state,
                                     state->caller.cldap->event.ctx,
+                                    state->caller.ev,
                                     next);
         if (tevent_req_nomem(subreq, req)) {
 …
         subreq = tdgram_sendto_queue_send(state,
                                           state->caller.cldap->event.ctx,
+                                          state->caller.ev,
                                           state->caller.cldap->sock,
                                           state->caller.cldap->send_queue,
 …
                       struct cldap_search *io)
+{
+        TALLOC_CTX *frame;
         struct tevent_req *req;
+        struct tevent_context *ev;
         NTSTATUS status;
-        if (!cldap->event.allow_poll) {
-                return NT_STATUS_INVALID_PIPE_STATE;
+        }
         if (cldap->searches.list) {
 …
+        }
+        req = cldap_search_send(mem_ctx, cldap, io);
+        NT_STATUS_HAVE_NO_MEMORY(req);
+        if (!tevent_req_poll(req, cldap->event.ctx)) {
+                talloc_free(req);
+                return NT_STATUS_INTERNAL_ERROR;
+        if (cldap->incoming.handler) {
+                return NT_STATUS_INVALID_PIPE_STATE;
+        }
+        frame = talloc_stackframe();
+        ev = samba_tevent_context_init(frame);
+        if (ev == NULL) {
+                TALLOC_FREE(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+        req = cldap_search_send(mem_ctx, ev, cldap, io);
+        if (req == NULL) {
+                TALLOC_FREE(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+        if (!tevent_req_poll(req, ev)) {
+                status = map_nt_error_from_unix_common(errno);
+                TALLOC_FREE(frame);
+                return status;
+        }
         status = cldap_search_recv(req, mem_ctx, io);
+        talloc_free(req);
+        return status;
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(frame);
+                return status;
+        }
+        TALLOC_FREE(frame);
+        return NT_STATUS_OK;
+}
 …
 };
+char *cldap_netlogon_create_filter(TALLOC_CTX *mem_ctx,
+                                   const struct cldap_netlogon *io)
+{
+        char *filter;
+        filter = talloc_asprintf(mem_ctx, "(&(NtVer=%s)",
+                                 ldap_encode_ndr_uint32(mem_ctx, io->in.version));
+        if (filter == NULL)
+                return NULL;
+        if (io->in.user) {
+                filter = talloc_asprintf_append_buffer(filter, "(User=%s)", io->in.user);
+                if (filter == NULL) {
+                        return NULL;
+                }
+        }
+        if (io->in.host) {
+                filter = talloc_asprintf_append_buffer(filter, "(Host=%s)", io->in.host);
+                if (filter == NULL) {
+                        return NULL;
+                }
+        }
+        if (io->in.realm) {
+                filter = talloc_asprintf_append_buffer(filter, "(DnsDomain=%s)", io->in.realm);
+                if (filter == NULL) {
+                        return NULL;
+                }
+        }
+        if (io->in.acct_control != -1) {
+                filter = talloc_asprintf_append_buffer(filter, "(AAC=%s)",
+                                                ldap_encode_ndr_uint32(mem_ctx, io->in.acct_control));
+                if (filter == NULL) {
+                        return NULL;
+                }
+        }
+        if (io->in.domain_sid) {
+                struct dom_sid *sid = dom_sid_parse_talloc(mem_ctx, io->in.domain_sid);
+                filter = talloc_asprintf_append_buffer(filter, "(domainSid=%s)",
+                                                ldap_encode_ndr_dom_sid(mem_ctx, sid));
+                if (filter == NULL) {
+                        return NULL;
+                }
+        }
+        if (io->in.domain_guid) {
+                struct GUID guid;
+                GUID_from_string(io->in.domain_guid, &guid);
+                filter = talloc_asprintf_append_buffer(filter, "(DomainGuid=%s)",
+                                                ldap_encode_ndr_GUID(mem_ctx, &guid));
+                if (filter == NULL) {
+                        return NULL;
+                }
+        }
+        filter = talloc_asprintf_append_buffer(filter, ")");
+        return filter;
+}
 static void cldap_netlogon_state_done(struct tevent_req *subreq);
 /*
 …
 */
 struct tevent_req *cldap_netlogon_send(TALLOC_CTX *mem_ctx,
+                                      struct cldap_socket *cldap,
+                                      const struct cldap_netlogon *io)
+                                       struct tevent_context *ev,
+                                       struct cldap_socket *cldap,
+                                       const struct cldap_netlogon *io)
+{
         struct tevent_req *req, *subreq;
 …
+        }
+        filter = talloc_asprintf(state, "(&(NtVer=%s)",
+                                 ldap_encode_ndr_uint32(state, io->in.version));
+        if (tevent_req_nomem(filter, req)) {
+                goto post;
+        }
+        if (io->in.user) {
+                filter = talloc_asprintf_append_buffer(filter, "(User=%s)", io->in.user);
+                if (tevent_req_nomem(filter, req)) {
+                        goto post;
+                }
+        }
+        if (io->in.host) {
+                filter = talloc_asprintf_append_buffer(filter, "(Host=%s)", io->in.host);
+                if (tevent_req_nomem(filter, req)) {
+                        goto post;
+                }
+        }
+        if (io->in.realm) {
+                filter = talloc_asprintf_append_buffer(filter, "(DnsDomain=%s)", io->in.realm);
+                if (tevent_req_nomem(filter, req)) {
+                        goto post;
+                }
+        }
+        if (io->in.acct_control != -1) {
+                filter = talloc_asprintf_append_buffer(filter, "(AAC=%s)",
+                                                ldap_encode_ndr_uint32(state, io->in.acct_control));
+                if (tevent_req_nomem(filter, req)) {
+                        goto post;
+                }
+        }
+        if (io->in.domain_sid) {
+                struct dom_sid *sid = dom_sid_parse_talloc(state, io->in.domain_sid);
+                if (tevent_req_nomem(sid, req)) {
+                        goto post;
+                }
+                filter = talloc_asprintf_append_buffer(filter, "(domainSid=%s)",
+                                                ldap_encode_ndr_dom_sid(state, sid));
+                if (tevent_req_nomem(filter, req)) {
+                        goto post;
+                }
+        }
+        if (io->in.domain_guid) {
+                struct GUID guid;
+                NTSTATUS status;
+                status = GUID_from_string(io->in.domain_guid, &guid);
+                if (tevent_req_nterror(req, status)) {
+                        goto post;
+                }
+                filter = talloc_asprintf_append_buffer(filter, "(DomainGuid=%s)",
+                                                ldap_encode_ndr_GUID(state, &guid));
+                if (tevent_req_nomem(filter, req)) {
+                        goto post;
+                }
+        }
+        filter = talloc_asprintf_append_buffer(filter, ")");
+        filter = cldap_netlogon_create_filter(state, io);
         if (tevent_req_nomem(filter, req)) {
                 goto post;
 …
         state->search.in.retries        = 2;
         subreq = cldap_search_send(state, cldap, &state->search);
+        subreq = cldap_search_send(state, ev, cldap, &state->search);
         if (tevent_req_nomem(subreq, req)) {
                 goto post;
 …
         return req;
 post:
         return tevent_req_post(req, cldap->event.ctx);
+        return tevent_req_post(req, ev);
+}
 …
         struct cldap_netlogon_state *state = tevent_req_data(req,
                                              struct cldap_netlogon_state);
         NTSTATUS status;
+        NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
         DATA_BLOB *data;
 …
                         struct cldap_netlogon *io)
+{
+        TALLOC_CTX *frame;
         struct tevent_req *req;
+        struct tevent_context *ev;
         NTSTATUS status;
-        if (!cldap->event.allow_poll) {
-                return NT_STATUS_INVALID_PIPE_STATE;
+        }
         if (cldap->searches.list) {
 …
+        }
+        req = cldap_netlogon_send(mem_ctx, cldap, io);
+        NT_STATUS_HAVE_NO_MEMORY(req);
+        if (!tevent_req_poll(req, cldap->event.ctx)) {
+                talloc_free(req);
+                return NT_STATUS_INTERNAL_ERROR;
+        if (cldap->incoming.handler) {
+                return NT_STATUS_INVALID_PIPE_STATE;
+        }
+        frame = talloc_stackframe();
+        ev = samba_tevent_context_init(frame);
+        if (ev == NULL) {
+                TALLOC_FREE(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+        req = cldap_netlogon_send(mem_ctx, ev, cldap, io);
+        if (req == NULL) {
+                TALLOC_FREE(frame);
+                return NT_STATUS_NO_MEMORY;
+        }
+        if (!tevent_req_poll(req, ev)) {
+                status = map_nt_error_from_unix_common(errno);
+                TALLOC_FREE(frame);
+                return status;
+        }
         status = cldap_netlogon_recv(req, mem_ctx, io);
+        talloc_free(req);
+        return status;
+        if (!NT_STATUS_IS_OK(status)) {
+                TALLOC_FREE(frame);
+                return status;
+        }
+        TALLOC_FREE(frame);
+        return NT_STATUS_OK;
+}

vendor/current/libcli/cldap/cldap.h

-              r740
+              r988
 NTSTATUS cldap_socket_init(TALLOC_CTX *mem_ctx,
-                           struct tevent_context *ev,
                            const struct tsocket_address *local_addr,
                            const struct tsocket_address *remote_addr,
 …
 NTSTATUS cldap_set_incoming_handler(struct cldap_socket *cldap,
+                                    struct tevent_context *ev,
                                     void (*handler)(struct cldap_socket *,
                                                     void *private_data,
 …
                                     void *private_data);
 struct tevent_req *cldap_search_send(TALLOC_CTX *mem_ctx,
+                                     struct tevent_context *ev,
                                      struct cldap_socket *cldap,
                                      const struct cldap_search *io);
 …
 struct tevent_req *cldap_netlogon_send(TALLOC_CTX *mem_ctx,
+                                       struct tevent_context *ev,
                                        struct cldap_socket *cldap,
                                        const struct cldap_netlogon *io);
 …
                         TALLOC_CTX *mem_ctx,
                         struct cldap_netlogon *io);
+char *cldap_netlogon_create_filter(TALLOC_CTX *mem_ctx,
+                                   const struct cldap_netlogon *io);
 NTSTATUS cldap_netlogon_reply(struct cldap_socket *cldap,

vendor/current/libcli/cldap/wscript_build

-              r740
+              r988
+bld.SAMBA_SUBSYSTEM('LIBCLI_CLDAP',
+        source='cldap.c',
+        public_deps='cli-ldap',
+        deps='LIBTSOCKET samba-util UTIL_TEVENT ldb LIBCLI_NETLOGON'
+        )
+bld.SAMBA_LIBRARY('cli_cldap',
+                  source='cldap.c',
+                  public_deps='cli-ldap',
+                  deps='LIBTSOCKET samba-util tevent-util ldb LIBCLI_NETLOGON',
+                  private_library=True
+                  )

vendor/current/libcli/drsuapi/drsuapi.h

r414	r988
30	30	const DATA_BLOB *gensec_skey,
31	31	uint32_t rid,
	32	uint32_t dsdb_repl_flags,
32	33	struct drsuapi_DsReplicaAttribute *attr);
33	34

vendor/current/libcli/drsuapi/repl_decrypt.c

-              r746
+              r988
 #include "../libcli/drsuapi/drsuapi.h"
 #include "libcli/auth/libcli_auth.h"
+#include "dsdb/samdb/samdb.h"
 WERROR drsuapi_decrypt_attribute_value(TALLOC_CTX *mem_ctx,
 …
                                  const DATA_BLOB *gensec_skey,
                                  uint32_t rid,
+                                 uint32_t dsdb_repl_flags,
                                  struct drsuapi_DsReplicaAttribute *attr)
+{
 …
+        }
+        if (dsdb_repl_flags & DSDB_REPL_FLAG_EXPECT_NO_SECRETS) {
+                return WERR_TOO_MANY_SECRETS;
+        }
         if (attr->value_ctr.num_values > 1) {
                 return WERR_DS_DRA_INVALID_PARAMETER;

vendor/current/libcli/drsuapi/wscript_build

r740	r988
4	4	bld.SAMBA_SUBSYSTEM('LIBCLI_DRSUAPI',
5	5	source='repl_decrypt.c',
6		public_deps='LIBCLI_AUTH'
	6	public_deps='LIBCLI_AUTH samdb'
7	7	)
8	8

vendor/current/libcli/echo/echo.c

-              r740
+              r988
                                                 &local_addr);
         if (ret != 0) {
                 tevent_req_nterror(req, map_nt_error_from_unix(ret));
+                tevent_req_nterror(req, map_nt_error_from_unix_common(ret));
                 return tevent_req_post(req, ev);
+        }
 …
                                                 ECHO_PORT, &server_addr);
         if (ret != 0) {
                 tevent_req_nterror(req, map_nt_error_from_unix(ret));
+                tevent_req_nterror(req, map_nt_error_from_unix_common(ret));
                 return tevent_req_post(req, ev);
+        }
 …
         ret = tdgram_inet_udp_socket(local_addr, server_addr, state, &dgram);
         if (ret != 0) {
                 tevent_req_nterror(req, map_nt_error_from_unix(ret));
+                tevent_req_nterror(req, map_nt_error_from_unix_common(ret));
                 return tevent_req_post(req, ev);
+        }
 …
         if (len == -1 && err != 0) {
                 tevent_req_nterror(req, map_nt_error_from_unix(err));
+                tevent_req_nterror(req, map_nt_error_from_unix_common(err));
                 return;
+        }
 …
         if (len == -1 && err != 0) {
+                tevent_req_nterror(req, map_nt_error_from_unix(err));
+                tevent_req_nterror(req, map_nt_error_from_unix_common(err));
+                return;
+        }
+        if (len != state->orig_len) {
+                tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
                 return;
+        }

vendor/current/libcli/echo/tests/echo.c

-              r740
+              r988
         make_nbt_name_server(&name,
                              torture_setting_string(tctx, "host", NULL));
+        status = resolve_name(lpcfg_resolve_context(tctx->lp_ctx), &name, tctx,
+                              &address, tctx->ev);
+        status = resolve_name_ex(lpcfg_resolve_context(tctx->lp_ctx),
+, 0,
+                                 &name, tctx,
+                                 &address, tctx->ev);
         if (!NT_STATUS_IS_OK(status)) {
                 printf("Failed to resolve %s - %s\n", name.name,

vendor/current/libcli/echo/tests/wscript_build

r740	r988
5	5	subsystem='smbtorture',
6	6	init_function='torture_libcli_echo_init',
7		deps='LIBTSOCKET ~~UTIL_TEVENT~~ LIBCLI_ECHO',
	7	deps='LIBTSOCKET tevent-util LIBCLI_ECHO',
8	8	internal_module=True);

vendor/current/libcli/echo/wscript_build

r740	r988
3	3	bld.SAMBA_SUBSYSTEM('LIBCLI_ECHO',
4	4	source='echo.c',
5		deps='LIBTSOCKET ~~UTIL_TEVENT~~');
	5	deps='LIBTSOCKET tevent-util');
6	6
7	7	bld.RECURSE('tests')

vendor/current/libcli/ldap/ldap_message.c

-              r740
+              r988
         case LDB_OP_AND:
         case LDB_OP_OR:
                 asn1_push_tag(data, ASN1_CONTEXT(tree->operation==LDB_OP_AND?0:1));
+                if (!asn1_push_tag(data, ASN1_CONTEXT(tree->operation==LDB_OP_AND?0:1))) return false;
                 for (i=0; i<tree->u.list.num_elements; i++) {
                         if (!ldap_push_filter(data, tree->u.list.elements[i])) {
 …
+                        }
+                }
                 asn1_pop_tag(data);
+                if (!asn1_pop_tag(data)) return false;
                 break;
         case LDB_OP_NOT:
                 asn1_push_tag(data, ASN1_CONTEXT(2));
+                if (!asn1_push_tag(data, ASN1_CONTEXT(2))) return false;
                 if (!ldap_push_filter(data, tree->u.isnot.child)) {
                         return false;
+                }
                 asn1_pop_tag(data);
+                if (!asn1_pop_tag(data)) return false;
                 break;
         case LDB_OP_EQUALITY:
                 /* equality test */
                 asn1_push_tag(data, ASN1_CONTEXT(3));
                 asn1_write_OctetString(data, tree->u.equality.attr,
                                       strlen(tree->u.equality.attr));
                 asn1_write_OctetString(data, tree->u.equality.value.data,
                                       tree->u.equality.value.length);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_CONTEXT(3))) return false;
+                if (!asn1_write_OctetString(data, tree->u.equality.attr,
+                                      strlen(tree->u.equality.attr))) return false;
+                if (!asn1_write_OctetString(data, tree->u.equality.value.data,
+                                      tree->u.equality.value.length)) return false;
+                if (!asn1_pop_tag(data)) return false;
                 break;
 …
                                   final   [2] LDAPString } }
                 */
+                asn1_push_tag(data, ASN1_CONTEXT(4));
+                asn1_write_OctetString(data, tree->u.substring.attr, strlen(tree->u.substring.attr));
+                asn1_push_tag(data, ASN1_SEQUENCE(0));
+                i = 0;
+                if ( ! tree->u.substring.start_with_wildcard) {
+                        asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0));
+                        asn1_write_DATA_BLOB_LDAPString(data, tree->u.substring.chunks[i]);
+                        asn1_pop_tag(data);
+                        i++;
+                }
+                while (tree->u.substring.chunks[i]) {
+                        int ctx;
+                        if (( ! tree->u.substring.chunks[i + 1]) &&
+                            (tree->u.substring.end_with_wildcard == 0)) {
+                                ctx = 2;
+                        } else {
+                                ctx = 1;
+                        }
+                        asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(ctx));
+                        asn1_write_DATA_BLOB_LDAPString(data, tree->u.substring.chunks[i]);
+                        asn1_pop_tag(data);
+                        i++;
+                }
+                asn1_pop_tag(data);
+                asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_CONTEXT(4))) return false;
+                if (!asn1_write_OctetString(data, tree->u.substring.attr, strlen(tree->u.substring.attr))) return false;
+                if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) return false;
+                if (tree->u.substring.chunks && tree->u.substring.chunks[0]) {
+                        i = 0;
+                        if (!tree->u.substring.start_with_wildcard) {
+                                if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0))) return false;
+                                if (!asn1_write_DATA_BLOB_LDAPString(data, tree->u.substring.chunks[i])) return false;
+                                if (!asn1_pop_tag(data)) return false;
+                                i++;
+                        }
+                        while (tree->u.substring.chunks[i]) {
+                                int ctx;
+                                if (( ! tree->u.substring.chunks[i + 1]) &&
+                                    (tree->u.substring.end_with_wildcard == 0)) {
+                                        ctx = 2;
+                                } else {
+                                        ctx = 1;
+                                }
+                                if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(ctx))) return false;
+                                if (!asn1_write_DATA_BLOB_LDAPString(data, tree->u.substring.chunks[i])) return false;
+                                if (!asn1_pop_tag(data)) return false;
+                                i++;
+                        }
+                }
+                if (!asn1_pop_tag(data)) return false;
+                if (!asn1_pop_tag(data)) return false;
                 break;
         case LDB_OP_GREATER:
                 /* greaterOrEqual test */
                 asn1_push_tag(data, ASN1_CONTEXT(5));
                 asn1_write_OctetString(data, tree->u.comparison.attr,
                                       strlen(tree->u.comparison.attr));
                 asn1_write_OctetString(data, tree->u.comparison.value.data,
                                       tree->u.comparison.value.length);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_CONTEXT(5))) return false;
+                if (!asn1_write_OctetString(data, tree->u.comparison.attr,
+                                      strlen(tree->u.comparison.attr))) return false;
+                if (!asn1_write_OctetString(data, tree->u.comparison.value.data,
+                                      tree->u.comparison.value.length)) return false;
+                if (!asn1_pop_tag(data)) return false;
                 break;
         case LDB_OP_LESS:
                 /* lessOrEqual test */
                 asn1_push_tag(data, ASN1_CONTEXT(6));
                 asn1_write_OctetString(data, tree->u.comparison.attr,
                                       strlen(tree->u.comparison.attr));
                 asn1_write_OctetString(data, tree->u.comparison.value.data,
                                       tree->u.comparison.value.length);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_CONTEXT(6))) return false;
+                if (!asn1_write_OctetString(data, tree->u.comparison.attr,
+                                      strlen(tree->u.comparison.attr))) return false;
+                if (!asn1_write_OctetString(data, tree->u.comparison.value.data,
+                                      tree->u.comparison.value.length)) return false;
+                if (!asn1_pop_tag(data)) return false;
                 break;
         case LDB_OP_PRESENT:
                 /* present test */
                 asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(7));
                 asn1_write_LDAPString(data, tree->u.present.attr);
                 asn1_pop_tag(data);
                 return !data->has_error;
+                if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(7))) return false;
+                if (!asn1_write_LDAPString(data, tree->u.present.attr)) return false;
+                if (!asn1_pop_tag(data)) return false;
+                return !asn1_has_error(data);
         case LDB_OP_APPROX:
                 /* approx test */
                 asn1_push_tag(data, ASN1_CONTEXT(8));
                 asn1_write_OctetString(data, tree->u.comparison.attr,
                                       strlen(tree->u.comparison.attr));
                 asn1_write_OctetString(data, tree->u.comparison.value.data,
                                       tree->u.comparison.value.length);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_CONTEXT(8))) return false;
+                if (!asn1_write_OctetString(data, tree->u.comparison.attr,
+                                      strlen(tree->u.comparison.attr))) return false;
+                if (!asn1_write_OctetString(data, tree->u.comparison.value.data,
+                                      tree->u.comparison.value.length)) return false;
+                if (!asn1_pop_tag(data)) return false;
                 break;
 …
+                  }
                 */
                 asn1_push_tag(data, ASN1_CONTEXT(9));
+                if (!asn1_push_tag(data, ASN1_CONTEXT(9))) return false;
                 if (tree->u.extended.rule_id) {
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(1));
                         asn1_write_LDAPString(data, tree->u.extended.rule_id);
                         asn1_pop_tag(data);
+                        if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(1))) return false;
+                        if (!asn1_write_LDAPString(data, tree->u.extended.rule_id)) return false;
+                        if (!asn1_pop_tag(data)) return false;
+                }
                 if (tree->u.extended.attr) {
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(2));
                         asn1_write_LDAPString(data, tree->u.extended.attr);
                         asn1_pop_tag(data);
+                }
                 asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(3));
                 asn1_write_DATA_BLOB_LDAPString(data, &tree->u.extended.value);
                 asn1_pop_tag(data);
                 asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(4));
                 asn1_write_uint8(data, tree->u.extended.dnAttributes);
                 asn1_pop_tag(data);
                 asn1_pop_tag(data);
+                        if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(2))) return false;
+                        if (!asn1_write_LDAPString(data, tree->u.extended.attr)) return false;
+                        if (!asn1_pop_tag(data)) return false;
+                }
+                if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(3))) return false;
+                if (!asn1_write_DATA_BLOB_LDAPString(data, &tree->u.extended.value)) return false;
+                if (!asn1_pop_tag(data)) return false;
+                if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(4))) return false;
+                if (!asn1_write_uint8(data, tree->u.extended.dnAttributes)) return false;
+                if (!asn1_pop_tag(data)) return false;
+                if (!asn1_pop_tag(data)) return false;
                 break;
 …
                 return false;
+        }
         return !data->has_error;
+}
 static void ldap_encode_response(struct asn1_data *data, struct ldap_Result *result)
+{
         asn1_write_enumerated(data, result->resultcode);
         asn1_write_OctetString(data, result->dn,
                                (result->dn) ? strlen(result->dn) : 0);
         asn1_write_OctetString(data, result->errormessage,
+        return !asn1_has_error(data);
+}
+static bool ldap_encode_response(struct asn1_data *data, struct ldap_Result *result)
+{
+        if (!asn1_write_enumerated(data, result->resultcode)) return false;
+        if (!asn1_write_OctetString(data, result->dn,
+                               (result->dn) ? strlen(result->dn) : 0)) return false;
+        if (!asn1_write_OctetString(data, result->errormessage,
                                (result->errormessage) ?
                                strlen(result->errormessage) : 0);
+                               strlen(result->errormessage) : 0)) return false;
         if (result->referral) {
+                asn1_push_tag(data, ASN1_CONTEXT(3));
+                asn1_write_OctetString(data, result->referral,
+                                       strlen(result->referral));
+                asn1_pop_tag(data);
+        }
+                if (!asn1_push_tag(data, ASN1_CONTEXT(3))) return false;
+                if (!asn1_write_OctetString(data, result->referral,
+                                       strlen(result->referral))) return false;
+                if (!asn1_pop_tag(data)) return false;
+        }
+        return true;
+}
 …
         if (!data) return false;
         asn1_push_tag(data, ASN1_SEQUENCE(0));
         asn1_write_Integer(data, msg->messageid);
+        if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
+        if (!asn1_write_Integer(data, msg->messageid)) goto err;
         switch (msg->type) {
         case LDAP_TAG_BindRequest: {
                 struct ldap_BindRequest *r = &msg->r.BindRequest;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_Integer(data, r->version);
                 asn1_write_OctetString(data, r->dn,
                                        (r->dn != NULL) ? strlen(r->dn) : 0);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_Integer(data, r->version)) goto err;
+                if (!asn1_write_OctetString(data, r->dn,
+                                       (r->dn != NULL) ? strlen(r->dn) : 0)) goto err;
                 switch (r->mechanism) {
                 case LDAP_AUTH_MECH_SIMPLE:
                         /* context, primitive */
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0));
                         asn1_write(data, r->creds.password,
                                    strlen(r->creds.password));
                         asn1_pop_tag(data);
+                        if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0))) goto err;
+                        if (!asn1_write(data, r->creds.password,
+                                   strlen(r->creds.password))) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
                         break;
                 case LDAP_AUTH_MECH_SASL:
                         /* context, constructed */
                         asn1_push_tag(data, ASN1_CONTEXT(3));
                         asn1_write_OctetString(data, r->creds.SASL.mechanism,
                                                strlen(r->creds.SASL.mechanism));
+                        if (!asn1_push_tag(data, ASN1_CONTEXT(3))) goto err;
+                        if (!asn1_write_OctetString(data, r->creds.SASL.mechanism,
+                                               strlen(r->creds.SASL.mechanism))) goto err;
                         if (r->creds.SASL.secblob) {
                                 asn1_write_OctetString(data, r->creds.SASL.secblob->data,
                                                        r->creds.SASL.secblob->length);
+                        }
                         asn1_pop_tag(data);
+                                if (!asn1_write_OctetString(data, r->creds.SASL.secblob->data,
+                                                       r->creds.SASL.secblob->length)) goto err;
+                        }
+                        if (!asn1_pop_tag(data)) goto err;
                         break;
                 default:
                         return false;
+                }
                 asn1_pop_tag(data);
+                        goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_BindResponse: {
                 struct ldap_BindResponse *r = &msg->r.BindResponse;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, &r->response);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, &r->response)) goto err;
                 if (r->SASL.secblob) {
                         asn1_write_ContextSimple(data, 7, r->SASL.secblob);
+                }
                 asn1_pop_tag(data);
+                        if (!asn1_write_ContextSimple(data, 7, r->SASL.secblob)) goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_UnbindRequest: {
 /*              struct ldap_UnbindRequest *r = &msg->r.UnbindRequest; */
                 asn1_push_tag(data, ASN1_APPLICATION_SIMPLE(msg->type));
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION_SIMPLE(msg->type))) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_SearchRequest: {
                 struct ldap_SearchRequest *r = &msg->r.SearchRequest;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_OctetString(data, r->basedn, strlen(r->basedn));
                 asn1_write_enumerated(data, r->scope);
                 asn1_write_enumerated(data, r->deref);
                 asn1_write_Integer(data, r->sizelimit);
                 asn1_write_Integer(data, r->timelimit);
                 asn1_write_BOOLEAN(data, r->attributesonly);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_OctetString(data, r->basedn, strlen(r->basedn))) goto err;
+                if (!asn1_write_enumerated(data, r->scope)) goto err;
+                if (!asn1_write_enumerated(data, r->deref)) goto err;
+                if (!asn1_write_Integer(data, r->sizelimit)) goto err;
+                if (!asn1_write_Integer(data, r->timelimit)) goto err;
+                if (!asn1_write_BOOLEAN(data, r->attributesonly)) goto err;
                 if (!ldap_push_filter(data, r->tree)) {
                         return false;
+                }
                 asn1_push_tag(data, ASN1_SEQUENCE(0));
+                        goto err;
+                }
+                if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
                 for (i=0; i<r->num_attributes; i++) {
                         asn1_write_OctetString(data, r->attributes[i],
                                                strlen(r->attributes[i]));
+                }
                 asn1_pop_tag(data);
                 asn1_pop_tag(data);
+                        if (!asn1_write_OctetString(data, r->attributes[i],
+                                               strlen(r->attributes[i]))) goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_SearchResultEntry: {
                 struct ldap_SearchResEntry *r = &msg->r.SearchResultEntry;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_OctetString(data, r->dn, strlen(r->dn));
                 asn1_push_tag(data, ASN1_SEQUENCE(0));
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_OctetString(data, r->dn, strlen(r->dn))) goto err;
+                if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
                 for (i=0; i<r->num_attributes; i++) {
                         struct ldb_message_element *attr = &r->attributes[i];
                         asn1_push_tag(data, ASN1_SEQUENCE(0));
                         asn1_write_OctetString(data, attr->name,
                                                strlen(attr->name));
                         asn1_push_tag(data, ASN1_SEQUENCE(1));
+                        if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
+                        if (!asn1_write_OctetString(data, attr->name,
+                                               strlen(attr->name))) goto err;
+                        if (!asn1_push_tag(data, ASN1_SEQUENCE(1))) goto err;
                         for (j=0; j<attr->num_values; j++) {
                                 asn1_write_OctetString(data,
+                                if (!asn1_write_OctetString(data,
                                                        attr->values[j].data,
                                                        attr->values[j].length);
+                        }
                         asn1_pop_tag(data);
                         asn1_pop_tag(data);
+                }
                 asn1_pop_tag(data);
                 asn1_pop_tag(data);
+                                                       attr->values[j].length)) goto err;
+                        }
+                        if (!asn1_pop_tag(data)) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_SearchResultDone: {
                 struct ldap_Result *r = &msg->r.SearchResultDone;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, r);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, r)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_ModifyRequest: {
                 struct ldap_ModifyRequest *r = &msg->r.ModifyRequest;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_OctetString(data, r->dn, strlen(r->dn));
                 asn1_push_tag(data, ASN1_SEQUENCE(0));
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_OctetString(data, r->dn, strlen(r->dn))) goto err;
+                if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
                 for (i=0; i<r->num_mods; i++) {
                         struct ldb_message_element *attrib = &r->mods[i].attrib;
                         asn1_push_tag(data, ASN1_SEQUENCE(0));
                         asn1_write_enumerated(data, r->mods[i].type);
                         asn1_push_tag(data, ASN1_SEQUENCE(0));
                         asn1_write_OctetString(data, attrib->name,
                                                strlen(attrib->name));
                         asn1_push_tag(data, ASN1_SET);
+                        if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
+                        if (!asn1_write_enumerated(data, r->mods[i].type)) goto err;
+                        if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
+                        if (!asn1_write_OctetString(data, attrib->name,
+                                               strlen(attrib->name))) goto err;
+                        if (!asn1_push_tag(data, ASN1_SET)) goto err;
                         for (j=0; j<attrib->num_values; j++) {
                                 asn1_write_OctetString(data,
+                                if (!asn1_write_OctetString(data,
                                                        attrib->values[j].data,
                                                        attrib->values[j].length);
+                                                       attrib->values[j].length)) goto err;
+                        }
                         asn1_pop_tag(data);
                         asn1_pop_tag(data);
                         asn1_pop_tag(data);
+                        if (!asn1_pop_tag(data)) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                }
                 asn1_pop_tag(data);
                 asn1_pop_tag(data);
+                if (!asn1_pop_tag(data)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_ModifyResponse: {
                 struct ldap_Result *r = &msg->r.ModifyResponse;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, r);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, r)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_AddRequest: {
                 struct ldap_AddRequest *r = &msg->r.AddRequest;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_OctetString(data, r->dn, strlen(r->dn));
                 asn1_push_tag(data, ASN1_SEQUENCE(0));
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_OctetString(data, r->dn, strlen(r->dn))) goto err;
+                if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
                 for (i=0; i<r->num_attributes; i++) {
                         struct ldb_message_element *attrib = &r->attributes[i];
                         asn1_push_tag(data, ASN1_SEQUENCE(0));
                         asn1_write_OctetString(data, attrib->name,
                                                strlen(attrib->name));
                         asn1_push_tag(data, ASN1_SET);
+                        if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
+                        if (!asn1_write_OctetString(data, attrib->name,
+                                               strlen(attrib->name))) goto err;
+                        if (!asn1_push_tag(data, ASN1_SET)) goto err;
                         for (j=0; j<r->attributes[i].num_values; j++) {
                                 asn1_write_OctetString(data,
+                                if (!asn1_write_OctetString(data,
                                                        attrib->values[j].data,
                                                        attrib->values[j].length);
+                        }
                         asn1_pop_tag(data);
                         asn1_pop_tag(data);
+                }
                 asn1_pop_tag(data);
                 asn1_pop_tag(data);
+                                                       attrib->values[j].length)) goto err;
+                        }
+                        if (!asn1_pop_tag(data)) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_AddResponse: {
                 struct ldap_Result *r = &msg->r.AddResponse;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, r);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, r)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_DelRequest: {
                 struct ldap_DelRequest *r = &msg->r.DelRequest;
                 asn1_push_tag(data, ASN1_APPLICATION_SIMPLE(msg->type));
                 asn1_write(data, r->dn, strlen(r->dn));
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION_SIMPLE(msg->type))) goto err;
+                if (!asn1_write(data, r->dn, strlen(r->dn))) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_DelResponse: {
                 struct ldap_Result *r = &msg->r.DelResponse;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, r);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, r)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_ModifyDNRequest: {
                 struct ldap_ModifyDNRequest *r = &msg->r.ModifyDNRequest;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_OctetString(data, r->dn, strlen(r->dn));
                 asn1_write_OctetString(data, r->newrdn, strlen(r->newrdn));
                 asn1_write_BOOLEAN(data, r->deleteolddn);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_OctetString(data, r->dn, strlen(r->dn))) goto err;
+                if (!asn1_write_OctetString(data, r->newrdn, strlen(r->newrdn))) goto err;
+                if (!asn1_write_BOOLEAN(data, r->deleteolddn)) goto err;
                 if (r->newsuperior) {
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0));
                         asn1_write(data, r->newsuperior,
                                    strlen(r->newsuperior));
                         asn1_pop_tag(data);
+                }
                 asn1_pop_tag(data);
+                        if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0))) goto err;
+                        if (!asn1_write(data, r->newsuperior,
+                                   strlen(r->newsuperior))) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_ModifyDNResponse: {
                 struct ldap_Result *r = &msg->r.ModifyDNResponse;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, r);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, r)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_CompareRequest: {
                 struct ldap_CompareRequest *r = &msg->r.CompareRequest;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_OctetString(data, r->dn, strlen(r->dn));
                 asn1_push_tag(data, ASN1_SEQUENCE(0));
                 asn1_write_OctetString(data, r->attribute,
                                        strlen(r->attribute));
                 asn1_write_OctetString(data, r->value.data,
                                        r->value.length);
                 asn1_pop_tag(data);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_OctetString(data, r->dn, strlen(r->dn))) goto err;
+                if (!asn1_push_tag(data, ASN1_SEQUENCE(0))) goto err;
+                if (!asn1_write_OctetString(data, r->attribute,
+                                       strlen(r->attribute))) goto err;
+                if (!asn1_write_OctetString(data, r->value.data,
+                                       r->value.length)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_CompareResponse: {
                 struct ldap_Result *r = &msg->r.ModifyDNResponse;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, r);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, r)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_AbandonRequest: {
                 struct ldap_AbandonRequest *r = &msg->r.AbandonRequest;
                 asn1_push_tag(data, ASN1_APPLICATION_SIMPLE(msg->type));
                 asn1_write_implicit_Integer(data, r->messageid);
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION_SIMPLE(msg->type))) goto err;
+                if (!asn1_write_implicit_Integer(data, r->messageid)) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_SearchResultReference: {
                 struct ldap_SearchResRef *r = &msg->r.SearchResultReference;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_write_OctetString(data, r->referral, strlen(r->referral));
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_write_OctetString(data, r->referral, strlen(r->referral))) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_ExtendedRequest: {
                 struct ldap_ExtendedRequest *r = &msg->r.ExtendedRequest;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0));
                 asn1_write(data, r->oid, strlen(r->oid));
                 asn1_pop_tag(data);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(0))) goto err;
+                if (!asn1_write(data, r->oid, strlen(r->oid))) goto err;
+                if (!asn1_pop_tag(data)) goto err;
                 if (r->value) {
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(1));
                         asn1_write(data, r->value->data, r->value->length);
                         asn1_pop_tag(data);
+                }
                 asn1_pop_tag(data);
+                        if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(1))) goto err;
+                        if (!asn1_write(data, r->value->data, r->value->length)) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         case LDAP_TAG_ExtendedResponse: {
                 struct ldap_ExtendedResponse *r = &msg->r.ExtendedResponse;
                 asn1_push_tag(data, ASN1_APPLICATION(msg->type));
                 ldap_encode_response(data, &r->response);
+                if (!asn1_push_tag(data, ASN1_APPLICATION(msg->type))) goto err;
+                if (!ldap_encode_response(data, &r->response)) goto err;
                 if (r->oid) {
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(10));
                         asn1_write(data, r->oid, strlen(r->oid));
                         asn1_pop_tag(data);
+                        if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(10))) goto err;
+                        if (!asn1_write(data, r->oid, strlen(r->oid))) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                }
                 if (r->value) {
                         asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(11));
                         asn1_write(data, r->value->data, r->value->length);
                         asn1_pop_tag(data);
+                }
                 asn1_pop_tag(data);
+                        if (!asn1_push_tag(data, ASN1_CONTEXT_SIMPLE(11))) goto err;
+                        if (!asn1_write(data, r->value->data, r->value->length)) goto err;
+                        if (!asn1_pop_tag(data)) goto err;
+                }
+                if (!asn1_pop_tag(data)) goto err;
                 break;
+        }
         default:
                 return false;
+                goto err;
+        }
         if (msg->controls != NULL) {
                 asn1_push_tag(data, ASN1_CONTEXT(0));
+                if (!asn1_push_tag(data, ASN1_CONTEXT(0))) goto err;
                 for (i = 0; msg->controls[i] != NULL; i++) {
 …
                                                  control_handlers,
                                                  msg->controls[i])) {
                                 DEBUG(1,("Unable to encode control %s\n",
+                                DEBUG(0,("Unable to encode control %s\n",
                                          msg->controls[i]->oid));
+                                return false;
+                        }
+                }
+                asn1_pop_tag(data);
+        }
+        asn1_pop_tag(data);
+        if (data->has_error) {
+                asn1_free(data);
+                return false;
+        }
+        *result = data_blob_talloc(mem_ctx, data->data, data->length);
+                                goto err;
+                        }
+                }
+                if (!asn1_pop_tag(data)) goto err;
+        }
+        if (!asn1_pop_tag(data)) goto err;
+        if (!asn1_extract_blob(data, mem_ctx, result)) {
+                goto err;
+        }
         asn1_free(data);
         return true;
+  err:
+        asn1_free(data);
+        return false;
+}
 …
+{
         char *result = talloc_array(mem_ctx, char, blob.length+1);
+        if (result == NULL) {
+                return NULL;
+        }
         memcpy(result, blob.data, blob.length);
         result[blob.length] = '\0';
 …
         *result = blob2string_talloc(mem_ctx, string);
         data_blob_free(&string);
         return true;
+}
 static void ldap_decode_response(TALLOC_CTX *mem_ctx,
+        return *result ? true : false;
+}
+static bool ldap_decode_response(TALLOC_CTX *mem_ctx,
                                  struct asn1_data *data,
                                  struct ldap_Result *result)
+{
         asn1_read_enumerated(data, &result->resultcode);
         asn1_read_OctetString_talloc(mem_ctx, data, &result->dn);
         asn1_read_OctetString_talloc(mem_ctx, data, &result->errormessage);
+        if (!asn1_read_enumerated(data, &result->resultcode)) return false;
+        if (!asn1_read_OctetString_talloc(mem_ctx, data, &result->dn)) return false;
+        if (!asn1_read_OctetString_talloc(mem_ctx, data, &result->errormessage)) return false;
         if (asn1_peek_tag(data, ASN1_CONTEXT(3))) {
                 asn1_start_tag(data, ASN1_CONTEXT(3));
                 asn1_read_OctetString_talloc(mem_ctx, data, &result->referral);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, ASN1_CONTEXT(3))) return false;
+                if (!asn1_read_OctetString_talloc(mem_ctx, data, &result->referral)) return false;
+                if (!asn1_end_tag(data)) return false;
         } else {
                 result->referral = NULL;
+        }
+        return true;
+}
 …
         chunks[chunk_num]->length = strlen(value);
         chunks[chunk_num + 1] = '\0';
+        chunks[chunk_num + 1] = NULL;
         return chunks;
 …
                 DATA_BLOB value;
+                asn1_start_tag(data, ASN1_CONTEXT(filter_tag));
+                asn1_read_OctetString_talloc(mem_ctx, data, &attrib);
+                asn1_read_OctetString(data, mem_ctx, &value);
+                asn1_end_tag(data);
+                if ((data->has_error) || (attrib == NULL) || (value.data == NULL)) {
+                if (!asn1_start_tag(data, ASN1_CONTEXT(filter_tag))) goto failed;
+                if (!asn1_read_OctetString_talloc(mem_ctx, data, &attrib)) goto failed;
+                if (!asn1_read_OctetString(data, mem_ctx, &value)) goto failed;
+                if (!asn1_end_tag(data)) goto failed;
+                if (asn1_has_error(data) || (attrib == NULL) ||
+                    (value.data == NULL)) {
                         goto failed;
+                }
 …
                 ret->operation = LDB_OP_SUBSTRING;
                 ret->u.substring.attr = talloc_strndup(ret, (char *)attr.data, attr.length);
+                if (ret->u.substring.attr == NULL) {
+                        goto failed;
+                }
                 ret->u.substring.chunks = NULL;
                 ret->u.substring.start_with_wildcard = 1;
 …
                 while (asn1_tag_remaining(data)) {
                         asn1_peek_uint8(data, &subs_tag);
+                        if (!asn1_peek_uint8(data, &subs_tag)) goto failed;
                         subs_tag &= 0x1f;       /* strip off the asn1 stuff */
                         if (subs_tag > 2) goto failed;
                         asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(subs_tag));
                         asn1_read_LDAPString(data, mem_ctx, &value);
                         asn1_end_tag(data);
+                        if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(subs_tag))) goto failed;
+                        if (!asn1_read_LDAPString(data, mem_ctx, &value)) goto failed;
+                        if (!asn1_end_tag(data)) goto failed;
                         switch (subs_tag) {
 …
                 DATA_BLOB value;
+                asn1_start_tag(data, ASN1_CONTEXT(filter_tag));
+                asn1_read_OctetString_talloc(mem_ctx, data, &attrib);
+                asn1_read_OctetString(data, mem_ctx, &value);
+                asn1_end_tag(data);
+                if ((data->has_error) || (attrib == NULL) || (value.data == NULL)) {
+                if (!asn1_start_tag(data, ASN1_CONTEXT(filter_tag))) goto failed;
+                if (!asn1_read_OctetString_talloc(mem_ctx, data, &attrib)) goto failed;
+                if (!asn1_read_OctetString(data, mem_ctx, &value)) goto failed;
+                if (!asn1_end_tag(data)) goto failed;
+                if (asn1_has_error(data) || (attrib == NULL) ||
+                    (value.data == NULL)) {
                         goto failed;
+                }
 …
                 DATA_BLOB value;
+                asn1_start_tag(data, ASN1_CONTEXT(filter_tag));
+                asn1_read_OctetString_talloc(mem_ctx, data, &attrib);
+                asn1_read_OctetString(data, mem_ctx, &value);
+                asn1_end_tag(data);
+                if ((data->has_error) || (attrib == NULL) || (value.data == NULL)) {
+                if (!asn1_start_tag(data, ASN1_CONTEXT(filter_tag))) goto failed;
+                if (!asn1_read_OctetString_talloc(mem_ctx, data, &attrib)) goto failed;
+                if (!asn1_read_OctetString(data, mem_ctx, &value)) goto failed;
+                if (!asn1_end_tag(data)) goto failed;
+                if (asn1_has_error(data) || (attrib == NULL) ||
+                    (value.data == NULL)) {
                         goto failed;
+                }
 …
                 DATA_BLOB value;
+                asn1_start_tag(data, ASN1_CONTEXT(filter_tag));
+                asn1_read_OctetString_talloc(mem_ctx, data, &attrib);
+                asn1_read_OctetString(data, mem_ctx, &value);
+                asn1_end_tag(data);
+                if ((data->has_error) || (attrib == NULL) || (value.data == NULL)) {
+                if (!asn1_start_tag(data, ASN1_CONTEXT(filter_tag))) goto failed;
+                if (!asn1_read_OctetString_talloc(mem_ctx, data, &attrib)) goto failed;
+                if (!asn1_read_OctetString(data, mem_ctx, &value)) goto failed;
+                if (!asn1_end_tag(data)) goto failed;
+                if (asn1_has_error(data) || (attrib == NULL) ||
+                    (value.data == NULL)) {
                         goto failed;
+                }
 …
                 /* either oid or type must be defined */
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(1))) { /* optional */
                         asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(1));
                         asn1_read_LDAPString(data, ret, &oid);
                         asn1_end_tag(data);
+                        if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(1))) goto failed;
+                        if (!asn1_read_LDAPString(data, ret, &oid)) goto failed;
+                        if (!asn1_end_tag(data)) goto failed;
+                }
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(2))) {      /* optional  */
                         asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(2));
                         asn1_read_LDAPString(data, ret, &attr);
                         asn1_end_tag(data);
+                }
                 asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(3));
                 asn1_read_LDAPString(data, ret, &value);
                 asn1_end_tag(data);
+                        if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(2))) goto failed;
+                        if (!asn1_read_LDAPString(data, ret, &attr)) goto failed;
+                        if (!asn1_end_tag(data)) goto failed;
+                }
+                if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(3))) goto failed;
+                if (!asn1_read_LDAPString(data, ret, &value)) goto failed;
+                if (!asn1_end_tag(data)) goto failed;
                 /* dnAttributes is marked as BOOLEAN DEFAULT FALSE
                    it is not marked as OPTIONAL but openldap tools
 …
                    boolean value to be set */
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(4))) {
                         asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(4));
                         asn1_read_uint8(data, &dnAttributes);
                         asn1_end_tag(data);
+                        if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(4))) goto failed;
+                        if (!asn1_read_uint8(data, &dnAttributes)) goto failed;
+                        if (!asn1_end_tag(data)) goto failed;
                 } else {
                         dnAttributes = 0;
 …
                         } else {
                                 ret->u.extended.attr = talloc_strdup(ret, "*");
+                                if (ret->u.extended.attr == NULL) {
+                                        goto failed;
+                                }
+                        }
                         ret->u.extended.rule_id      = talloc_steal(ret, oid);
 …
 /* Decode a single LDAP attribute, possibly containing multiple values */
 static void ldap_decode_attrib(TALLOC_CTX *mem_ctx, struct asn1_data *data,
+static bool ldap_decode_attrib(TALLOC_CTX *mem_ctx, struct asn1_data *data,
                                struct ldb_message_element *attrib)
+{
         asn1_start_tag(data, ASN1_SEQUENCE(0));
         asn1_read_OctetString_talloc(mem_ctx, data, &attrib->name);
         asn1_start_tag(data, ASN1_SET);
+        if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) return false;
+        if (!asn1_read_OctetString_talloc(mem_ctx, data, &attrib->name)) return false;
+        if (!asn1_start_tag(data, ASN1_SET)) return false;
         while (asn1_peek_tag(data, ASN1_OCTET_STRING)) {
                 DATA_BLOB blob;
                 asn1_read_OctetString(data, mem_ctx, &blob);
+                if (!asn1_read_OctetString(data, mem_ctx, &blob)) return false;
                 add_value_to_attrib(mem_ctx, &blob, attrib);
+        }
+        asn1_end_tag(data);
+        asn1_end_tag(data);
+        if (!asn1_end_tag(data)) return false;
+        return asn1_end_tag(data);
+}
 /* Decode a set of LDAP attributes, as found in the dereference control */
 void ldap_decode_attribs_bare(TALLOC_CTX *mem_ctx, struct asn1_data *data,
+bool ldap_decode_attribs_bare(TALLOC_CTX *mem_ctx, struct asn1_data *data,
                               struct ldb_message_element **attributes,
                               int *num_attributes)
 …
                 struct ldb_message_element attrib;
                 ZERO_STRUCT(attrib);
                 ldap_decode_attrib(mem_ctx, data, &attrib);
+                if (!ldap_decode_attrib(mem_ctx, data, &attrib)) return false;
                 add_attrib_to_array_talloc(mem_ctx, &attrib,
                                            attributes, num_attributes);
+        }
+        return true;
+}
 /* Decode a set of LDAP attributes, as found in a search entry */
 static void ldap_decode_attribs(TALLOC_CTX *mem_ctx, struct asn1_data *data,
+static bool ldap_decode_attribs(TALLOC_CTX *mem_ctx, struct asn1_data *data,
                                 struct ldb_message_element **attributes,
                                 int *num_attributes)
+{
         asn1_start_tag(data, ASN1_SEQUENCE(0));
         ldap_decode_attribs_bare(mem_ctx, data,
                                  attributes, num_attributes);
         asn1_end_tag(data);
+        if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) return false;
+        if (!ldap_decode_attribs_bare(mem_ctx, data,
+                                 attributes, num_attributes)) return false;
+        return asn1_end_tag(data);
+}
 …
         uint8_t tag;
+        asn1_start_tag(data, ASN1_SEQUENCE(0));
+        asn1_read_Integer(data, &msg->messageid);
+        if (!asn1_peek_uint8(data, &tag))
+                return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+        if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) goto prot_err;
+        if (!asn1_read_Integer(data, &msg->messageid)) goto prot_err;
+        if (!asn1_peek_uint8(data, &tag)) goto prot_err;
         switch(tag) {
 …
                 struct ldap_BindRequest *r = &msg->r.BindRequest;
                 msg->type = LDAP_TAG_BindRequest;
                 asn1_start_tag(data, tag);
                 asn1_read_Integer(data, &r->version);
                 asn1_read_OctetString_talloc(msg, data, &r->dn);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!asn1_read_Integer(data, &r->version)) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->dn)) goto prot_err;
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(0))) {
                         int pwlen;
                         r->creds.password = "";
                         r->mechanism = LDAP_AUTH_MECH_SIMPLE;
                         asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(0));
+                        if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(0))) goto prot_err;
                         pwlen = asn1_tag_remaining(data);
                         if (pwlen == -1) {
                                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                                goto prot_err;
+                        }
                         if (pwlen != 0) {
 …
                                         return NT_STATUS_LDAP(LDAP_OPERATIONS_ERROR);
+                                }
                                 asn1_read(data, pw, pwlen);
+                                if (!asn1_read(data, pw, pwlen)) goto prot_err;
                                 pw[pwlen] = '\0';
                                 r->creds.password = pw;
+                        }
                         asn1_end_tag(data);
+                        if (!asn1_end_tag(data)) goto prot_err;
                 } else if (asn1_peek_tag(data, ASN1_CONTEXT(3))){
                         asn1_start_tag(data, ASN1_CONTEXT(3));
+                        if (!asn1_start_tag(data, ASN1_CONTEXT(3))) goto prot_err;
                         r->mechanism = LDAP_AUTH_MECH_SASL;
                         asn1_read_OctetString_talloc(msg, data, &r->creds.SASL.mechanism);
+                        if (!asn1_read_OctetString_talloc(msg, data, &r->creds.SASL.mechanism)) goto prot_err;
                         if (asn1_peek_tag(data, ASN1_OCTET_STRING)) { /* optional */
                                 DATA_BLOB tmp_blob = data_blob(NULL, 0);
                                 asn1_read_OctetString(data, msg, &tmp_blob);
+                                if (!asn1_read_OctetString(data, msg, &tmp_blob)) goto prot_err;
                                 r->creds.SASL.secblob = talloc(msg, DATA_BLOB);
                                 if (!r->creds.SASL.secblob) {
 …
                                 r->creds.SASL.secblob = NULL;
+                        }
                         asn1_end_tag(data);
+                        if (!asn1_end_tag(data)) goto prot_err;
                 } else {
                         /* Neither Simple nor SASL bind */
                         return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                }
                 asn1_end_tag(data);
+                        goto prot_err;
+                }
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_BindResponse *r = &msg->r.BindResponse;
                 msg->type = LDAP_TAG_BindResponse;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, &r->response);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, &r->response)) goto prot_err;
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(7))) {
                         DATA_BLOB tmp_blob = data_blob(NULL, 0);
                         asn1_read_ContextSimple(data, 7, &tmp_blob);
+                        if (!asn1_read_ContextSimple(data, 7, &tmp_blob)) goto prot_err;
                         r->SASL.secblob = talloc(msg, DATA_BLOB);
                         if (!r->SASL.secblob) {
 …
                         r->SASL.secblob = NULL;
+                }
                 asn1_end_tag(data);
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
         case ASN1_APPLICATION_SIMPLE(LDAP_TAG_UnbindRequest): {
                 msg->type = LDAP_TAG_UnbindRequest;
                 asn1_start_tag(data, tag);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 const char **attrs = NULL;
                 msg->type = LDAP_TAG_SearchRequest;
                 asn1_start_tag(data, tag);
                 asn1_read_OctetString_talloc(msg, data, &r->basedn);
                 asn1_read_enumerated(data, (int *)(void *)&(r->scope));
                 asn1_read_enumerated(data, (int *)(void *)&(r->deref));
                 asn1_read_Integer(data, &sizelimit);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->basedn)) goto prot_err;
+                if (!asn1_read_enumerated(data, (int *)(void *)&(r->scope))) goto prot_err;
+                if (!asn1_read_enumerated(data, (int *)(void *)&(r->deref))) goto prot_err;
+                if (!asn1_read_Integer(data, &sizelimit)) goto prot_err;
                 r->sizelimit = sizelimit;
                 asn1_read_Integer(data, &timelimit);
+                if (!asn1_read_Integer(data, &timelimit)) goto prot_err;
                 r->timelimit = timelimit;
                 asn1_read_BOOLEAN(data, &r->attributesonly);
+                if (!asn1_read_BOOLEAN(data, &r->attributesonly)) goto prot_err;
                 r->tree = ldap_decode_filter_tree(msg, data);
                 if (r->tree == NULL) {
                         return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                }
                 asn1_start_tag(data, ASN1_SEQUENCE(0));
+                        goto prot_err;
+                }
+                if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) goto prot_err;
                 r->num_attributes = 0;
                 r->attributes = NULL;
                 while (asn1_tag_remaining(data) > 0) {
+                while (asn1_tag_remaining(data) > 0) {
                         const char *attr;
                         if (!asn1_read_OctetString_talloc(msg, data,
                                                           &attr))
                                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                                goto prot_err;
                         if (!add_string_to_array(msg, attr,
                                                  &attrs,
                                                  &r->num_attributes))
                                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                                goto prot_err;
+                }
                 r->attributes = attrs;
                 asn1_end_tag(data);
                 asn1_end_tag(data);
+                if (!asn1_end_tag(data)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 r->attributes = NULL;
                 r->num_attributes = 0;
                 asn1_start_tag(data, tag);
                 asn1_read_OctetString_talloc(msg, data, &r->dn);
                 ldap_decode_attribs(msg, data, &r->attributes,
                                     &r->num_attributes);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->dn)) goto prot_err;
+                if (!ldap_decode_attribs(msg, data, &r->attributes,
+                                    &r->num_attributes)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_Result *r = &msg->r.SearchResultDone;
                 msg->type = LDAP_TAG_SearchResultDone;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, r);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, r)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_SearchResRef *r = &msg->r.SearchResultReference;
                 msg->type = LDAP_TAG_SearchResultReference;
                 asn1_start_tag(data, tag);
                 asn1_read_OctetString_talloc(msg, data, &r->referral);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->referral)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_ModifyRequest *r = &msg->r.ModifyRequest;
                 msg->type = LDAP_TAG_ModifyRequest;
                 asn1_start_tag(data, ASN1_APPLICATION(LDAP_TAG_ModifyRequest));
                 asn1_read_OctetString_talloc(msg, data, &r->dn);
                 asn1_start_tag(data, ASN1_SEQUENCE(0));
+                if (!asn1_start_tag(data, ASN1_APPLICATION(LDAP_TAG_ModifyRequest))) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->dn)) goto prot_err;
+                if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) goto prot_err;
                 r->num_mods = 0;
 …
                         int v;
                         ZERO_STRUCT(mod);
                         asn1_start_tag(data, ASN1_SEQUENCE(0));
                         asn1_read_enumerated(data, &v);
+                        if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) goto prot_err;
+                        if (!asn1_read_enumerated(data, &v)) goto prot_err;
                         mod.type = v;
                         ldap_decode_attrib(msg, data, &mod.attrib);
                         asn1_end_tag(data);
+                        if (!ldap_decode_attrib(msg, data, &mod.attrib)) goto prot_err;
+                        if (!asn1_end_tag(data)) goto prot_err;
                         if (!add_mod_to_array_talloc(msg, &mod,
                                                      &r->mods, &r->num_mods)) {
 …
+                }
                 asn1_end_tag(data);
                 asn1_end_tag(data);
+                if (!asn1_end_tag(data)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_Result *r = &msg->r.ModifyResponse;
                 msg->type = LDAP_TAG_ModifyResponse;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, r);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, r)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_AddRequest *r = &msg->r.AddRequest;
                 msg->type = LDAP_TAG_AddRequest;
                 asn1_start_tag(data, tag);
                 asn1_read_OctetString_talloc(msg, data, &r->dn);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->dn)) goto prot_err;
                 r->attributes = NULL;
                 r->num_attributes = 0;
                 ldap_decode_attribs(msg, data, &r->attributes,
                                     &r->num_attributes);
                 asn1_end_tag(data);
+                if (!ldap_decode_attribs(msg, data, &r->attributes,
+                                    &r->num_attributes)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_Result *r = &msg->r.AddResponse;
                 msg->type = LDAP_TAG_AddResponse;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, r);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, r)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 char *dn;
                 msg->type = LDAP_TAG_DelRequest;
                 asn1_start_tag(data,
                                ASN1_APPLICATION_SIMPLE(LDAP_TAG_DelRequest));
+                if (!asn1_start_tag(data,
+                               ASN1_APPLICATION_SIMPLE(LDAP_TAG_DelRequest))) goto prot_err;
                 len = asn1_tag_remaining(data);
                 if (len == -1) {
                         return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                        goto prot_err;
+                }
                 dn = talloc_array(msg, char, len+1);
                 if (dn == NULL)
                         break;
                 asn1_read(data, dn, len);
+                if (!asn1_read(data, dn, len)) goto prot_err;
                 dn[len] = '\0';
                 r->dn = dn;
                 asn1_end_tag(data);
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_Result *r = &msg->r.DelResponse;
                 msg->type = LDAP_TAG_DelResponse;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, r);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, r)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_ModifyDNRequest *r = &msg->r.ModifyDNRequest;
                 msg->type = LDAP_TAG_ModifyDNRequest;
                 asn1_start_tag(data,
                                ASN1_APPLICATION(LDAP_TAG_ModifyDNRequest));
                 asn1_read_OctetString_talloc(msg, data, &r->dn);
                 asn1_read_OctetString_talloc(msg, data, &r->newrdn);
                 asn1_read_BOOLEAN(data, &r->deleteolddn);
+                if (!asn1_start_tag(data,
+                               ASN1_APPLICATION(LDAP_TAG_ModifyDNRequest))) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->dn)) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->newrdn)) goto prot_err;
+                if (!asn1_read_BOOLEAN(data, &r->deleteolddn)) goto prot_err;
                 r->newsuperior = NULL;
                 if (asn1_tag_remaining(data) > 0) {
                         int len;
                         char *newsup;
                         asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(0));
+                        if (!asn1_start_tag(data, ASN1_CONTEXT_SIMPLE(0))) goto prot_err;
                         len = asn1_tag_remaining(data);
                         if (len == -1) {
                                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                                goto prot_err;
+                        }
                         newsup = talloc_array(msg, char, len+1);
 …
                                 return NT_STATUS_LDAP(LDAP_OPERATIONS_ERROR);
+                        }
                         asn1_read(data, newsup, len);
+                        if (!asn1_read(data, newsup, len)) goto prot_err;
                         newsup[len] = '\0';
                         r->newsuperior = newsup;
                         asn1_end_tag(data);
+                }
                 asn1_end_tag(data);
+                        if (!asn1_end_tag(data)) goto prot_err;
+                }
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_Result *r = &msg->r.ModifyDNResponse;
                 msg->type = LDAP_TAG_ModifyDNResponse;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, r);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, r)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_CompareRequest *r = &msg->r.CompareRequest;
                 msg->type = LDAP_TAG_CompareRequest;
                 asn1_start_tag(data,
                                ASN1_APPLICATION(LDAP_TAG_CompareRequest));
                 asn1_read_OctetString_talloc(msg, data, &r->dn);
                 asn1_start_tag(data, ASN1_SEQUENCE(0));
                 asn1_read_OctetString_talloc(msg, data, &r->attribute);
                 asn1_read_OctetString(data, msg, &r->value);
+                if (!asn1_start_tag(data,
+                               ASN1_APPLICATION(LDAP_TAG_CompareRequest))) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->dn)) goto prot_err;
+                if (!asn1_start_tag(data, ASN1_SEQUENCE(0))) goto prot_err;
+                if (!asn1_read_OctetString_talloc(msg, data, &r->attribute)) goto prot_err;
+                if (!asn1_read_OctetString(data, msg, &r->value)) goto prot_err;
                 if (r->value.data) {
                         talloc_steal(msg, r->value.data);
+                }
                 asn1_end_tag(data);
                 asn1_end_tag(data);
+                if (!asn1_end_tag(data)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_Result *r = &msg->r.CompareResponse;
                 msg->type = LDAP_TAG_CompareResponse;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, r);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, r)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 struct ldap_AbandonRequest *r = &msg->r.AbandonRequest;
                 msg->type = LDAP_TAG_AbandonRequest;
                 asn1_start_tag(data, tag);
                 asn1_read_implicit_Integer(data, &r->messageid);
                 asn1_end_tag(data);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!asn1_read_implicit_Integer(data, &r->messageid)) goto prot_err;
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 msg->type = LDAP_TAG_ExtendedRequest;
                 asn1_start_tag(data,tag);
+                if (!asn1_start_tag(data,tag)) goto prot_err;
                 if (!asn1_read_ContextSimple(data, 0, &tmp_blob)) {
                         return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                        goto prot_err;
+                }
                 r->oid = blob2string_talloc(msg, tmp_blob);
 …
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(1))) {
                         asn1_read_ContextSimple(data, 1, &tmp_blob);
+                        if (!asn1_read_ContextSimple(data, 1, &tmp_blob)) goto prot_err;
                         r->value = talloc(msg, DATA_BLOB);
                         if (!r->value) {
 …
+                }
                 asn1_end_tag(data);
+                if (!asn1_end_tag(data)) goto prot_err;
                 break;
+        }
 …
                 msg->type = LDAP_TAG_ExtendedResponse;
                 asn1_start_tag(data, tag);
                 ldap_decode_response(msg, data, &r->response);
+                if (!asn1_start_tag(data, tag)) goto prot_err;
+                if (!ldap_decode_response(msg, data, &r->response)) goto prot_err;
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(10))) {
                         asn1_read_ContextSimple(data, 1, &tmp_blob);
+                        if (!asn1_read_ContextSimple(data, 1, &tmp_blob)) goto prot_err;
                         r->oid = blob2string_talloc(msg, tmp_blob);
                         data_blob_free(&tmp_blob);
 …
                 if (asn1_peek_tag(data, ASN1_CONTEXT_SIMPLE(11))) {
                         asn1_read_ContextSimple(data, 1, &tmp_blob);
+                        if (!asn1_read_ContextSimple(data, 1, &tmp_blob)) goto prot_err;
                         r->value = talloc(msg, DATA_BLOB);
                         if (!r->value) {
 …
+                }
                 asn1_end_tag(data);
                 break;
+        }
         default:
                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                if (!asn1_end_tag(data)) goto prot_err;
+                break;
+        }
+        default:
+                goto prot_err;
+        }
 …
                 bool *decoded = NULL;
                 asn1_start_tag(data, ASN1_CONTEXT(0));
+                if (!asn1_start_tag(data, ASN1_CONTEXT(0))) goto prot_err;
                 while (asn1_peek_tag(data, ASN1_SEQUENCE(0))) {
 …
+                        }
                         if (!ldap_decode_control_wrapper(ctrl, data, ctrl[i], &value)) {
                                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+                        }
                         if (!ldap_decode_control_value(ctrl, value,
+                        if (!ldap_decode_control_wrapper(ctrl[i], data, ctrl[i], &value)) {
+                                goto prot_err;
+                        }
+                        if (!ldap_decode_control_value(ctrl[i], value,
                                                        control_handlers,
                                                        ctrl[i])) {
 …
                 msg->controls_decoded = decoded;
                 asn1_end_tag(data);
+        }
         asn1_end_tag(data);
         if ((data->has_error) || (data->nesting != NULL)) {
+                if (!asn1_end_tag(data)) goto prot_err;
+        }
+        if (!asn1_end_tag(data)) goto prot_err;
+        if (asn1_has_error(data) || asn1_has_nesting(data)) {
                 return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+        }
         return NT_STATUS_OK;
+  prot_err:
+        return NT_STATUS_LDAP(LDAP_PROTOCOL_ERROR);
+}
 …
 NTSTATUS ldap_full_packet(void *private_data, DATA_BLOB blob, size_t *packet_size)
+{
+        int ret;
         if (blob.length < 6) {
                 /*
 …
                 return STATUS_MORE_ENTRIES;
+        }
+        return asn1_peek_full_tag(blob, ASN1_SEQUENCE(0), packet_size);
+}
+        ret = asn1_peek_full_tag(blob, ASN1_SEQUENCE(0), packet_size);
+        if (ret != 0) {
+                return map_nt_error_from_unix_common(ret);
+        }
+        return NT_STATUS_OK;
+}

vendor/current/libcli/ldap/ldap_message.h

-              r740
+              r988
 #include "../libcli/ldap/ldap_errors.h"
-#if _SAMBA_BUILD_ == 3
-#include "lib/ldb_compat.h"
-#else
 #include <ldb.h>
-#endif
 enum ldap_request_tag {
 …
         bool attributesonly;
         struct ldb_parse_tree *tree;
         int num_attributes;
+        size_t num_attributes;
         const char * const *attributes;
 };
 …
                                   const char **result);
 void ldap_decode_attribs_bare(TALLOC_CTX *mem_ctx, struct asn1_data *data,
+bool ldap_decode_attribs_bare(TALLOC_CTX *mem_ctx, struct asn1_data *data,
                               struct ldb_message_element **attributes,
                               int *num_attributes);

vendor/current/libcli/ldap/ldap_ndr.c

-              r740
+              r988
 #include "includes.h"
-#if _SAMBA_BUILD_ == 3
-#include "lib/ldb_compat.h"
-#else
 #include <ldb.h>
-#endif
 #include "librpc/gen_ndr/ndr_security.h"
 #include "librpc/gen_ndr/ndr_misc.h"

vendor/current/libcli/ldap/wscript_build

-              r740
+              r988
 #!/usr/bin/env python
+bld.SAMBA_SUBSYSTEM('LIBCLI_LDAP_MESSAGE',
+        source='ldap_message.c',
+        public_deps='errors talloc ldb',
+        public_headers='ldap_message.h ldap_errors.h',
+        deps='samba-util ASN1_UTIL'
+        )
+bld.SAMBA_SUBSYSTEM('LIBCLI_LDAP_NDR',
+        source='ldap_ndr.c',
+        public_deps='errors talloc',
+        public_headers='ldap_ndr.h',
+        deps='samba-util ldb NDR_SECURITY tevent'
+        )
+bld.SAMBA_LIBRARY('cli-ldap-common',
+                  source='ldap_message.c ldap_ndr.c',
+                  public_deps='samba-errors talloc ldb',
+                  private_headers='ldap_message.h ldap_errors.h ldap_ndr.h',
+                  deps='samba-util asn1util NDR_SECURITY tevent',
+                  private_library=True)

vendor/current/libcli/named_pipe_auth/npa_tstream.c

-              r740
+              r988
 #include "../librpc/gen_ndr/ndr_named_pipe_auth.h"
 #include "../libcli/named_pipe_auth/npa_tstream.h"
+#if _SAMBA_BUILD_ == 4
+#include "libcli/raw/smb.h"
+#endif
+#include "../libcli/smb/smb_constants.h"
 static const struct tstream_context_ops tstream_npa_ops;
 …
                                                 &state->client);
         if (ret != 0) {
                 DEBUG(2, ("Invalid server address[%s:%u] - %s\n",
+                DEBUG(2, ("Invalid client address[%s:%u] - %s\n",
                           i4.client_addr, i4.client_port,
                           strerror(errno)));
 …
         return 0;
+}
+/* SOCKETPAIR for internal rpc communication */
+/* file_type is FILE_TYPE_BYTE_MODE_PIPE or FILE_TYPE_MESSAGE_MODE_PIPE */
+int _tstream_npa_socketpair(uint16_t file_type,
+                            TALLOC_CTX *mem_ctx1,
+                            struct tstream_context **pstream1,
+                            TALLOC_CTX *mem_ctx2,
+                            struct tstream_context **pstream2,
+                            const char *location)
+{
+        struct tstream_context *stream1 = NULL;
+        struct tstream_context *stream2 = NULL;
+        int fds[2];
+        int fd1;
+        int fd2;
+        int rc;
+        bool ok;
+        rc = socketpair(AF_UNIX, SOCK_STREAM, 0, fds);
+        if (rc == -1) {
+                return -1;
+        }
+        fd1 = fds[0];
+        fd2 = fds[1];
+        ok = smb_set_close_on_exec(fd1);
+        if (!ok) {
+                goto close_fail;
+        }
+        ok = smb_set_close_on_exec(fd2);
+        if (!ok) {
+                goto close_fail;
+        }
+        rc = set_blocking(fd1, false);
+        if (rc == -1) {
+                goto close_fail;
+        }
+        rc = set_blocking(fd2, false);
+        if (rc == -1) {
+                goto close_fail;
+        }
+        rc = _tstream_npa_existing_socket(mem_ctx1,
+                                          fd1,
+                                          file_type,
+                                          &stream1,
+                                          location);
+        if (rc == -1) {
+                goto close_fail;
+        }
+        rc = _tstream_npa_existing_socket(mem_ctx2,
+                                          fd2,
+                                          file_type,
+                                          &stream2,
+                                          location);
+        if (rc == -1) {
+                int sys_errno = errno;
+                talloc_free(stream1);
+                close(fd2);
+                errno = sys_errno;
+                return -1;
+        }
+        *pstream1 = stream1;
+        *pstream2 = stream2;
+        return 0;
+close_fail:
+        {
+                int sys_errno = errno;
+                close(fd1);
+                close(fd2);
+                errno = sys_errno;
+                return -1;
+        }
+}

vendor/current/libcli/named_pipe_auth/npa_tstream.h

-              r740
+              r988
                                           __location__)
+int _tstream_npa_socketpair(uint16_t file_type,
+                            TALLOC_CTX *mem_ctx1,
+                            struct tstream_context **pstream1,
+                            TALLOC_CTX *mem_ctx2,
+                            struct tstream_context **pstream2,
+                            const char *location);
+#define tstream_npa_socketpair(ft, mem1, stream1, mem2, stream2) \
+        _tstream_npa_socketpair(ft, mem1, stream1, mem2, stream2, \
+                                __location__)
 #endif /* NPA_TSTREAM_H */

vendor/current/libcli/named_pipe_auth/wscript_build

-              r740
+              r988
+bld.SAMBA_SUBSYSTEM('NAMED_PIPE_AUTH_TSTREAM',
+        source='npa_tstream.c',
+        public_deps='NDR_NAMED_PIPE_AUTH tevent LIBTSOCKET'
+        )
+bld.SAMBA_LIBRARY('npa_tstream',
+                  source='npa_tstream.c',
+                  private_library=True,
+                  public_deps='NDR_NAMED_PIPE_AUTH tevent LIBTSOCKET'
+                  )

vendor/current/libcli/nbt/libnbt.h

-              r740
+              r988
 #include "librpc/gen_ndr/nbt.h"
 #include "librpc/ndr/libndr.h"
+#include "system/network.h"
+#include "lib/util/xfile.h"
 /*
   possible states for pending requests
 …
+NDR_SCALAR_PROTO(wrepl_nbt_name, const struct nbt_name *)
+NDR_SCALAR_PROTO(nbt_string, const char *)
+NDR_SCALAR_PTR_PROTO(wrepl_nbt_name, struct nbt_name)
 NDR_BUFFER_PROTO(nbt_name, struct nbt_name)
 NTSTATUS nbt_rcode_to_ntstatus(uint8_t rcode);
 …
                                           int *return_count);
-NTSTATUS resolve_dns_hosts_file_as_sockaddr(const char *dns_hosts_file,
-                                            const char *name, bool srv_lookup,
-                                            TALLOC_CTX *mem_ctx,
-                                            struct sockaddr_storage **return_iplist,
-                                            int *return_count);
 #endif /* __LIBNBT_H__ */

vendor/current/libcli/nbt/namerefresh.c

r740	r988
332	332
333	333	if (!tevent_req_poll(subreq, ev)) {
334		status = map_nt_error_from_unix(errno);
	334	status = map_nt_error_from_unix_common(errno);
335	335	talloc_free(frame);
336	336	return status;

vendor/current/libcli/nbt/nameregister.c

-              r740
+              r988
         if (!tevent_req_poll(subreq, ev)) {
                 status = map_nt_error_from_unix(errno);
+                status = map_nt_error_from_unix_common(errno);
                 talloc_free(frame);
                 return status;
 …
         if (!tevent_req_poll(subreq, ev)) {
                 status = map_nt_error_from_unix(errno);
+                status = map_nt_error_from_unix_common(errno);
                 talloc_free(frame);
                 return status;

vendor/current/libcli/nbt/nbtname.c

-              r740
+              r988
 #include "system/locale.h"
 #include "lib/util/util_net.h"
+/* don't allow an unlimited number of name components */
+#define MAX_COMPONENTS 10
+/**
+  print a nbt string
+*/
+_PUBLIC_ void ndr_print_nbt_string(struct ndr_print *ndr, const char *name, const char *s)
+{
+        ndr_print_string(ndr, name, s);
+}
+/*
+  pull one component of a nbt_string
+*/
+static enum ndr_err_code ndr_pull_component(struct ndr_pull *ndr,
+                                            uint8_t **component,
+                                            uint32_t *offset,
+                                            uint32_t *max_offset)
+{
+        uint8_t len;
+        unsigned int loops = 0;
+        while (loops < 5) {
+                if (*offset >= ndr->data_size) {
+                        return ndr_pull_error(ndr, NDR_ERR_STRING,
+                                              "BAD NBT NAME component");
+                }
+                len = ndr->data[*offset];
+                if (len == 0) {
+                        *offset += 1;
+                        *max_offset = MAX(*max_offset, *offset);
+                        *component = NULL;
+                        return NDR_ERR_SUCCESS;
+                }
+                if ((len & 0xC0) == 0xC0) {
+                        /* its a label pointer */
+                        if (1 + *offset >= ndr->data_size) {
+                                return ndr_pull_error(ndr, NDR_ERR_STRING,
+                                                      "BAD NBT NAME component");
+                        }
+                        *max_offset = MAX(*max_offset, *offset + 2);
+                        *offset = ((len&0x3F)<<8) | ndr->data[1 + *offset];
+                        *max_offset = MAX(*max_offset, *offset);
+                        loops++;
+                        continue;
+                }
+                if ((len & 0xC0) != 0) {
+                        /* its a reserved length field */
+                        return ndr_pull_error(ndr, NDR_ERR_STRING,
+                                              "BAD NBT NAME component");
+                }
+                if (*offset + len + 2 > ndr->data_size) {
+                        return ndr_pull_error(ndr, NDR_ERR_STRING,
+                                              "BAD NBT NAME component");
+                }
+                *component = (uint8_t*)talloc_strndup(
+                        ndr->current_mem_ctx,
+                        (const char *)&ndr->data[1 + *offset], len);
+                NDR_ERR_HAVE_NO_MEMORY(*component);
+                *offset += len + 1;
+                *max_offset = MAX(*max_offset, *offset);
+                return NDR_ERR_SUCCESS;
+        }
+        /* too many pointers */
+        return ndr_pull_error(ndr, NDR_ERR_STRING, "BAD NBT NAME component");
+}
+/**
+  pull a nbt_string from the wire
+*/
+_PUBLIC_ enum ndr_err_code ndr_pull_nbt_string(struct ndr_pull *ndr, int ndr_flags, const char **s)
+{
+        uint32_t offset = ndr->offset;
+        uint32_t max_offset = offset;
+        unsigned num_components;
+        char *name;
+        if (!(ndr_flags & NDR_SCALARS)) {
+                return NDR_ERR_SUCCESS;
+        }
+        name = NULL;
+        /* break up name into a list of components */
+        for (num_components=0;num_components<MAX_COMPONENTS;num_components++) {
+                uint8_t *component = NULL;
+                NDR_CHECK(ndr_pull_component(ndr, &component, &offset, &max_offset));
+                if (component == NULL) break;
+                if (name) {
+                        name = talloc_asprintf_append_buffer(name, ".%s", component);
+                        NDR_ERR_HAVE_NO_MEMORY(name);
+                } else {
+                        name = (char *)component;
+                }
+        }
+        if (num_components == MAX_COMPONENTS) {
+                return ndr_pull_error(ndr, NDR_ERR_STRING,
+                                      "BAD NBT NAME too many components");
+        }
+        if (num_components == 0) {
+                name = talloc_strdup(ndr->current_mem_ctx, "");
+                NDR_ERR_HAVE_NO_MEMORY(name);
+        }
+        (*s) = name;
+        ndr->offset = max_offset;
+        return NDR_ERR_SUCCESS;
+}
+/**
+  push a nbt string to the wire
+*/
+_PUBLIC_ enum ndr_err_code ndr_push_nbt_string(struct ndr_push *ndr, int ndr_flags, const char *s)
+{
+        if (!(ndr_flags & NDR_SCALARS)) {
+                return NDR_ERR_SUCCESS;
+        }
+        while (s && *s) {
+                enum ndr_err_code ndr_err;
+                char *compname;
+                size_t complen;
+                uint32_t offset;
+                /* see if we have pushed the remaing string allready,
+                 * if so we use a label pointer to this string
+                 */
+                ndr_err = ndr_token_retrieve_cmp_fn(&ndr->nbt_string_list, s, &offset, (comparison_fn_t)strcmp, false);
+                if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        uint8_t b[2];
+                        if (offset > 0x3FFF) {
+                                return ndr_push_error(ndr, NDR_ERR_STRING,
+                                                      "offset for nbt string label pointer %u[%08X] > 0x00003FFF",
+                                                      offset, offset);
+                        }
+                        b[0] = 0xC0 | (offset>>8);
+                        b[1] = (offset & 0xFF);
+                        return ndr_push_bytes(ndr, b, 2);
+                }
+                complen = strcspn(s, ".");
+                /* we need to make sure the length fits into 6 bytes */
+                if (complen > 0x3F) {
+                        return ndr_push_error(ndr, NDR_ERR_STRING,
+                                              "component length %u[%08X] > 0x0000003F",
+                                              (unsigned)complen, (unsigned)complen);
+                }
+                compname = talloc_asprintf(ndr, "%c%*.*s",
+                                                (unsigned char)complen,
+                                                (unsigned char)complen,
+                                                (unsigned char)complen, s);
+                NDR_ERR_HAVE_NO_MEMORY(compname);
+                /* remember the current componemt + the rest of the string
+                 * so it can be reused later
+                 */
+                NDR_CHECK(ndr_token_store(ndr, &ndr->nbt_string_list, s, ndr->offset));
+                /* push just this component into the blob */
+                NDR_CHECK(ndr_push_bytes(ndr, (const uint8_t *)compname, complen+1));
+                talloc_free(compname);
+                s += complen;
+                if (*s == '.') s++;
+        }
+        /* if we reach the end of the string and have pushed the last component
+         * without using a label pointer, we need to terminate the string
+         */
+        return ndr_push_bytes(ndr, (const uint8_t *)"", 1);
+}
+#include "libcli/nbt/libnbt.h"
 /*
 …
   pull a nbt name, WINS Replication uses another on wire format for nbt name
 */
 _PUBLIC_ enum ndr_err_code ndr_pull_wrepl_nbt_name(struct ndr_pull *ndr, int ndr_flags, const struct nbt_name **_r)
+_PUBLIC_ enum ndr_err_code ndr_pull_wrepl_nbt_name(struct ndr_pull *ndr, int ndr_flags, struct nbt_name **_r)
+{
         struct nbt_name *r;

vendor/current/libcli/nbt/nbtsocket.c

-              r740
+              r988
+        }
         if (req->nbtsock->send_queue == NULL) {
                 EVENT_FD_NOT_WRITEABLE(req->nbtsock->fde);
+                TEVENT_FD_NOT_WRITEABLE(req->nbtsock->fde);
+        }
         if (req->nbtsock->num_pending == 0 &&
             req->nbtsock->incoming.handler == NULL) {
                 EVENT_FD_NOT_READABLE(req->nbtsock->fde);
+                TEVENT_FD_NOT_READABLE(req->nbtsock->fde);
+        }
         return 0;
 …
                         talloc_free(req);
                 } else {
                         EVENT_FD_READABLE(nbtsock->fde);
+                        TEVENT_FD_READABLE(nbtsock->fde);
                         nbtsock->num_pending++;
+                }
+        }
         EVENT_FD_NOT_WRITEABLE(nbtsock->fde);
+        TEVENT_FD_NOT_WRITEABLE(nbtsock->fde);
         talloc_free(tmp_ctx);
         return;
 …
         if (req->num_retries != 0) {
                 req->num_retries--;
                 req->te = event_add_timed(req->nbtsock->event_ctx, req,
                                           timeval_add(&t, req->timeout, 0),
                                           nbt_name_socket_timeout, req);
+                req->te = tevent_add_timer(req->nbtsock->event_ctx, req,
+                                           timeval_add(&t, req->timeout, 0),
+                                           nbt_name_socket_timeout, req);
                 if (req->state != NBT_REQUEST_SEND) {
                         req->state = NBT_REQUEST_SEND;
+                        DLIST_ADD_END(req->nbtsock->send_queue, req,
+                                      struct nbt_name_request *);
+                }
+                EVENT_FD_WRITEABLE(req->nbtsock->fde);
+                        DLIST_ADD_END(req->nbtsock->send_queue, req);
+                }
+                TEVENT_FD_WRITEABLE(req->nbtsock->fde);
                 return;
+        }
 …
+                }
                 req->timeout = ttl;
                 req->te = event_add_timed(req->nbtsock->event_ctx, req,
                                           timeval_current_ofs(req->timeout, 0),
                                           nbt_name_socket_timeout, req);
+                req->te = tevent_add_timer(req->nbtsock->event_ctx, req,
+                                           timeval_current_ofs(req->timeout, 0),
+                                           nbt_name_socket_timeout, req);
                 return;
+        }
 …
         struct nbt_name_socket *nbtsock = talloc_get_type(private_data,
                                                           struct nbt_name_socket);
         if (flags & EVENT_FD_WRITE) {
+        if (flags & TEVENT_FD_WRITE) {
                 nbt_name_socket_send(nbtsock);
+        }
         if (flags & EVENT_FD_READ) {
+        if (flags & TEVENT_FD_READ) {
                 nbt_name_socket_recv(nbtsock);
+        }
 …
         nbtsock->unexpected.handler = NULL;
         nbtsock->fde = event_add_fd(nbtsock->event_ctx, nbtsock,
                                     socket_get_fd(nbtsock->sock), 0,
                                     nbt_name_socket_handler, nbtsock);
+        nbtsock->fde = tevent_add_fd(nbtsock->event_ctx, nbtsock,
+                                     socket_get_fd(nbtsock->sock), 0,
+                                     nbt_name_socket_handler, nbtsock);
         return nbtsock;
 …
         req->name_trn_id     = id;
         req->te = event_add_timed(nbtsock->event_ctx, req,
                                   timeval_current_ofs(req->timeout, 0),
                                   nbt_name_socket_timeout, req);
+        req->te = tevent_add_timer(nbtsock->event_ctx, req,
+                                   timeval_current_ofs(req->timeout, 0),
+                                   nbt_name_socket_timeout, req);
         talloc_set_destructor(req, nbt_name_request_destructor);
 …
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) goto failed;
         DLIST_ADD_END(nbtsock->send_queue, req, struct nbt_name_request *);
+        DLIST_ADD_END(nbtsock->send_queue, req);
         if (DEBUGLVL(10)) {
 …
+        }
         EVENT_FD_WRITEABLE(nbtsock->fde);
+        TEVENT_FD_WRITEABLE(nbtsock->fde);
         return req;
 …
+        }
         DLIST_ADD_END(nbtsock->send_queue, req, struct nbt_name_request *);
         EVENT_FD_WRITEABLE(nbtsock->fde);
+        DLIST_ADD_END(nbtsock->send_queue, req);
+        TEVENT_FD_WRITEABLE(nbtsock->fde);
         return NT_STATUS_OK;
 …
         while (req->state < NBT_REQUEST_DONE) {
                 if (event_loop_once(req->nbtsock->event_ctx) != 0) {
+                if (tevent_loop_once(req->nbtsock->event_ctx) != 0) {
                         req->state = NBT_REQUEST_ERROR;
                         req->status = NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 …
         nbtsock->incoming.handler = handler;
         nbtsock->incoming.private_data = private_data;
         EVENT_FD_READABLE(nbtsock->fde);
+        TEVENT_FD_READABLE(nbtsock->fde);
         return NT_STATUS_OK;
+}
 …
         nbtsock->unexpected.handler = handler;
         nbtsock->unexpected.private_data = private_data;
         EVENT_FD_READABLE(nbtsock->fde);
+        TEVENT_FD_READABLE(nbtsock->fde);
         return NT_STATUS_OK;
+}

vendor/current/libcli/nbt/pynbt.c

-              r740
+              r988
 #include "includes.h"
 #include "libcli/util/pyerrors.h"
 #include "scripting/python/modules.h"
+#include "python/modules.h"
 #include "../libcli/nbt/libnbt.h"
 #include "lib/events/events.h"
 void initnetbios(void);
-#ifndef Py_RETURN_NONE
-#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
-#endif
 extern PyTypeObject nbt_node_Type;

vendor/current/libcli/nbt/tools/nmblookup.c

-              r740
+              r988
 #include "param/param.h"
+#include <string.h>
+#define MAX_NETBIOSNAME_LEN 16
 /* command line options */
 static struct {
 …
         struct nbt_name_socket *nbtsock;
         NTSTATUS status = NT_STATUS_OK;
+        size_t nbt_len;
         bool ret = true;
 …
         } else {
                 node_name = talloc_strdup(tmp_ctx, name);
+        }
+        nbt_len = strlen(node_name);
+        if (nbt_len > MAX_NETBIOSNAME_LEN - 1) {
+                printf("The specified netbios name [%s] is too long.\n",
+                       node_name);
+                talloc_free(tmp_ctx);
+                return false;
+        }
 …
                 int i, num_interfaces;
                 num_interfaces = iface_count(ifaces);
+                num_interfaces = iface_list_count(ifaces);
                 for (i=0;i<num_interfaces;i++) {
                         const char *bcast = iface_n_bcast(ifaces, i);
+                        const char *bcast = iface_list_n_bcast(ifaces, i);
                         if (bcast == NULL) continue;
                         status = do_node_query(nbtsock, bcast, nbt_port,
 …
+        }
         load_interfaces(NULL, lpcfg_interfaces(cmdline_lp_ctx), &ifaces);
+        load_interface_list(NULL, cmdline_lp_ctx, &ifaces);
         ev = s4_event_context_init(talloc_autofree_context());

vendor/current/libcli/nbt/wscript_build

-              r740
+              r988
+                    )
+if bld.env._SAMBA_BUILD_ == 4:
+    bld.SAMBA_LIBRARY('cli-nbt',
+                      source='nbtsocket.c namequery.c nameregister.c namerefresh.c namerelease.c dns_hosts_file.c',
+                      public_deps='ndr NDR_NBT tevent UTIL_TEVENT NDR_SECURITY samba_socket samba-util lmhosts',
+                      private_library=True
+                      )
+bld.SAMBA_LIBRARY('cli-nbt',
+                  source='nbtsocket.c namequery.c nameregister.c namerefresh.c namerelease.c',
+                  public_deps='ndr ndr_nbt tevent tevent-util NDR_SECURITY samba_socket samba-util lmhosts',
+                  private_library=True
+                  )
+    bld.SAMBA_BINARY('nmblookup',
+                     source='tools/nmblookup.c',
+                     manpages='man/nmblookup.1',
+                     deps='samba-hostconfig samba-util cli-nbt popt POPT_SAMBA netif LIBCLI_RESOLVE'
+                     )
+bld.SAMBA_BINARY('nmblookup' + bld.env.suffix4,
+                 source='tools/nmblookup.c',
+                 manpages='man/nmblookup4.1',
+                 deps='samba-hostconfig samba-util cli-nbt popt POPT_SAMBA netif LIBCLI_RESOLVE',
+                 install=False
+                 )
     bld.SAMBA_PYTHON('python_netbios',
                      source='pynbt.c',
                      public_deps='cli-nbt DYNCONFIG samba-hostconfig',
                      realname='samba/netbios.so'
+                     )
+bld.SAMBA_PYTHON('python_netbios',
+                 source='pynbt.c',
+                 public_deps='cli-nbt DYNCONFIG samba-hostconfig',
+                 realname='samba/netbios.so'
+                 )

vendor/current/libcli/netlogon/netlogon.c

-              r740
+              r988
                         ntver);
                 if (ndr->offset < ndr->data_size) {
+                        ndr_err = ndr_pull_error(ndr, NDR_ERR_UNREAD_BYTES,
+                                                 "not all bytes consumed ofs[%u] size[%u]",
+                                                 ndr->offset, ndr->data_size);
+                        TALLOC_FREE(ndr);
+                        /*
+                         * We need to handle a bug in FreeIPA (at least <= 4.1.2).
+                         *
+                         * They include the ip address information without setting
+                         * NETLOGON_NT_VERSION_5EX_WITH_IP, while using
+                         * ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX instead of
+                         * ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX_with_flags.
+                         */
+                        ndr_err = ndr_pull_struct_blob_all(data, mem_ctx,
+                                                   &response->data.nt5,
+                                                   (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
+                }
                 response->ntver = NETLOGON_NT_VERSION_5EX;

vendor/current/libcli/netlogon/netlogon.h

-              r740
+              r988
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "librpc/gen_ndr/ndr_security.h"
-#include "librpc/gen_ndr/ndr_svcctl.h"
-#include "librpc/gen_ndr/ndr_samr.h"
-struct netlogon_samlogon_response
+{
-        uint32_t ntver;
-        union {
-                struct NETLOGON_SAM_LOGON_RESPONSE_NT40 nt4;
-                struct NETLOGON_SAM_LOGON_RESPONSE nt5;
-                struct NETLOGON_SAM_LOGON_RESPONSE_EX nt5_ex;
-        } data;
-};
 struct nbt_netlogon_response
 …
 #include "../libcli/netlogon/netlogon_proto.h"
-#include "../libcli/netlogon/ndr_netlogon_proto.h"
 #endif /* __CLDAP_SERVER_PROTO_H__ */

vendor/current/libcli/netlogon/wscript_build

-              r740
+              r988
 #!/usr/bin/env python
-bld.SAMBA_SUBSYSTEM('LIBCLI_NDR_NETLOGON',
-        source='ndr_netlogon.c',
-        public_deps='ndr NDR_SECURITY'
+        )
 bld.SAMBA_SUBSYSTEM('LIBCLI_NETLOGON',
         source='netlogon.c',
         public_deps='samba-util LIBCLI_NDR_NETLOGON'
+        public_deps='samba-util ndr_nbt'
+        )

vendor/current/libcli/registry/wscript_build

-              r740
+              r988
 bld.SAMBA_SUBSYSTEM('util_reg',
+bld.SAMBA_LIBRARY('util_reg',
                     source='util_reg.c',
+                    deps='ndr')
+                    deps='ndr',
+                    private_library=True)

vendor/current/libcli/security/access_check.c

-              r746
+              r988
         uint32_t bits_remaining;
         uint32_t explicitly_denied_bits = 0;
+        /*
+         * Up until Windows Server 2008, owner always had these rights. Now
+         * we have to use Owner Rights perms if they are on the file.
+         *
+         * In addition we have to accumulate these bits and apply them
+         * correctly. See bug #8795
+         */
+        uint32_t owner_rights_allowed = 0;
+        uint32_t owner_rights_denied = 0;
+        bool owner_rights_default = true;
         *access_granted = access_desired;
 …
+        }
-        /* the owner always gets SEC_STD_WRITE_DAC and SEC_STD_READ_CONTROL */
-        if ((bits_remaining & (SEC_STD_WRITE_DAC|SEC_STD_READ_CONTROL)) &&
-            security_token_has_sid(token, sd->owner_sid)) {
-                bits_remaining &= ~(SEC_STD_WRITE_DAC|SEC_STD_READ_CONTROL);
+        }
         /* a NULL dacl allows access */
         if ((sd->type & SEC_DESC_DACL_PRESENT) && sd->dacl == NULL) {
 …
+                }
+                /*
+                 * We need the Owner Rights permissions to ensure we
+                 * give or deny the correct permissions to the owner. Replace
+                 * owner_rights with the perms here if it is present.
+                 *
+                 * We don't care if we are not the owner because that is taken
+                 * care of below when we check if our token has the owner SID.
+                 *
+                 */
+                if (dom_sid_equal(&ace->trustee, &global_sid_Owner_Rights)) {
+                        if (ace->type == SEC_ACE_TYPE_ACCESS_ALLOWED) {
+                                owner_rights_allowed |= ace->access_mask;
+                                owner_rights_default = false;
+                        } else if (ace->type == SEC_ACE_TYPE_ACCESS_DENIED) {
+                                owner_rights_denied |= ace->access_mask;
+                                owner_rights_default = false;
+                        }
+                        continue;
+                }
                 if (!security_token_has_sid(token, &ace->trustee)) {
                         continue;
 …
+        }
+        /* Explicitly denied bits always override */
         bits_remaining |= explicitly_denied_bits;
+        /* The owner always gets owner rights as defined above. */
+        if (security_token_has_sid(token, sd->owner_sid)) {
+                if (owner_rights_default) {
+                        /*
+                         * Just remove them, no need to check if they are
+                         * there.
+                         */
+                        bits_remaining &= ~(SEC_STD_WRITE_DAC |
+                                                SEC_STD_READ_CONTROL);
+                } else {
+                        bits_remaining &= ~owner_rights_allowed;
+                        bits_remaining |= owner_rights_denied;
+                }
+        }
         /*
 …
+        }
-        /* TODO: remove this, as it is file server specific */
-        if ((bits_remaining & SEC_RIGHTS_PRIV_RESTORE) &&
-            security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
-                bits_remaining &= ~(SEC_RIGHTS_PRIV_RESTORE);
+        }
-        if ((bits_remaining & SEC_RIGHTS_PRIV_BACKUP) &&
-            security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
-                bits_remaining &= ~(SEC_RIGHTS_PRIV_BACKUP);
+        }
         if ((bits_remaining & SEC_STD_WRITE_OWNER) &&
              security_token_has_privilege(token, SEC_PRIV_TAKE_OWNERSHIP)) {
 …
+}
+/*
+  The main entry point for access checking FOR THE FILE SERVER ONLY !
+  If returning ACCESS_DENIED this function returns the denied bits in
+  the uint32_t pointed to by the access_granted pointer.
+*/
+NTSTATUS se_file_access_check(const struct security_descriptor *sd,
+                          const struct security_token *token,
+                          bool priv_open_requested,
+                          uint32_t access_desired,
+                          uint32_t *access_granted)
+{
+        uint32_t bits_remaining;
+        NTSTATUS status;
+        if (!priv_open_requested) {
+                /* Fall back to generic se_access_check(). */
+                return se_access_check(sd,
+                                token,
+                                access_desired,
+                                access_granted);
+        }
+        /*
+         * We need to handle the maximum allowed flag
+         * outside of se_access_check(), as we need to
+         * add in the access allowed by the privileges
+         * as well.
+         */
+        if (access_desired & SEC_FLAG_MAXIMUM_ALLOWED) {
+                uint32_t orig_access_desired = access_desired;
+                access_desired |= access_check_max_allowed(sd, token);
+                access_desired &= ~SEC_FLAG_MAXIMUM_ALLOWED;
+                if (security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
+                        access_desired |= SEC_RIGHTS_PRIV_BACKUP;
+                }
+                if (security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
+                        access_desired |= SEC_RIGHTS_PRIV_RESTORE;
+                }
+                DEBUG(10,("se_file_access_check: MAX desired = 0x%x "
+                        "mapped to 0x%x\n",
+                        orig_access_desired,
+                        access_desired));
+        }
+        status = se_access_check(sd,
+                                token,
+                                access_desired,
+                                access_granted);
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
+                return status;
+        }
+        bits_remaining = *access_granted;
+        /* Check if we should override with privileges. */
+        if ((bits_remaining & SEC_RIGHTS_PRIV_BACKUP) &&
+            security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
+                bits_remaining &= ~(SEC_RIGHTS_PRIV_BACKUP);
+        }
+        if ((bits_remaining & SEC_RIGHTS_PRIV_RESTORE) &&
+            security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
+                bits_remaining &= ~(SEC_RIGHTS_PRIV_RESTORE);
+        }
+        if (bits_remaining != 0) {
+                *access_granted = bits_remaining;
+                return NT_STATUS_ACCESS_DENIED;
+        }
+        return NT_STATUS_OK;
+}
 static const struct GUID *get_ace_object_type(struct security_ace *ace)
+{
+        struct GUID *type;
+        if (ace->object.object.flags & SEC_ACE_OBJECT_TYPE_PRESENT)
+                type = &ace->object.object.type.type;
+        else if (ace->object.object.flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT)
+                type = &ace->object.object.inherited_type.inherited_type; /* This doesn't look right. Is something wrong with the IDL? */
+        else
+                type = NULL;
+        return type;
+}
+/* modified access check for the purposes of DS security
+        if (ace->object.object.flags & SEC_ACE_OBJECT_TYPE_PRESENT) {
+                return &ace->object.object.type.type;
+        }
+        return NULL;
+}
+/**
+ * @brief Perform directoryservice (DS) related access checks for a given user
+ *
+ * Perform DS access checks for the user represented by its security_token, on
+ * the provided security descriptor. If an tree associating GUID and access
+ * required is provided then object access (OA) are checked as well. *
+ * @param[in]   sd             The security descritor against which the required
+ *                             access are requested
+ *
+ * @param[in]   token          The security_token associated with the user to
+ *                             test
+ *
+ * @param[in]   access_desired A bitfield of rights that must be granted for the
+ *                             given user in the specified SD.
+ *
+ * If one
+ * of the entry in the tree grants all the requested rights for the given GUID
+ * FIXME
+ * tree can be null if not null it's the
  * Lots of code duplication, it will ve united in just one
  * function eventually */
 …
                              struct dom_sid *replace_sid)
+{
+        uint32_t i;
+        uint32_t bits_remaining;
+        struct object_tree *node;
+        const struct GUID *type;
+        struct dom_sid *ps_sid = dom_sid_parse_talloc(NULL, SID_NT_SELF);
+        *access_granted = access_desired;
+        bits_remaining = access_desired;
+        /* handle the maximum allowed flag */
+        if (access_desired & SEC_FLAG_MAXIMUM_ALLOWED) {
+                access_desired |= access_check_max_allowed(sd, token);
+                access_desired &= ~SEC_FLAG_MAXIMUM_ALLOWED;
+                *access_granted = access_desired;
+        uint32_t i;
+        uint32_t bits_remaining;
+        struct object_tree *node;
+        const struct GUID *type;
+        struct dom_sid self_sid;
+        dom_sid_parse(SID_NT_SELF, &self_sid);
+        *access_granted = access_desired;
+        bits_remaining = access_desired;
+        /* handle the maximum allowed flag */
+        if (access_desired & SEC_FLAG_MAXIMUM_ALLOWED) {
+                access_desired |= access_check_max_allowed(sd, token);
+                access_desired &= ~SEC_FLAG_MAXIMUM_ALLOWED;
+                *access_granted = access_desired;
                 bits_remaining = access_desired;
+        }
+        if (access_desired & SEC_FLAG_SYSTEM_SECURITY) {
+                if (security_token_has_privilege(token, SEC_PRIV_SECURITY)) {
+                        bits_remaining &= ~SEC_FLAG_SYSTEM_SECURITY;
+                } else {
+                        talloc_free(ps_sid);
+                        return NT_STATUS_PRIVILEGE_NOT_HELD;
+                }
+        }
+        }
+        if (access_desired & SEC_FLAG_SYSTEM_SECURITY) {
+                if (security_token_has_privilege(token, SEC_PRIV_SECURITY)) {
+                        bits_remaining &= ~SEC_FLAG_SYSTEM_SECURITY;
+                } else {
+                        return NT_STATUS_PRIVILEGE_NOT_HELD;
+                }
+        }
         /* the owner always gets SEC_STD_WRITE_DAC and SEC_STD_READ_CONTROL */
 …
+        }
+        /* TODO: remove this, as it is file server specific */
+        if ((bits_remaining & SEC_RIGHTS_PRIV_RESTORE) &&
+            security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
+                bits_remaining &= ~(SEC_RIGHTS_PRIV_RESTORE);
+        }
+        if ((bits_remaining & SEC_RIGHTS_PRIV_BACKUP) &&
+            security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
+                bits_remaining &= ~(SEC_RIGHTS_PRIV_BACKUP);
+        }
+        /* a NULL dacl allows access */
+        if ((sd->type & SEC_DESC_DACL_PRESENT) && sd->dacl == NULL) {
+                *access_granted = access_desired;
+                talloc_free(ps_sid);
+                return NT_STATUS_OK;
+        }
+        if (sd->dacl == NULL) {
+                goto done;
+        }
+        /* check each ace in turn. */
+        for (i=0; bits_remaining && i < sd->dacl->num_aces; i++) {
+        /* SEC_PRIV_TAKE_OWNERSHIP grants SEC_STD_WRITE_OWNER */
+        if ((bits_remaining & (SEC_STD_WRITE_OWNER)) &&
+            security_token_has_privilege(token, SEC_PRIV_TAKE_OWNERSHIP)) {
+                bits_remaining &= ~(SEC_STD_WRITE_OWNER);
+        }
+        /* a NULL dacl allows access */
+        if ((sd->type & SEC_DESC_DACL_PRESENT) && sd->dacl == NULL) {
+                *access_granted = access_desired;
+                return NT_STATUS_OK;
+        }
+        if (sd->dacl == NULL) {
+                goto done;
+        }
+        /* check each ace in turn. */
+        for (i=0; bits_remaining && i < sd->dacl->num_aces; i++) {
                 struct dom_sid *trustee;
                 struct security_ace *ace = &sd->dacl->aces[i];
+                if (ace->flags & SEC_ACE_FLAG_INHERIT_ONLY) {
+                        continue;
+                }
+                if (dom_sid_equal(&ace->trustee, ps_sid) && replace_sid) {
+                if (ace->flags & SEC_ACE_FLAG_INHERIT_ONLY) {
+                        continue;
+                }
+                if (dom_sid_equal(&ace->trustee, &self_sid) && replace_sid) {
                         trustee = replace_sid;
+                }
+                else
+                {
+                } else {
                         trustee = &ace->trustee;
+                }
+                if (!security_token_has_sid(token, trustee)) {
+                        continue;
+                }
+                switch (ace->type) {
+                case SEC_ACE_TYPE_ACCESS_ALLOWED:
+                        if (tree)
+                                object_tree_modify_access(tree, ace->access_mask);
+                        bits_remaining &= ~ace->access_mask;
+                        break;
+                case SEC_ACE_TYPE_ACCESS_DENIED:
+                        if (bits_remaining & ace->access_mask) {
+                                talloc_free(ps_sid);
+                                return NT_STATUS_ACCESS_DENIED;
+                        }
+                        break;
+                case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
+                case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
+                        /* check only in case we have provided a tree,
+                         * the ACE has an object type and that type
+                         * is in the tree                           */
+                        type = get_ace_object_type(ace);
+                        if (!tree)
+                                continue;
+                        if (!type)
+                                node = tree;
+                        else
+                                if (!(node = get_object_tree_by_GUID(tree, type)))
+                                        continue;
+                        if (ace->type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT) {
+                                object_tree_modify_access(node, ace->access_mask);
+                                if (node->remaining_access == 0) {
+                                        talloc_free(ps_sid);
+                                        return NT_STATUS_OK;
+                                }
+                        } else {
+                                if (node->remaining_access & ace->access_mask){
+                                        talloc_free(ps_sid);
+                                        return NT_STATUS_ACCESS_DENIED;
+                                }
+                        }
+                        break;
+                default:        /* Other ACE types not handled/supported */
+                        break;
+                }
+        }
+                if (!security_token_has_sid(token, trustee)) {
+                        continue;
+                }
+                switch (ace->type) {
+                case SEC_ACE_TYPE_ACCESS_ALLOWED:
+                        if (tree) {
+                                object_tree_modify_access(tree, ace->access_mask);
+                        }
+                        bits_remaining &= ~ace->access_mask;
+                        break;
+                case SEC_ACE_TYPE_ACCESS_DENIED:
+                        if (bits_remaining & ace->access_mask) {
+                                return NT_STATUS_ACCESS_DENIED;
+                        }
+                        break;
+                case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
+                case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
+                        /*
+                         * check only in case we have provided a tree,
+                         * the ACE has an object type and that type
+                         * is in the tree
+                         */
+                        type = get_ace_object_type(ace);
+                        if (!tree) {
+                                continue;
+                        }
+                        if (!type) {
+                                node = tree;
+                        } else {
+                                if (!(node = get_object_tree_by_GUID(tree, type))) {
+                                        continue;
+                                }
+                        }
+                        if (ace->type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT) {
+                                object_tree_modify_access(node, ace->access_mask);
+                                if (node->remaining_access == 0) {
+                                        return NT_STATUS_OK;
+                                }
+                        } else {
+                                if (node->remaining_access & ace->access_mask){
+                                        return NT_STATUS_ACCESS_DENIED;
+                                }
+                        }
+                        break;
+                default:        /* Other ACE types not handled/supported */
+                        break;
+                }
+        }
 done:
+        talloc_free(ps_sid);
+        if (bits_remaining != 0) {
+                return NT_STATUS_ACCESS_DENIED;
+        }
+        return NT_STATUS_OK;
+}
+        if (bits_remaining != 0) {
+                return NT_STATUS_ACCESS_DENIED;
+        }
+        return NT_STATUS_OK;
+}

vendor/current/libcli/security/access_check.h

-              r740
+              r988
                          uint32_t *access_granted);
+/*
+  The main entry point for access checking FOR THE FILE SERVER ONLY !
+  If returning ACCESS_DENIED this function returns the denied bits in
+  the uint32_t pointed to by the access_granted pointer.
+*/
+NTSTATUS se_file_access_check(const struct security_descriptor *sd,
+                         const struct security_token *token,
+                         bool priv_open_requested,
+                         uint32_t access_desired,
+                         uint32_t *access_granted);
 /* modified access check for the purposes of DS security
  * Lots of code duplication, it will ve united in just one
 …
 bool insert_in_object_tree(TALLOC_CTX *mem_ctx,
                           const struct GUID *guid,
                           uint32_t init_access,
                           struct object_tree **root,
                            struct object_tree **new_node);
+                           const struct GUID *guid,
+                           uint32_t init_access,
+                           struct object_tree *root,
+                           struct object_tree **new_node_out);
 /* search by GUID */

vendor/current/libcli/security/create_descriptor.c

-              r740
+              r988
 static bool object_in_list(struct GUID *object_list, struct GUID *object)
+{
+        return true;
+}
+        size_t i;
+        if (object_list == NULL) {
+                return true;
+        }
+        if (GUID_all_zero(object)) {
+                return true;
+        }
+        for (i=0; ; i++) {
+                if (GUID_all_zero(&object_list[i])) {
+                        return false;
+                }
+                if (!GUID_equal(&object_list[i], object)) {
+                        continue;
+                }
+                return true;
+        }
+        return false;
+}
 /* returns true if the ACE gontains generic information
  * that needs to be processed additionally */
+static bool desc_ace_has_generic(TALLOC_CTX *mem_ctx,
+                             struct security_ace *ace)
+{
+        struct dom_sid *co, *cg;
+        co = dom_sid_parse_talloc(mem_ctx,  SID_CREATOR_OWNER);
+        cg = dom_sid_parse_talloc(mem_ctx,  SID_CREATOR_GROUP);
+static bool desc_ace_has_generic(struct security_ace *ace)
+{
         if (ace->access_mask & SEC_GENERIC_ALL || ace->access_mask & SEC_GENERIC_READ ||
             ace->access_mask & SEC_GENERIC_WRITE || ace->access_mask & SEC_GENERIC_EXECUTE) {
                 return true;
+        }
+        if (dom_sid_equal(&ace->trustee, co) || dom_sid_equal(&ace->trustee, cg)) {
+        if (dom_sid_equal(&ace->trustee, &global_sid_Creator_Owner) ||
+            dom_sid_equal(&ace->trustee, &global_sid_Creator_Group)) {
                 return true;
+        }
 …
 /* creates an ace in which the generic information is expanded */
+static void desc_expand_generic(TALLOC_CTX *mem_ctx,
+                                struct security_ace *new_ace,
+static void desc_expand_generic(struct security_ace *new_ace,
                                 struct dom_sid *owner,
                                 struct dom_sid *group)
+{
-        struct dom_sid *co, *cg;
-        co = dom_sid_parse_talloc(mem_ctx,  SID_CREATOR_OWNER);
-        cg = dom_sid_parse_talloc(mem_ctx,  SID_CREATOR_GROUP);
         new_ace->access_mask = map_generic_rights_ds(new_ace->access_mask);
         if (dom_sid_equal(&new_ace->trustee, co)) {
+        if (dom_sid_equal(&new_ace->trustee, &global_sid_Creator_Owner)) {
                 new_ace->trustee = *owner;
+        }
         if (dom_sid_equal(&new_ace->trustee, cg)) {
+        if (dom_sid_equal(&new_ace->trustee, &global_sid_Creator_Group)) {
                 new_ace->trustee = *group;
+        }
 …
         TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
         struct security_acl *tmp_acl = talloc_zero(mem_ctx, struct security_acl);
-        struct dom_sid *co, *cg;
         if (!tmp_acl) {
                 return NULL;
 …
                 return NULL;
+        }
-        co = dom_sid_parse_talloc(tmp_ctx,  SID_CREATOR_OWNER);
-        cg = dom_sid_parse_talloc(tmp_ctx,  SID_CREATOR_GROUP);
         for (i=0; i < acl->num_aces; i++) {
 …
                 if ((ace->flags & SEC_ACE_FLAG_CONTAINER_INHERIT) ||
                     (ace->flags & SEC_ACE_FLAG_OBJECT_INHERIT)) {
+                        struct GUID inherited_object = GUID_zero();
                         tmp_acl->aces = talloc_realloc(tmp_acl, tmp_acl->aces,
                                                        struct security_ace,
 …
                         /* remove IO flag from the child's ace */
                         if (ace->flags & SEC_ACE_FLAG_INHERIT_ONLY &&
                             !desc_ace_has_generic(tmp_ctx, ace)) {
+                            !desc_ace_has_generic(ace)) {
                                 tmp_acl->aces[tmp_acl->num_aces].flags &= ~SEC_ACE_FLAG_INHERIT_ONLY;
+                        }
 …
                             tmp_acl->aces[tmp_acl->num_aces].flags |= SEC_ACE_FLAG_INHERIT_ONLY;
+                        if (ace->type == SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT ||
+                            ace->type == SEC_ACE_TYPE_ACCESS_DENIED_OBJECT) {
+                                if (!object_in_list(object_list, &ace->object.object.type.type)) {
+                        switch (ace->type) {
+                        case SEC_ACE_TYPE_ACCESS_ALLOWED:
+                        case SEC_ACE_TYPE_ACCESS_DENIED:
+                        case SEC_ACE_TYPE_SYSTEM_AUDIT:
+                        case SEC_ACE_TYPE_SYSTEM_ALARM:
+                        case SEC_ACE_TYPE_ALLOWED_COMPOUND:
+                                break;
+                        case SEC_ACE_TYPE_ACCESS_ALLOWED_OBJECT:
+                        case SEC_ACE_TYPE_ACCESS_DENIED_OBJECT:
+                        case SEC_ACE_TYPE_SYSTEM_ALARM_OBJECT:
+                        case SEC_ACE_TYPE_SYSTEM_AUDIT_OBJECT:
+                                if (ace->object.object.flags & SEC_ACE_INHERITED_OBJECT_TYPE_PRESENT) {
+                                        inherited_object = ace->object.object.inherited_type.inherited_type;
+                                }
+                                if (!object_in_list(object_list, &inherited_object)) {
                                         tmp_acl->aces[tmp_acl->num_aces].flags |= SEC_ACE_FLAG_INHERIT_ONLY;
+                                }
+                        }
+                                break;
+                        }
                         tmp_acl->num_aces++;
                         if (is_container) {
                                 if (!(ace->flags & SEC_ACE_FLAG_NO_PROPAGATE_INHERIT) &&
                                     (desc_ace_has_generic(tmp_ctx, ace))) {
+                                    (desc_ace_has_generic(ace))) {
                                             tmp_acl->aces = talloc_realloc(tmp_acl,
                                                                            tmp_acl->aces,
 …
+                                            }
                                             tmp_acl->aces[tmp_acl->num_aces] = *ace;
+                                            desc_expand_generic(tmp_ctx,
+                                                                &tmp_acl->aces[tmp_acl->num_aces],
+                                            desc_expand_generic(&tmp_acl->aces[tmp_acl->num_aces],
                                                                 owner,
                                                                 group);
 …
         struct security_acl *tmp_acl = talloc_zero(tmp_ctx, struct security_acl);
         struct security_acl *new_acl;
-        struct dom_sid *co, *cg;
         if (!acl)
 …
         tmp_acl->revision = acl->revision;
         DEBUG(6,(__location__ ": acl revision %d\n", acl->revision));
-        co = dom_sid_parse_talloc(tmp_ctx,  SID_CREATOR_OWNER);
-        cg = dom_sid_parse_talloc(tmp_ctx,  SID_CREATOR_GROUP);
         for (i=0; i < acl->num_aces; i++){
 …
                  * it has to be expanded to two aces, the original as IO,
                  * and another one where these are translated */
                 if (desc_ace_has_generic(tmp_ctx, ace)) {
+                if (desc_ace_has_generic(ace)) {
                         if (!(ace->flags & SEC_ACE_FLAG_CONTAINER_INHERIT)) {
+                                desc_expand_generic(tmp_ctx,
+                                                    &tmp_acl->aces[tmp_acl->num_aces-1],
+                                desc_expand_generic(&tmp_acl->aces[tmp_acl->num_aces-1],
                                                     owner,
                                                     group);
 …
                                 /* add a new ACE with expanded generic info */
                                 tmp_acl->aces[tmp_acl->num_aces] = *ace;
+                                desc_expand_generic(tmp_ctx,
+                                                    &tmp_acl->aces[tmp_acl->num_aces],
+                                desc_expand_generic(&tmp_acl->aces[tmp_acl->num_aces],
                                                     owner,
                                                     group);

vendor/current/libcli/security/display_sec.c

-              r740
+              r988
 /*
+/*
    Unix SMB/CIFS implementation.
    Samba utility functions
    Copyright (C) Andrew Tridgell 1992-1999
    Copyright (C) Luke Kenneth Casson Leighton 1996 - 1999
    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,
+   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/>.
 …
         printf("\tACL\tNum ACEs:\t%u\trevision:\t%x\n",
                          sec_acl->num_aces, sec_acl->revision);
+               sec_acl->num_aces, sec_acl->revision);
         printf("\t---\n");
 …
         if (type & SEC_DESC_SELF_RELATIVE)      /* 0x8000 */
                 printf("SEC_DESC_SELF_RELATIVE ");
         printf("\n");
+}

vendor/current/libcli/security/dom_sid.c

-              r740
+              r988
  Return the first character not parsed in endp.
 *****************************************************************/
+#define AUTHORITY_MASK (~(0xffffffffffffULL))
 bool dom_sid_parse_endp(const char *sidstr,struct dom_sid *sidout,
 …
         char *q;
         /* BIG NOTE: this function only does SIDS where the identauth is not >= 2^32 */
         uint32_t conv;
+        uint64_t conv;
         ZERO_STRUCTP(sidout);
 …
+        }
         conv = (uint32_t) strtoul(p, &q, 10);
         if (!q || (*q != '-')) {
+        conv = strtoul(p, &q, 10);
+        if (!q || (*q != '-') || conv > UINT8_MAX) {
                 goto format_error;
+        }
 …
         /* get identauth */
         conv = (uint32_t) strtoul(q, &q, 10);
         if (!q) {
+        conv = strtoull(q, &q, 0);
+        if (!q || conv & AUTHORITY_MASK) {
                 goto format_error;
+        }
         /* identauth in decimal should be <  2^32 */
+        /* When identauth >= UINT32_MAX, it's in hex with a leading 0x */
         /* NOTE - the conv value is in big-endian format. */
         sidout->id_auth[0] = 0;
         sidout->id_auth[1] = 0;
         sidout->id_auth[2] = (conv & 0xff000000) >> 24;
         sidout->id_auth[3] = (conv & 0x00ff0000) >> 16;
         sidout->id_auth[4] = (conv & 0x0000ff00) >> 8;
         sidout->id_auth[5] = (conv & 0x000000ff);
+        sidout->id_auth[0] = (conv & 0xff0000000000ULL) >> 40;
+        sidout->id_auth[1] = (conv & 0x00ff00000000ULL) >> 32;
+        sidout->id_auth[2] = (conv & 0x0000ff000000ULL) >> 24;
+        sidout->id_auth[3] = (conv & 0x000000ff0000ULL) >> 16;
+        sidout->id_auth[4] = (conv & 0x00000000ff00ULL) >> 8;
+        sidout->id_auth[5] = (conv & 0x0000000000ffULL);
         sidout->num_auths = 0;
 …
+                }
                 conv = strtoul(q, &end, 10);
                 if (end == q) {
+                conv = strtoull(q, &end, 10);
+                if (end == q || conv > UINT32_MAX) {
                         goto format_error;
+                }
 …
 struct dom_sid *dom_sid_parse_length(TALLOC_CTX *mem_ctx, const DATA_BLOB *sid)
+{
+        struct dom_sid *ret;
+        char *p = talloc_strndup(mem_ctx, (char *)sid->data, sid->length);
+        if (!p) {
+                return NULL;
+        }
+        ret = dom_sid_parse_talloc(mem_ctx, p);
+        talloc_free(p);
+        return ret;
+        char p[sid->length+1];
+        memcpy(p, sid->data, sid->length);
+        p[sid->length] = '\0';
+        return dom_sid_parse_talloc(mem_ctx, p);
+}
 …
+{
         int i, ofs;
         uint32_t ia;
+        uint64_t ia;
         if (!sid) {
+                strlcpy(buf, "(NULL SID)", buflen);
+                return 10;      /* strlen("(NULL SID)") */
+        }
+        ia = (sid->id_auth[5]) +
+                (sid->id_auth[4] << 8 ) +
+                (sid->id_auth[3] << 16) +
+                (sid->id_auth[2] << 24);
+        ofs = snprintf(buf, buflen, "S-%u-%lu",
+                       (unsigned int)sid->sid_rev_num, (unsigned long)ia);
+                return strlcpy(buf, "(NULL SID)", buflen);
+        }
+        ia = ((uint64_t)sid->id_auth[5]) +
+                ((uint64_t)sid->id_auth[4] << 8 ) +
+                ((uint64_t)sid->id_auth[3] << 16) +
+                ((uint64_t)sid->id_auth[2] << 24) +
+                ((uint64_t)sid->id_auth[1] << 32) +
+                ((uint64_t)sid->id_auth[0] << 40);
+        ofs = snprintf(buf, buflen, "S-%hhu-", (unsigned char)sid->sid_rev_num);
+        if (ia >= UINT32_MAX) {
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "0x%llx",
+                                (unsigned long long)ia);
+        } else {
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "%llu",
+                                (unsigned long long)ia);
+        }
         for (i = 0; i < sid->num_auths; i++) {
                 ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "-%lu",
                                 (unsigned long)sid->sub_auths[i]);
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "-%u",
+                                (unsigned int)sid->sub_auths[i]);
+        }
         return ofs;
 …
          */
         result = (char *)talloc_memdup(mem_ctx, buf, len+1);
+        if (result == NULL) {
+                return NULL;
+        }
         /*

vendor/current/libcli/security/dom_sid.h

-              r740
+              r988
 extern const struct dom_sid global_sid_World_Domain;
 extern const struct dom_sid global_sid_World;
+extern const struct dom_sid global_sid_Local_Authority;
 extern const struct dom_sid global_sid_Creator_Owner_Domain;
 extern const struct dom_sid global_sid_NT_Authority;
 …
 extern const struct dom_sid global_sid_Authenticated_Users;
 extern const struct dom_sid global_sid_Network;
+extern const struct dom_sid global_sid_Asserted_Identity;
+extern const struct dom_sid global_sid_Asserted_Identity_Service;
+extern const struct dom_sid global_sid_Asserted_Identity_Authentication_Authority;
 extern const struct dom_sid global_sid_Creator_Owner;
 extern const struct dom_sid global_sid_Creator_Group;
+extern const struct dom_sid global_sid_Owner_Rights;
 extern const struct dom_sid global_sid_Anonymous;
 extern const struct dom_sid global_sid_Builtin;
 …
 extern const struct dom_sid global_sid_Unix_Users;
 extern const struct dom_sid global_sid_Unix_Groups;
+extern const struct dom_sid global_sid_Unix_NFS;
+extern const struct dom_sid global_sid_Unix_NFS_Users;
+extern const struct dom_sid global_sid_Unix_NFS_Groups;
+extern const struct dom_sid global_sid_Unix_NFS_Mode;
+extern const struct dom_sid global_sid_Unix_NFS_Other;
 int dom_sid_compare_auth(const struct dom_sid *sid1,
 …
 bool sid_peek_check_rid(const struct dom_sid *exp_dom_sid, const struct dom_sid *sid, uint32_t *rid);
 void sid_copy(struct dom_sid *dst, const struct dom_sid *src);
+bool sid_blob_parse(DATA_BLOB in, struct dom_sid *sid);
+bool sid_parse(const char *inbuf, size_t len, struct dom_sid *sid);
+bool sid_parse(const uint8_t *inbuf, size_t len, struct dom_sid *sid);
 int sid_compare_domain(const struct dom_sid *sid1, const struct dom_sid *sid2);
-bool sid_equal(const struct dom_sid *sid1, const struct dom_sid *sid2);
 NTSTATUS add_sid_to_array(TALLOC_CTX *mem_ctx, const struct dom_sid *sid,
                           struct dom_sid **sids, uint32_t *num);

vendor/current/libcli/security/object_tree.c

-              r740
+              r988
 bool insert_in_object_tree(TALLOC_CTX *mem_ctx,
                           const struct GUID *guid,
                           uint32_t init_access,
                           struct object_tree **root,
                           struct object_tree **new_node)
+                           const struct GUID *guid,
+                           uint32_t init_access,
+                           struct object_tree *root,
+                           struct object_tree **new_node_out)
+{
+        struct object_tree *new_node;
         if (!guid || GUID_all_zero(guid)){
                 return true;
+        }
         if (!*root){
                 *root = talloc_zero(mem_ctx, struct object_tree);
                 if (!*root) {
+        if (!root) {
+                root = talloc_zero(mem_ctx, struct object_tree);
+                if (!root) {
                         return false;
+                }
+                (*root)->guid = *guid;
+                *new_node = *root;
+                return true;
+        }
+                new_node = root;
+        } else {
+                int i;
+        if (!(*root)->children) {
+                (*root)->children = talloc_array(mem_ctx, struct object_tree, 1);
+                (*root)->children[0].guid = *guid;
+                (*root)->children[0].num_of_children = 0;
+                (*root)->children[0].children = NULL;
+                (*root)->num_of_children++;
+                (*root)->children[0].remaining_access = init_access;
+                *new_node = &((*root)->children[0]);
+                return true;
+        }
+        else {
+                int i;
+                for (i = 0; i < (*root)->num_of_children; i++) {
+                        if (GUID_equal(&((*root)->children[i].guid), guid)) {
+                                *new_node = &((*root)->children[i]);
+                for (i = 0; i < root->num_of_children; i++) {
+                        if (GUID_equal(&root->children[i].guid, guid)) {
+                                new_node = &root->children[i];
+                                new_node->remaining_access |= init_access;
+                                *new_node_out = new_node;
                                 return true;
+                        }
+                }
+                (*root)->children = talloc_realloc(mem_ctx, (*root)->children, struct object_tree,
+                                                   (*root)->num_of_children +1);
+                (*root)->children[(*root)->num_of_children].guid = *guid;
+                (*root)->children[(*root)->num_of_children].remaining_access = init_access;
+                *new_node = &((*root)->children[(*root)->num_of_children]);
+                (*root)->num_of_children++;
+                return true;
+                root->children = talloc_realloc(mem_ctx, root->children,
+                                                struct object_tree,
+                                                root->num_of_children + 1);
+                if (!root->children) {
+                        return false;
+                }
+                new_node = &root->children[root->num_of_children];
+                root->num_of_children++;
+        }
+        new_node->children = NULL;
+        new_node->guid = *guid;
+        new_node->remaining_access = init_access;
+        new_node->num_of_children = 0;
+        *new_node_out = new_node;
+        return true;
+}
 …
                 return result;
+        }
+        else if (root->num_of_children > 0) {
+                for (i = 0; i < root->num_of_children; i++) {
+        for (i = 0; i < root->num_of_children; i++) {
                 if ((result = get_object_tree_by_GUID(&root->children[i], guid)))
                         break;
+                }
+        }
         return result;
+}
+/* Change the granted access per each ACE */
+/**
+ * @brief Modify the tree to mark specified access rights as granted
+ *
+ * This function will modify the root and the child of the tree pointed by
+ * root, so that for each tree element the bits set in access_mask are
+ * marked as granted.
+ *
+ * @param[in]  root        An object_tree structure that we want to modify
+ *
+ * @param[in]  access_mask A bitfield of access right that we want to mark as
+ *                         granted in the whole tree.
+ */
 void object_tree_modify_access(struct object_tree *root,
                                uint32_t access_mask)
+{
+        int i;
         root->remaining_access &= ~access_mask;
+        if (root->num_of_children > 0) {
+                int i;
+                for (i = 0; i < root->num_of_children; i++) {
+                        object_tree_modify_access(&root->children[i], access_mask);
+                }
+        for (i = 0; i < root->num_of_children; i++) {
+                object_tree_modify_access(&root->children[i], access_mask);
+        }
+}

vendor/current/libcli/security/privileges.c

-              r740
+              r988
+}
+bool security_token_system_privilege(const struct security_token *token)
+{
+        if (token == NULL) {
+                return false;
+        }
+        if (token->privilege_mask == (uint64_t)~0) {
+                return true;
+        }
+        return false;
+}
 /*
   set a bit in the privilege mask

vendor/current/libcli/security/privileges.h

-              r740
+              r988
 bool security_token_has_privilege(const struct security_token *token, enum sec_privilege privilege);
+/**
+ * @brief Check if the security token has system privileges.
+ *
+ * @param[in]  token    The token to check.
+ *
+ * @return              True if the token has system privileges, false if not.
+ */
+bool security_token_system_privilege(const struct security_token *token);
 /*
   set a bit in the privilege mask

vendor/current/libcli/security/pysecurity.c

-              r740
+              r988
+        }
         security_descriptor = py_talloc_get_type(py_sec_desc, struct security_descriptor);
+        security_descriptor = pytalloc_get_type(py_sec_desc, struct security_descriptor);
         if (!security_descriptor) {
                 PyErr_Format(PyExc_TypeError,
                              "Expected dcerpc.security.descriptor for security_descriptor argument got  %s",
                              talloc_get_name(py_talloc_get_ptr(py_sec_desc)));
+                             talloc_get_name(pytalloc_get_ptr(py_sec_desc)));
                 return NULL;
+        }
         security_token = py_talloc_get_type(py_security_token, struct security_token);
+        security_token = pytalloc_get_type(py_security_token, struct security_token);
         if (!security_token) {
                 PyErr_Format(PyExc_TypeError,
                              "Expected dcerpc.security.token for token argument, got %s",
                              talloc_get_name(py_talloc_get_ptr(py_security_token)));
+                             talloc_get_name(pytalloc_get_ptr(py_security_token)));
                 return NULL;
+        }

vendor/current/libcli/security/sddl.c

r740	r988
82	82	{ "LS", SID_NT_LOCAL_SERVICE },
83	83	{ "NS", SID_NT_NETWORK_SERVICE },
	84	{ "IS", SID_NT_IUSR },
84	85
85	86	{ "BA", SID_BUILTIN_ADMINISTRATORS },

vendor/current/libcli/security/secace.c

-              r740
+              r988
         t->trustee = *sid;
+}
-/*******************************************************************
- adds new SID with its permissions to ACE list
-********************************************************************/
-NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, struct security_ace **pp_new, struct security_ace *old, unsigned *num, const struct dom_sid *sid, uint32_t mask)
+{
-        unsigned int i = 0;
-        if (!ctx || !pp_new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
-        *num += 1;
-        if((pp_new[0] = talloc_zero_array(ctx, struct security_ace, *num )) == 0)
-                return NT_STATUS_NO_MEMORY;
-        for (i = 0; i < *num - 1; i ++)
-                sec_ace_copy(&(*pp_new)[i], &old[i]);
-        (*pp_new)[i].type  = SEC_ACE_TYPE_ACCESS_ALLOWED;
-        (*pp_new)[i].flags = 0;
-        (*pp_new)[i].size  = SEC_ACE_HEADER_SIZE + ndr_size_dom_sid(sid, 0);
-        (*pp_new)[i].access_mask = mask;
-        (*pp_new)[i].trustee = *sid;
-        return NT_STATUS_OK;
+}
-/*******************************************************************
-  modify SID's permissions at ACL
-********************************************************************/
-NTSTATUS sec_ace_mod_sid(struct security_ace *ace, size_t num, const struct dom_sid *sid, uint32_t mask)
+{
-        unsigned int i = 0;
-        if (!ace || !sid)  return NT_STATUS_INVALID_PARAMETER;
-        for (i = 0; i < num; i ++) {
-                if (dom_sid_equal(&ace[i].trustee, sid)) {
-                        ace[i].access_mask = mask;
-                        return NT_STATUS_OK;
+                }
+        }
-        return NT_STATUS_NOT_FOUND;
+}
-/*******************************************************************
- delete SID from ACL
-********************************************************************/
-NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, struct security_ace **pp_new, struct security_ace *old, uint32_t *num, const struct dom_sid *sid)
+{
-        unsigned int i     = 0;
-        unsigned int n_del = 0;
-        if (!ctx || !pp_new || !old || !sid || !num)  return NT_STATUS_INVALID_PARAMETER;
-        if (*num) {
-                if((pp_new[0] = talloc_zero_array(ctx, struct security_ace, *num )) == 0)
-                        return NT_STATUS_NO_MEMORY;
-        } else {
-                pp_new[0] = NULL;
+        }
-        for (i = 0; i < *num; i ++) {
-                if (!dom_sid_equal(&old[i].trustee, sid))
-                        sec_ace_copy(&(*pp_new)[i], &old[i]);
-                else
-                        n_del ++;
+        }
-        if (n_del == 0)
-                return NT_STATUS_NOT_FOUND;
-        else {
-                *num -= n_del;
-                return NT_STATUS_OK;
+        }
+}
-/*******************************************************************
- Compares two struct security_ace structures
-********************************************************************/
-bool sec_ace_equal(const struct security_ace *s1, const struct security_ace *s2)
+{
-        /* Trivial case */
-        if (!s1 && !s2) {
-                return true;
+        }
-        if (!s1 || !s2) {
-                return false;
+        }
-        /* Check top level stuff */
-        if (s1->type != s2->type || s1->flags != s2->flags ||
-            s1->access_mask != s2->access_mask) {
-                return false;
+        }
-        /* Check SID */
-        if (!dom_sid_equal(&s1->trustee, &s2->trustee)) {
-                return false;
+        }
-        return true;
+}

vendor/current/libcli/security/secace.h

-              r740
+              r988
 void init_sec_ace(struct security_ace *t, const struct dom_sid *sid, enum security_ace_type type,
                   uint32_t mask, uint8_t flag);
-NTSTATUS sec_ace_add_sid(TALLOC_CTX *ctx, struct security_ace **pp_new, struct security_ace *old, unsigned *num, const struct dom_sid *sid, uint32_t mask);
-NTSTATUS sec_ace_mod_sid(struct security_ace *ace, size_t num, const struct dom_sid *sid, uint32_t mask);
-NTSTATUS sec_ace_del_sid(TALLOC_CTX *ctx, struct security_ace **pp_new, struct security_ace *old, uint32_t *num, const struct dom_sid *sid);
-bool sec_ace_equal(const struct security_ace *s1, const struct security_ace *s2);
 int nt_ace_inherit_comp( const struct security_ace *a1, const struct security_ace *a2);
 int nt_ace_canon_comp( const struct security_ace *a1, const struct security_ace *a2);

vendor/current/libcli/security/secacl.c

-              r740
+              r988
 /*
+/*
  *  Unix SMB/Netbios implementation.
  *  SEC_ACL handling routines
 …
  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
  *  Copyright (C) Paul Ashton                  1997-1998.
+ *
+ *
  *  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/>.
 …
 /*******************************************************************
  Create a SEC_ACL structure.
+ Create a SEC_ACL structure.
 ********************************************************************/
 struct security_acl *make_sec_acl(TALLOC_CTX *ctx,
                                                                   enum security_acl_revision revision,
                                                                   int num_aces, struct security_ace *ace_list)
+struct security_acl *make_sec_acl(TALLOC_CTX *ctx,
+                                  enum security_acl_revision revision,
+                                  int num_aces, struct security_ace *ace_list)
+{
         struct security_acl *dst;
         int i;
+        if((dst = talloc_zero(ctx, struct security_acl)) == NULL)
+        dst = talloc(ctx, struct security_acl);
+        if (dst == NULL) {
                 return NULL;
+        }
         dst->revision = revision;
         dst->num_aces = num_aces;
         dst->size = SEC_ACL_HEADER_SIZE;
+        dst->aces = NULL;
         /* Now we need to return a non-NULL address for the ace list even
 …
            positive number. */
+        if ((num_aces) &&
+            ((dst->aces = talloc_array(dst, struct security_ace, num_aces))
+             == NULL)) {
+        if (num_aces == 0) {
+                return dst;
+        }
+        dst->aces = talloc_array(dst, struct security_ace, num_aces);
+        if (dst->aces == NULL) {
+                TALLOC_FREE(dst);
                 return NULL;
+        }
         for (i = 0; i < num_aces; i++) {
                 dst->aces[i] = ace_list[i]; /* Structure copy. */
 …
         return dst;
+}
-/*******************************************************************
- Duplicate a SEC_ACL structure.
-********************************************************************/
-struct security_acl *dup_sec_acl(TALLOC_CTX *ctx, struct security_acl *src)
+{
-        if(src == NULL)
-                return NULL;
-        return make_sec_acl(ctx, src->revision, src->num_aces, src->aces);
+}

vendor/current/libcli/security/secacl.h

r740	r988
26	26	struct security_acl make_sec_acl(TALLOC_CTX ctx, enum security_acl_revision revision,
27	27	int num_aces, struct security_ace *ace_list);
28		~~struct security_acl dup_sec_acl(TALLOC_CTX ctx, struct security_acl *src);~~
29	28
30	29

vendor/current/libcli/security/security.h

-              r740
+              r988
 #define SHARE_READ_ONLY       (FILE_GENERIC_READ|FILE_EXECUTE)
+/**
+ * Remaining access is a bit mask of remaining access rights (bits) that have
+ * to be granted in order to fulfill the requested access.
+ *
+ * The GUID is optional, if specified it restricts this object tree and its
+ * childs to object/attributes that inherits from this GUID.
+ * For DS access an object inherits from a GUID if one of its class has this GUID
+ * in the schemaIDGUID attribute.
+ */
 struct object_tree {
         uint32_t remaining_access;
 …
 #include "libcli/security/secace.h"
 #include "libcli/security/secacl.h"
+#include "libcli/security/secdesc.h"
 #include "libcli/security/security_descriptor.h"
 #include "libcli/security/security_token.h"

vendor/current/libcli/security/security_descriptor.c

-              r740
+              r988
+}
+NTSTATUS security_descriptor_for_client(TALLOC_CTX *mem_ctx,
+                                        const struct security_descriptor *ssd,
+                                        uint32_t sec_info,
+                                        uint32_t access_granted,
+                                        struct security_descriptor **_csd)
+{
+        struct security_descriptor *csd = NULL;
+        uint32_t access_required = 0;
+        *_csd = NULL;
+        if (sec_info & (SECINFO_OWNER|SECINFO_GROUP)) {
+                access_required |= SEC_STD_READ_CONTROL;
+        }
+        if (sec_info & SECINFO_DACL) {
+                access_required |= SEC_STD_READ_CONTROL;
+        }
+        if (sec_info & SECINFO_SACL) {
+                access_required |= SEC_FLAG_SYSTEM_SECURITY;
+        }
+        if (access_required & (~access_granted)) {
+                return NT_STATUS_ACCESS_DENIED;
+        }
+        /*
+         * make a copy...
+         */
+        csd = security_descriptor_copy(mem_ctx, ssd);
+        if (csd == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        /*
+         * ... and remove everthing not wanted
+         */
+        if (!(sec_info & SECINFO_OWNER)) {
+                TALLOC_FREE(csd->owner_sid);
+                csd->type &= ~SEC_DESC_OWNER_DEFAULTED;
+        }
+        if (!(sec_info & SECINFO_GROUP)) {
+                TALLOC_FREE(csd->group_sid);
+                csd->type &= ~SEC_DESC_GROUP_DEFAULTED;
+        }
+        if (!(sec_info & SECINFO_DACL)) {
+                TALLOC_FREE(csd->dacl);
+                csd->type &= ~(
+                        SEC_DESC_DACL_PRESENT |
+                        SEC_DESC_DACL_DEFAULTED|
+                        SEC_DESC_DACL_AUTO_INHERIT_REQ |
+                        SEC_DESC_DACL_AUTO_INHERITED |
+                        SEC_DESC_DACL_PROTECTED |
+                        SEC_DESC_DACL_TRUSTED);
+        }
+        if (!(sec_info & SECINFO_SACL)) {
+                TALLOC_FREE(csd->sacl);
+                csd->type &= ~(
+                        SEC_DESC_SACL_PRESENT |
+                        SEC_DESC_SACL_DEFAULTED |
+                        SEC_DESC_SACL_AUTO_INHERIT_REQ |
+                        SEC_DESC_SACL_AUTO_INHERITED |
+                        SEC_DESC_SACL_PROTECTED |
+                        SEC_DESC_SERVER_SECURITY);
+        }
+        *_csd = csd;
+        return NT_STATUS_OK;
+}
 /*
   add an ACE to an ACL of a security_descriptor
 …
   compare two security ace structures
 */
 bool security_ace_equal(const struct security_ace *ace1,
+bool security_ace_equal(const struct security_ace *ace1,
                         const struct security_ace *ace2)
+{
+        if (ace1 == ace2) return true;
+        if (!ace1 || !ace2) return false;
+        if (ace1->type != ace2->type) return false;
+        if (ace1->flags != ace2->flags) return false;
+        if (ace1->access_mask != ace2->access_mask) return false;
+        if (!dom_sid_equal(&ace1->trustee, &ace2->trustee)) return false;
+        return true;
+        if (ace1 == ace2) {
+                return true;
+        }
+        if ((ace1 == NULL) || (ace2 == NULL)) {
+                return false;
+        }
+        if (ace1->type != ace2->type) {
+                return false;
+        }
+        if (ace1->flags != ace2->flags) {
+                return false;
+        }
+        if (ace1->access_mask != ace2->access_mask) {
+                return false;
+        }
+        if (!dom_sid_equal(&ace1->trustee, &ace2->trustee)) {
+                return false;
+        }
+        return true;
+}
 …
+{
-        struct dom_sid *sid;
         struct security_ace *ace;
+        bool ok;
         ace = talloc_zero(mem_ctx, struct security_ace);
 …
+        }
         sid = dom_sid_parse_talloc(ace, sid_str);
         if (sid == NULL) {
+        ok = dom_sid_parse(sid_str, &ace->trustee);
+        if (!ok) {
                 talloc_free(ace);
                 return NULL;
+        }
-        ace->trustee = *sid;
         ace->type = type;
         ace->access_mask = access_mask;
 …
         return ace;
+}
+/*******************************************************************
+ Check for MS NFS ACEs in a sd
+*******************************************************************/
+bool security_descriptor_with_ms_nfs(const struct security_descriptor *psd)
+{
+        int i;
+        if (psd->dacl == NULL) {
+                return false;
+        }
+        for (i = 0; i < psd->dacl->num_aces; i++) {
+                if (dom_sid_compare_domain(
+                            &global_sid_Unix_NFS,
+                            &psd->dacl->aces[i].trustee) == 0) {
+                        return true;
+                }
+        }
+        return false;
+}

vendor/current/libcli/security/security_descriptor.h

-              r740
+              r988
 struct security_descriptor *security_descriptor_copy(TALLOC_CTX *mem_ctx,
                                                      const struct security_descriptor *osd);
+NTSTATUS security_descriptor_for_client(TALLOC_CTX *mem_ctx,
+                                        const struct security_descriptor *ssd,
+                                        uint32_t sec_info,
+                                        uint32_t access_granted,
+                                        struct security_descriptor **_csd);
 NTSTATUS security_descriptor_sacl_add(struct security_descriptor *sd,
                                       const struct security_ace *ace);
 …
                                                        uint32_t (*generic_map)(uint32_t access_mask));
+bool security_descriptor_with_ms_nfs(const struct security_descriptor *psd);
 #endif /* __SECURITY_DESCRIPTOR_H__ */

vendor/current/libcli/security/security_token.c

-              r740
+              r988
+{
         bool ret;
+        struct dom_sid *sid = dom_sid_parse_talloc(NULL, sid_string);
+        if (!sid) return false;
+        struct dom_sid sid;
+        ret = security_token_is_sid(token, sid);
+        ret = dom_sid_parse(sid_string, &sid);
+        if (!ret) {
+                return false;
+        }
         talloc_free(sid);
+        ret = security_token_is_sid(token, &sid);
         return ret;
+}
 …
+{
         bool ret;
+        struct dom_sid *sid = dom_sid_parse_talloc(NULL, sid_string);
+        if (!sid) return false;
+        struct dom_sid sid;
+        ret = security_token_has_sid(token, sid);
+        ret = dom_sid_parse(sid_string, &sid);
+        if (!ret) {
+                return false;
+        }
         talloc_free(sid);
+        ret = security_token_has_sid(token, &sid);
         return ret;
+}
+bool security_token_has_builtin_guests(const struct security_token *token)
+{
+        return security_token_has_sid(token, &global_sid_Builtin_Guests);
+}

vendor/current/libcli/security/security_token.h

r740	r988
52	52	bool security_token_has_sid_string(const struct security_token token, const char sid_string);
53	53
	54	bool security_token_has_builtin_guests(const struct security_token *token);
	55
54	56	bool security_token_has_builtin_administrators(const struct security_token *token);
55	57

vendor/current/libcli/security/session.c

-              r740
+              r988
+        }
+        if (security_token_has_builtin_guests(session_info->security_token)) {
+                return SECURITY_GUEST;
+        }
         if (security_token_has_builtin_administrators(session_info->security_token)) {
                 return SECURITY_ADMINISTRATOR;

vendor/current/libcli/security/session.h

-              r740
+              r988
 enum security_user_level {
         SECURITY_ANONYMOUS            = 0,
+        SECURITY_GUEST                = 1,
         SECURITY_USER                 = 10,
         SECURITY_RO_DOMAIN_CONTROLLER = 20,
 …
 struct auth_user_info;
 struct auth_user_info_torture;
+struct auth_session_info {
+        struct security_token *security_token;
+        struct security_unix_token *unix_token;
+        struct auth_user_info *info;
+        struct auth_user_info_unix *unix_info;
+        struct auth_user_info_torture *torture;
+        DATA_BLOB session_key;
+        struct cli_credentials *credentials;
+};
+struct auth_session_info;
 enum security_user_level security_session_user_level(struct auth_session_info *session_info,

vendor/current/libcli/security/util_sid.c

-              r740
+              r988
 const struct dom_sid global_sid_World =                      /* Everyone */
 { 1, 1, {0,0,0,0,0,1}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const struct dom_sid global_sid_Local_Authority =            /* Local Authority */
+{ 1, 0, {0,0,0,0,0,2}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 const struct dom_sid global_sid_Creator_Owner_Domain =       /* Creator Owner domain */
 { 1, 0, {0,0,0,0,0,3}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 …
 { 1, 1, {0,0,0,0,0,5}, {12,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 #endif
+const struct dom_sid global_sid_Asserted_Identity =       /* Asserted Identity */
+{ 1, 0, {0,0,0,0,0,18}, {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const struct dom_sid global_sid_Asserted_Identity_Service =     /* Asserted Identity Service */
+{ 1, 1, {0,0,0,0,0,18}, {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const struct dom_sid global_sid_Asserted_Identity_Authentication_Authority =    /* Asserted Identity Authentication Authority */
+{ 1, 1, {0,0,0,0,0,18}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 const struct dom_sid global_sid_Network =                       /* Network rids */
 { 1, 1, {0,0,0,0,0,5}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 …
 const struct dom_sid global_sid_Creator_Group =         /* Creator Group */
 { 1, 1, {0,0,0,0,0,3}, {1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const struct dom_sid global_sid_Owner_Rights =          /* Owner Rights */
+{ 1, 1, {0,0,0,0,0,3}, {4,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 const struct dom_sid global_sid_Anonymous =                     /* Anonymous login */
 { 1, 1, {0,0,0,0,0,5}, {7,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
 …
 { 1, 1, {0,0,0,0,0,22}, {2,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+/*
+ * http://technet.microsoft.com/en-us/library/hh509017(v=ws.10).aspx
+ */
+const struct dom_sid global_sid_Unix_NFS =             /* MS NFS and Apple style */
+{ 1, 1, {0,0,0,0,0,5}, {88,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const struct dom_sid global_sid_Unix_NFS_Users =                /* Unix uid, MS NFS and Apple style */
+{ 1, 2, {0,0,0,0,0,5}, {88,1,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const struct dom_sid global_sid_Unix_NFS_Groups =               /* Unix gid, MS NFS and Apple style */
+{ 1, 2, {0,0,0,0,0,5}, {88,2,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+const struct dom_sid global_sid_Unix_NFS_Mode =                 /* Unix mode */
+{ 1, 2, {0,0,0,0,0,5}, {88,3,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+/* Unused, left here for documentary purposes */
+#if 0
+const struct dom_sid global_sid_Unix_NFS_Other =                /* Unix other, MS NFS and Apple style */
+{ 1, 2, {0,0,0,0,0,5}, {88,4,0,0,0,0,0,0,0,0,0,0,0,0,0}};
+#endif
 /* Unused, left here for documentary purposes */
 #if 0
 …
         int i;
         ZERO_STRUCTP(dst);
         dst->sid_rev_num = src->sid_rev_num;
         dst->num_auths = src->num_auths;
+        *dst = (struct dom_sid) {
+                .sid_rev_num = src->sid_rev_num,
+                .num_auths = src->num_auths,
+        };
         memcpy(&dst->id_auth[0], &src->id_auth[0], sizeof(src->id_auth));
 …
 /*****************************************************************
+ Parse a on-the-wire SID (in a DATA_BLOB) to a struct dom_sid.
+*****************************************************************/
+bool sid_blob_parse(DATA_BLOB in, struct dom_sid *sid)
+{
+ Parse a on-the-wire SID to a struct dom_sid.
+*****************************************************************/
+bool sid_parse(const uint8_t *inbuf, size_t len, struct dom_sid *sid)
+{
+        DATA_BLOB in = data_blob_const(inbuf, len);
         enum ndr_err_code ndr_err;
+        ndr_err = ndr_pull_struct_blob_all(&in, NULL, sid,
+                                           (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
+        ndr_err = ndr_pull_struct_blob_all(
+                &in, NULL, sid, (ndr_pull_flags_fn_t)ndr_pull_dom_sid);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return false;
+        }
         return true;
+}
-/*****************************************************************
- Parse a on-the-wire SID to a struct dom_sid.
-*****************************************************************/
-bool sid_parse(const char *inbuf, size_t len, struct dom_sid *sid)
+{
-        DATA_BLOB in = data_blob_const(inbuf, len);
-        return sid_blob_parse(in, sid);
+}
 …
         return dom_sid_compare_auth(sid1, sid2);
+}
-/*****************************************************************
- Compare two sids.
-*****************************************************************/
-bool sid_equal(const struct dom_sid *sid1, const struct dom_sid *sid2)
+{
-        return dom_sid_compare(sid1, sid2) == 0;
+}
 …
         for (i=0; i<(*num_sids); i++) {
                 if (dom_sid_compare(sid, &(*sids)[i]) == 0)
+                if (dom_sid_equal(sid, &(*sids)[i])) {
                         return NT_STATUS_OK;
+                }
+        }
 …
                    and break out of the loop */
                 if ( sid_equal(sid, &sid_list[i]) ) {
+                if (dom_sid_equal(sid, &sid_list[i])) {
                         *num -= 1;
                         break;
 …
         /* This loop will copy the remainder of the array
            if i < num of sids ni the array */
         for ( ; i<*num; i++ )
+           if i < num of sids in the array */
+        for ( ; i<*num; i++ ) {
                 sid_copy( &sid_list[i], &sid_list[i+1] );
+        }
         return;
 …
+{
         static const struct dom_sid null_sid = {0};
         return sid_equal(sid, &null_sid);
+}
+        return dom_sid_equal(sid, &null_sid);
+}

vendor/current/libcli/security/wscript_build

-              r740
+              r988
 bld.SAMBA_LIBRARY('security',
                   source='dom_sid.c display_sec.c secace.c secacl.c security_descriptor.c sddl.c privileges.c security_token.c access_check.c object_tree.c create_descriptor.c util_sid.c session.c',
+bld.SAMBA_LIBRARY('samba-security',
+                  source='dom_sid.c display_sec.c secace.c secacl.c security_descriptor.c sddl.c privileges.c security_token.c access_check.c object_tree.c create_descriptor.c util_sid.c session.c secdesc.c',
                   private_library=True,
                   deps='talloc ndr NDR_SECURITY'
+                  )
+if getattr(bld.env, '_SAMBA_BUILD_', 0) == 4:
+    bld.SAMBA_PYTHON('pysecurity',
+                     source='pysecurity.c',
+                     deps='security pytalloc-util',
+                     realname='samba/security.so'
+                     )
+bld.SAMBA_PYTHON('pysecurity',
+                 source='pysecurity.c',
+                 deps='samba-security pytalloc-util',
+                 realname='samba/security.so'
+                 )

vendor/current/libcli/smb/smb2_constants.h

-              r746
+              r988
 #ifndef __LIBCLI_SMB2_SMB2_CONSTANTS_H__
 #define __LIBCLI_SMB2_SMB2_CONSTANTS_H__
+/* offsets into SMB2_TRANSFORM header elements */
+#define SMB2_TF_PROTOCOL_ID     0x00 /*  4 bytes */
+#define SMB2_TF_SIGNATURE       0x04 /* 16 bytes */
+#define SMB2_TF_NONCE           0x14 /* 16 bytes */
+#define SMB2_TF_MSG_SIZE        0x24 /*  4 bytes */
+#define SMB2_TF_RESERVED        0x28 /*  2 bytes */
+#define SMB2_TF_FLAGS           0x2A /*  2 bytes */
+#define SMB2_TF_SESSION_ID      0x2C /*  8 bytes */
+#define SMB2_TF_HDR_SIZE        0x34 /* 52 bytes */
+#define SMB2_TF_MAGIC 0x424D53FD /* 0xFD 'S' 'M' 'B' */
+#define SMB2_TF_FLAGS_ENCRYPTED     0x0001
 /* offsets into header elements for a sync SMB2 request */
 …
 #define SMB2_HDR_EPOCH          SMB2_HDR_CREDIT_CHARGE /* TODO: remove this */
 #define SMB2_HDR_STATUS         0x08
+#define SMB2_HDR_CHANNEL_SEQUENCE SMB2_HDR_STATUS /* in requests */
 #define SMB2_HDR_OPCODE         0x0c
 #define SMB2_HDR_CREDIT         0x0e
 …
 #define SMB2_HDR_FLAG_CHAINED   0x04
 #define SMB2_HDR_FLAG_SIGNED    0x08
+#define SMB2_HDR_FLAG_PRIORITY_MASK 0x70
 #define SMB2_HDR_FLAG_DFS       0x10000000
+#define SMB2_HDR_FLAG_REPLAY_OPERATION 0x20000000
+#define SMB2_PRIORITY_MASK_TO_VALUE(__m) (((__m) & SMB2_HDR_FLAG_PRIORITY_MASK) >> 4)
+#define SMB2_PRIORITY_VALUE_TO_MASK(__v) (((__v) << 4) & SMB2_HDR_FLAG_PRIORITY_MASK)
 /* SMB2 opcodes */
 #define SMB2_OP_NEGPROT   0x00
 #define SMB2_OP_SESSSETUP 0x01
 #define SMB2_OP_LOGOFF    0x02
 #define SMB2_OP_TCON      0x03
 #define SMB2_OP_TDIS      0x04
 #define SMB2_OP_CREATE    0x05
 #define SMB2_OP_CLOSE     0x06
 #define SMB2_OP_FLUSH     0x07
 #define SMB2_OP_READ      0x08
 #define SMB2_OP_WRITE     0x09
 #define SMB2_OP_LOCK      0x0a
 #define SMB2_OP_IOCTL     0x0b
 #define SMB2_OP_CANCEL    0x0c
 #define SMB2_OP_KEEPALIVE 0x0d
 #define SMB2_OP_FIND      0x0e
 #define SMB2_OP_NOTIFY    0x0f
 #define SMB2_OP_GETINFO   0x10
 #define SMB2_OP_SETINFO   0x11
 #define SMB2_OP_BREAK     0x12
+#define SMB2_OP_NEGPROT         0x00
+#define SMB2_OP_SESSSETUP       0x01
+#define SMB2_OP_LOGOFF          0x02
+#define SMB2_OP_TCON            0x03
+#define SMB2_OP_TDIS            0x04
+#define SMB2_OP_CREATE          0x05
+#define SMB2_OP_CLOSE           0x06
+#define SMB2_OP_FLUSH           0x07
+#define SMB2_OP_READ            0x08
+#define SMB2_OP_WRITE           0x09
+#define SMB2_OP_LOCK            0x0a
+#define SMB2_OP_IOCTL           0x0b
+#define SMB2_OP_CANCEL          0x0c
+#define SMB2_OP_KEEPALIVE       0x0d
+#define SMB2_OP_QUERY_DIRECTORY 0x0e
+#define SMB2_OP_NOTIFY          0x0f
+#define SMB2_OP_GETINFO         0x10
+#define SMB2_OP_SETINFO         0x11
+#define SMB2_OP_BREAK           0x12
 #define SMB2_MAGIC 0x424D53FE /* 0xFE 'S' 'M' 'B' */
 …
 #define SMB2_DIALECT_REVISION_202       0x0202
 #define SMB2_DIALECT_REVISION_210       0x0210
+#define SMB2_DIALECT_REVISION_222       0x0222
+#define SMB2_DIALECT_REVISION_224       0x0224
+#define SMB3_DIALECT_REVISION_300       0x0300
+#define SMB3_DIALECT_REVISION_302       0x0302
+#define SMB3_DIALECT_REVISION_310       0x0310
+#define SMB3_DIALECT_REVISION_311       0x0311
 #define SMB2_DIALECT_REVISION_2FF       0x02FF
 …
 #define SMB2_NEGOTIATE_SIGNING_REQUIRED  0x02
+/* SMB2 capabilities - only 1 so far. I'm sure more will be added */
+#define SMB2_CAP_DFS                     0x00000001
+#define SMB2_CAP_LEASING                 0x00000002 /* only in dialect 0x210 */
+#define SMB2_CAP_LARGE_MTU               0x00000004 /* only in dialect 0x210 */
+/* SMB2 global capabilities */
+#define SMB2_CAP_DFS                    0x00000001
+#define SMB2_CAP_LEASING                0x00000002 /* only in dialect >= 0x210 */
+#define SMB2_CAP_LARGE_MTU              0x00000004 /* only in dialect >= 0x210 */
+#define SMB2_CAP_MULTI_CHANNEL          0x00000008 /* only in dialect >= 0x222 */
+#define SMB2_CAP_PERSISTENT_HANDLES     0x00000010 /* only in dialect >= 0x222 */
+#define SMB2_CAP_DIRECTORY_LEASING      0x00000020 /* only in dialect >= 0x222 */
+#define SMB2_CAP_ENCRYPTION             0x00000040 /* only in dialect >= 0x222 */
 /* so we can spot new caps as added */
+#define SMB2_CAP_ALL                     SMB2_CAP_DFS
+/* SMB2 session flags */
+#define SMB2_CAP_ALL (\
+                SMB2_CAP_DFS | \
+                SMB2_CAP_LEASING | \
+                SMB2_CAP_LARGE_MTU | \
+                SMB2_CAP_MULTI_CHANNEL | \
+                SMB2_CAP_PERSISTENT_HANDLES | \
+                SMB2_CAP_DIRECTORY_LEASING | \
+                SMB2_CAP_ENCRYPTION)
+/* Types of SMB2 Negotiate Contexts - only in dialect >= 0x310 */
+#define SMB2_PREAUTH_INTEGRITY_CAPABILITIES 0x0001
+#define SMB2_ENCRYPTION_CAPABILITIES        0x0002
+/* Values for the SMB2_PREAUTH_INTEGRITY_CAPABILITIES Context (>= 0x310) */
+#define SMB2_PREAUTH_INTEGRITY_SHA512       0x0001
+/* Values for the SMB2_ENCRYPTION_CAPABILITIES Context (>= 0x310) */
+#define SMB2_ENCRYPTION_AES128_CCM         0x0001 /* only in dialect >= 0x224 */
+#define SMB2_ENCRYPTION_AES128_GCM         0x0002 /* only in dialect >= 0x310 */
+#define SMB2_NONCE_HIGH_MAX(nonce_len_bytes) ((uint64_t)(\
+        ((nonce_len_bytes) >= 16) ? UINT64_MAX : \
+        ((nonce_len_bytes) <= 8) ? 0 : \
+        (((uint64_t)1 << (((nonce_len_bytes) - 8)*8)) - 1) \
+        ))
+/* SMB2 session (request) flags */
+#define SMB2_SESSION_FLAG_BINDING       0x01
+/*      SMB2_SESSION_FLAG_ENCRYPT_DATA  0x04       only in dialect >= 0x310 */
+/* SMB2 session (response) flags */
 #define SMB2_SESSION_FLAG_IS_GUEST       0x0001
 #define SMB2_SESSION_FLAG_IS_NULL        0x0002
+#define SMB2_SESSION_FLAG_ENCRYPT_DATA   0x0004 /* in dialect >= 0x224 */
+/* SMB2 tree connect (request) flags */
+#define SMB2_SHAREFLAG_CLUSTER_RECONNECT 0x0001 /* only in dialect >= 0x310 */
 /* SMB2 sharetype flags */
 …
 #define SMB2_SHAREFLAG_ALLOW_NAMESPACE_CACHING           0x0400
 #define SMB2_SHAREFLAG_ACCESS_BASED_DIRECTORY_ENUM       0x0800
+#define SMB2_SHAREFLAG_ALL                               0x0F33
+/* SMB2 share capafilities */
+#define SMB2_SHARE_CAP_DFS              0x8
+#define SMB2_SHAREFLAG_FORCE_LEVELII_OPLOCKS             0x1000
+#define SMB2_SHAREFLAG_ENABLE_HASH_V1                    0x2000
+#define SMB2_SHAREFLAG_ENABLE_HASH_V2                    0x4000
+#define SMB2_SHAREFLAG_ENCRYPT_DATA                      0x8000
+#define SMB2_SHAREFLAG_ALL                               0xFF33
+/* SMB2 share capabilities */
+#define SMB2_SHARE_CAP_DFS                      0x8
+#define SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY  0x10 /* in dialect >= 0x222 */
+#define SMB2_SHARE_CAP_SCALEOUT                 0x20 /* in dialect >= 0x222 */
+#define SMB2_SHARE_CAP_CLUSTER                  0x40 /* in dialect >= 0x222 */
+#define SMB2_SHARE_CAP_ASYMMETRIC               0x80 /* in dialect >= 0x302 */
 /* SMB2 create security flags */
 …
 /* SMB2 lease bits */
 #define SMB2_LEASE_NONE                                  0x00
+#define SMB2_LEASE_READ                                  0x01
+#define SMB2_LEASE_HANDLE                                0x02
+#define SMB2_LEASE_WRITE                                 0x04
+/* SMB2 lease flags */
+#define SMB2_LEASE_FLAG_BREAK_IN_PROGRESS                0x00000002
+#define SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET             0x00000004
 /* SMB2 lease break flags */
 …
 #define SMB2_CREATE_TAG_QFID "QFid"
 #define SMB2_CREATE_TAG_RQLS "RqLs"
+#define SMB2_CREATE_TAG_DH2Q "DH2Q"
+#define SMB2_CREATE_TAG_DH2C "DH2C"
+#define SMB2_CREATE_TAG_AAPL "AAPL"
+#define SMB2_CREATE_TAG_APP_INSTANCE_ID "\x45\xBC\xA6\x6A\xEF\xA7\xF7\x4A\x90\x08\xFA\x46\x2E\x14\x4D\x74"
+#define SVHDX_OPEN_DEVICE_CONTEXT "\x9C\xCB\xCF\x9E\x04\xC1\xE6\x43\x98\x0E\x15\x8D\xA1\xF6\xEC\x83"
+/* SMB2 notify flags */
+#define SMB2_WATCH_TREE 0x0001
 /* SMB2 Create ignore some more create_options */
 …
 #define SMB2_CLOSE_FLAGS_FULL_INFORMATION (0x01)
+#define SMB2_READFLAG_READ_UNBUFFERED   0x01
+#define SMB2_WRITEFLAG_WRITE_THROUGH    0x00000001
+#define SMB2_WRITEFLAG_WRITE_UNBUFFERED 0x00000002
+/* 2.2.31 SMB2 IOCTL Request */
+#define SMB2_IOCTL_FLAG_IS_FSCTL                0x00000001
+/*
+ * Flags for durable handle v2 requests
+ */
+#define SMB2_DHANDLE_FLAG_PERSISTENT 0x00000002
 #endif

vendor/current/libcli/smb/smb2_create_blob.c

-              r746
+              r988
                 uint32_t next;
                 uint32_t name_offset, name_length;
                 uint32_t reserved, data_offset;
+                uint32_t data_offset;
                 uint32_t data_length;
                 char *tag;
 …
                 name_offset = SVAL(data, 4);
                 name_length = SVAL(data, 6);
+#if 0
                 reserved    = SVAL(data, 8);
+#endif
                 data_offset = SVAL(data, 10);
                 data_length = IVAL(data, 12);
 …
                 NT_STATUS_HAVE_NO_MEMORY(b->blobs[b->num_blobs].data.data);
         } else {
                 b->blobs[b->num_blobs].data = data_blob(NULL, 0);
+                b->blobs[b->num_blobs].data = data_blob_null;
+        }

vendor/current/libcli/smb/smb2_create_blob.h

-              r414
+              r988
 };
+struct smb_create_returns {
+        uint8_t oplock_level;
+        uint32_t create_action;
+        NTTIME creation_time;
+        NTTIME last_access_time;
+        NTTIME last_write_time;
+        NTTIME change_time;
+        uint64_t allocation_size;
+        uint64_t end_of_file;
+        uint32_t file_attributes;
+};
 /*
   parse a set of SMB2 create blobs

vendor/current/libcli/smb/smb_common.h

-              r414
+              r988
 #define __LIBCLI_SMB_SMB_COMMON_H__
+#include "../libcli/smb/smb2_constants.h"
+#include "../libcli/smb/smb2_create_blob.h"
+#include "libcli/smb/smb_constants.h"
+#include "libcli/smb/smb2_constants.h"
+#include "libcli/smb/smb2_create_blob.h"
+#include "libcli/smb/smb2_lease.h"
+#include "libcli/smb/smb2_signing.h"
+#include "libcli/smb/smb_util.h"
+#include "libcli/smb/smb_unix_ext.h"
 #endif

vendor/current/libcli/smbreadline/smbreadline.c

-              r740
+              r988
                 warnings in some.  */
                 rl_attempted_completion_function = RL_COMPLETION_CAST completion_fn;
+                /*
+                 * We only want sensible characters as the word-break chars
+                 * for the most part. This allows us to tab through a path.
+                 */
+                rl_basic_word_break_characters = " \t\n";
+        }
 #if HAVE_DECL_RL_EVENT_HOOK
         if (callback)
                 rl_event_hook = (Function *)callback;
+                rl_event_hook = (rl_hook_func_t *)callback;
 #endif
         ret = readline(prompt);

vendor/current/libcli/util/doserr.c

-              r740
+              r988
         { "WERR_NOT_SUPPORTED", WERR_NOT_SUPPORTED },
         { "WERR_DUP_NAME", WERR_DUP_NAME },
-        { "WERR_BAD_PASSWORD", WERR_BAD_PASSWORD },
         { "WERR_NOMEM", WERR_NOMEM },
         { "WERR_INVALID_NAME", WERR_INVALID_NAME },
-        { "WERR_UNKNOWN_LEVEL", WERR_UNKNOWN_LEVEL },
         { "WERR_OBJECT_PATH_INVALID", WERR_OBJECT_PATH_INVALID },
         { "WERR_ALREADY_EXISTS", WERR_ALREADY_EXISTS },
 …
         { "WERR_WRONG_PASSWORD", WERR_WRONG_PASSWORD },
         { "WERR_CLASS_NOT_REGISTERED", WERR_CLASS_NOT_REGISTERED },
+        { "WERR_PRINT_PROCESSOR_ALREADY_INSTALLED", WERR_PRINT_PROCESSOR_ALREADY_INSTALLED },
         /*****************************************************************************
          Auto-generated Win32 error from:
 …
         { WERR_INVALID_PARAM, "Invalid parameter" },
         { WERR_NOT_SUPPORTED, "Not supported" },
-        { WERR_BAD_PASSWORD, "A bad password was supplied" },
         { WERR_NOMEM, "Out of memory" },
         { WERR_NO_LOGON_SERVERS, "No logon servers found" },

vendor/current/libcli/util/error.h

-              r740
+              r988
 #include "libcli/util/doserr.h"
 #include "libcli/util/ntstatus.h"
+/** NT error on DOS connection! (NT_STATUS_OK) */
+bool ntstatus_dos_equal(NTSTATUS status1, NTSTATUS status2);
+#include "libcli/util/hresult.h"
 /*****************************************************************************
 …
  Map an NT error code from a Unix error code.
 *********************************************************************/
+NTSTATUS map_nt_error_from_unix(int unix_error);
+/*********************************************************************
+convert a Unix error code to a WERROR
+*********************************************************************/
+WERROR unix_to_werror(int unix_error);
+NTSTATUS map_nt_error_from_unix_common(int unix_error);
 NTSTATUS nt_status_squash(NTSTATUS nt_status);
+/*****************************************************************************
+convert a Unix error to a WERROR
+ *****************************************************************************/
+WERROR unix_to_werror(int unix_error);
 #endif /* _SAMBA_ERROR_H */

vendor/current/libcli/util/ntstatus.h

-              r740
+              r988
 #define STATUS_INVALID_EA_FLAG            NT_STATUS(0x80000015)
 #define NT_STATUS_NO_MORE_ENTRIES         NT_STATUS(0x8000001a)
+#define STATUS_STOPPED_ON_SYMLINK         NT_STATUS(0x8000002d)
 #define STATUS_PENDING                    NT_STATUS(0x0103)
 …
 #define NT_STATUS_DS_NO_MORE_RIDS NT_STATUS(0xC0000000 | 0x02A8)
 #define NT_STATUS_NOT_A_REPARSE_POINT NT_STATUS(0xC0000000 | 0x0275)
+#define NT_STATUS_IO_REPARSE_DATA_INVALID NT_STATUS(0xC0000000 | 0x0278)
+#define NT_STATUS_IO_REPARSE_TAG_NOT_HANDLED NT_STATUS(0xC0000000 | 0x0279)
 #define NT_STATUS_CURRENT_DOMAIN_NOT_ALLOWED NT_STATUS(0xC0000000 | 0x02E9)
 #define NT_STATUS_OBJECTID_NOT_FOUND NT_STATUS(0xC0000000 | 0x02F0)
 #define NT_STATUS_NO_SUCH_JOB NT_STATUS(0xC0000000 | 0xEDE) /* scheduler */
+#define NT_STATUS_NETWORK_SESSION_EXPIRED NT_STATUS(0xC0000000 | 0x035C)
+#define NT_STATUS_ALL_SIDS_FILTERED NT_STATUS(0xC0000000 | 0x035E)
 #define NT_STATUS_DOWNGRADE_DETECTED NT_STATUS(0xC0000000 | 0x0388)
 #define NT_STATUS_NO_S4U_PROT_SUPPORT NT_STATUS(0xC0000000 | 0x040A)
 #define NT_STATUS_CROSSREALM_DELEGATION_FAILURE NT_STATUS(0xC0000000 | 0x040B)
 #define NT_STATUS_NO_SUCH_JOB NT_STATUS(0xC0000000 | 0xEDE) /* scheduler */
+#define NT_STATUS_FILE_NOT_AVAILABLE NT_STATUS(0xC0000000 | 0x0467)
 #define NT_STATUS_RPC_PROTSEQ_NOT_SUPPORTED NT_STATUS(0xC0000000 | 0x20004)
 #define NT_STATUS_RPC_UNSUPPORTED_NAME_SYNTAX NT_STATUS(0xC0000000 | 0x20026)
 …
 #define NT_STATUS_RPC_SEC_PKG_ERROR NT_STATUS(0xC0000000 | 0x20057)
 #define NT_STATUS_RPC_SS_CONTEXT_MISMATCH NT_STATUS(0xC0000000 | 0x30005)
 #define NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE NT_STATUS(0xC000000 | 0x3000A)
+#define NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE NT_STATUS(0xC0000000 | 0x3000A)
 #define NT_STATUS_RPC_BAD_STUB_DATA NT_STATUS(0xC0000000 | 0x3000C)
 #define NT_STATUS_RPC_INVALID_PIPE_OBJECT NT_STATUS(0xC0000000 | 0x3005C)
 …
 #define NT_STATUS_ERROR_DS_INCOMPATIBLE_VERSION NT_STATUS(0xC0000000 | 0x00002177)
+/*
+ * New descriptions for new errors generated from
+ * [MS-ERREF] http://msdn.microsoft.com/en-us/library/cc704588.aspx
+ */
+#define NT_STATUS_WAIT_1                                  NT_STATUS(0x00000001)
+#define NT_STATUS_WAIT_2                                  NT_STATUS(0x00000002)
+#define NT_STATUS_WAIT_3                                  NT_STATUS(0x00000003)
+#define NT_STATUS_WAIT_63                                 NT_STATUS(0x0000003F)
+#define NT_STATUS_ABANDONED                               NT_STATUS(0x00000080)
+#define NT_STATUS_ABANDONED_WAIT_0                        NT_STATUS(0x00000080)
+#define NT_STATUS_ABANDONED_WAIT_63                       NT_STATUS(0x000000BF)
+#define NT_STATUS_USER_APC                                NT_STATUS(0x000000C0)
+#define NT_STATUS_ALERTED                                 NT_STATUS(0x00000101)
+#define NT_STATUS_TIMEOUT                                 NT_STATUS(0x00000102)
+#define NT_STATUS_REPARSE                                 NT_STATUS(0x00000104)
+#define NT_STATUS_NOT_ALL_ASSIGNED                        NT_STATUS(0x00000106)
+#define NT_STATUS_OPLOCK_BREAK_IN_PROGRESS                NT_STATUS(0x00000108)
+#define NT_STATUS_VOLUME_MOUNTED                          NT_STATUS(0x00000109)
+#define NT_STATUS_RXACT_COMMITTED                         NT_STATUS(0x0000010A)
+#define NT_STATUS_NO_QUOTAS_FOR_ACCOUNT                   NT_STATUS(0x0000010D)
+#define NT_STATUS_PRIMARY_TRANSPORT_CONNECT_FAILED        NT_STATUS(0x0000010E)
+#define NT_STATUS_PAGE_FAULT_TRANSITION                   NT_STATUS(0x00000110)
+#define NT_STATUS_PAGE_FAULT_DEMAND_ZERO                  NT_STATUS(0x00000111)
+#define NT_STATUS_PAGE_FAULT_COPY_ON_WRITE                NT_STATUS(0x00000112)
+#define NT_STATUS_PAGE_FAULT_GUARD_PAGE                   NT_STATUS(0x00000113)
+#define NT_STATUS_PAGE_FAULT_PAGING_FILE                  NT_STATUS(0x00000114)
+#define NT_STATUS_CACHE_PAGE_LOCKED                       NT_STATUS(0x00000115)
+#define NT_STATUS_CRASH_DUMP                              NT_STATUS(0x00000116)
+#define NT_STATUS_BUFFER_ALL_ZEROS                        NT_STATUS(0x00000117)
+#define NT_STATUS_REPARSE_OBJECT                          NT_STATUS(0x00000118)
+#define NT_STATUS_RESOURCE_REQUIREMENTS_CHANGED           NT_STATUS(0x00000119)
+#define NT_STATUS_TRANSLATION_COMPLETE                    NT_STATUS(0x00000120)
+#define NT_STATUS_DS_MEMBERSHIP_EVALUATED_LOCALLY         NT_STATUS(0x00000121)
+#define NT_STATUS_NOTHING_TO_TERMINATE                    NT_STATUS(0x00000122)
+#define NT_STATUS_PROCESS_NOT_IN_JOB                      NT_STATUS(0x00000123)
+#define NT_STATUS_PROCESS_IN_JOB                          NT_STATUS(0x00000124)
+#define NT_STATUS_VOLSNAP_HIBERNATE_READY                 NT_STATUS(0x00000125)
+#define NT_STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY      NT_STATUS(0x00000126)
+#define NT_STATUS_INTERRUPT_VECTOR_ALREADY_CONNECTED      NT_STATUS(0x00000127)
+#define NT_STATUS_INTERRUPT_STILL_CONNECTED               NT_STATUS(0x00000128)
+#define NT_STATUS_PROCESS_CLONED                          NT_STATUS(0x00000129)
+#define NT_STATUS_FILE_LOCKED_WITH_ONLY_READERS           NT_STATUS(0x0000012A)
+#define NT_STATUS_FILE_LOCKED_WITH_WRITERS                NT_STATUS(0x0000012B)
+#define NT_STATUS_RESOURCEMANAGER_READ_ONLY               NT_STATUS(0x00000202)
+#define NT_STATUS_WAIT_FOR_OPLOCK                         NT_STATUS(0x00000367)
+#define NT_STATUS_DBG_EXCEPTION_HANDLED                   NT_STATUS(0x00010001)
+#define NT_STATUS_DBG_CONTINUE                            NT_STATUS(0x00010002)
+#define NT_STATUS_FLT_IO_COMPLETE                         NT_STATUS(0x001C0001)
+#define NT_STATUS_CALLBACK_RETURNED_THREAD_AFFINITY       NT_STATUS(0xC0000721)
+#define NT_STATUS_OBJECT_NAME_EXISTS                      NT_STATUS(0x40000000)
+#define NT_STATUS_THREAD_WAS_SUSPENDED                    NT_STATUS(0x40000001)
+#define NT_STATUS_WORKING_SET_LIMIT_RANGE                 NT_STATUS(0x40000002)
+#define NT_STATUS_IMAGE_NOT_AT_BASE                       NT_STATUS(0x40000003)
+#define NT_STATUS_RXACT_STATE_CREATED                     NT_STATUS(0x40000004)
+#define NT_STATUS_SEGMENT_NOTIFICATION                    NT_STATUS(0x40000005)
+#define NT_STATUS_LOCAL_USER_SESSION_KEY                  NT_STATUS(0x40000006)
+#define NT_STATUS_BAD_CURRENT_DIRECTORY                   NT_STATUS(0x40000007)
+#define NT_STATUS_SERIAL_MORE_WRITES                      NT_STATUS(0x40000008)
+#define NT_STATUS_REGISTRY_RECOVERED                      NT_STATUS(0x40000009)
+#define NT_STATUS_FT_READ_RECOVERY_FROM_BACKUP            NT_STATUS(0x4000000A)
+#define NT_STATUS_FT_WRITE_RECOVERY                       NT_STATUS(0x4000000B)
+#define NT_STATUS_SERIAL_COUNTER_TIMEOUT                  NT_STATUS(0x4000000C)
+#define NT_STATUS_NULL_LM_PASSWORD                        NT_STATUS(0x4000000D)
+#define NT_STATUS_IMAGE_MACHINE_TYPE_MISMATCH             NT_STATUS(0x4000000E)
+#define NT_STATUS_RECEIVE_PARTIAL                         NT_STATUS(0x4000000F)
+#define NT_STATUS_RECEIVE_EXPEDITED                       NT_STATUS(0x40000010)
+#define NT_STATUS_RECEIVE_PARTIAL_EXPEDITED               NT_STATUS(0x40000011)
+#define NT_STATUS_EVENT_DONE                              NT_STATUS(0x40000012)
+#define NT_STATUS_EVENT_PENDING                           NT_STATUS(0x40000013)
+#define NT_STATUS_CHECKING_FILE_SYSTEM                    NT_STATUS(0x40000014)
+#define NT_STATUS_FATAL_APP_EXIT                          NT_STATUS(0x40000015)
+#define NT_STATUS_PREDEFINED_HANDLE                       NT_STATUS(0x40000016)
+#define NT_STATUS_WAS_UNLOCKED                            NT_STATUS(0x40000017)
+#define NT_STATUS_SERVICE_NOTIFICATION                    NT_STATUS(0x40000018)
+#define NT_STATUS_WAS_LOCKED                              NT_STATUS(0x40000019)
+#define NT_STATUS_LOG_HARD_ERROR                          NT_STATUS(0x4000001A)
+#define NT_STATUS_ALREADY_WIN32                           NT_STATUS(0x4000001B)
+#define NT_STATUS_WX86_UNSIMULATE                         NT_STATUS(0x4000001C)
+#define NT_STATUS_WX86_CONTINUE                           NT_STATUS(0x4000001D)
+#define NT_STATUS_WX86_SINGLE_STEP                        NT_STATUS(0x4000001E)
+#define NT_STATUS_WX86_BREAKPOINT                         NT_STATUS(0x4000001F)
+#define NT_STATUS_WX86_EXCEPTION_CONTINUE                 NT_STATUS(0x40000020)
+#define NT_STATUS_WX86_EXCEPTION_LASTCHANCE               NT_STATUS(0x40000021)
+#define NT_STATUS_WX86_EXCEPTION_CHAIN                    NT_STATUS(0x40000022)
+#define NT_STATUS_IMAGE_MACHINE_TYPE_MISMATCH_EXE         NT_STATUS(0x40000023)
+#define NT_STATUS_NO_YIELD_PERFORMED                      NT_STATUS(0x40000024)
+#define NT_STATUS_TIMER_RESUME_IGNORED                    NT_STATUS(0x40000025)
+#define NT_STATUS_ARBITRATION_UNHANDLED                   NT_STATUS(0x40000026)
+#define NT_STATUS_CARDBUS_NOT_SUPPORTED                   NT_STATUS(0x40000027)
+#define NT_STATUS_WX86_CREATEWX86TIB                      NT_STATUS(0x40000028)
+#define NT_STATUS_MP_PROCESSOR_MISMATCH                   NT_STATUS(0x40000029)
+#define NT_STATUS_HIBERNATED                              NT_STATUS(0x4000002A)
+#define NT_STATUS_RESUME_HIBERNATION                      NT_STATUS(0x4000002B)
+#define NT_STATUS_FIRMWARE_UPDATED                        NT_STATUS(0x4000002C)
+#define NT_STATUS_DRIVERS_LEAKING_LOCKED_PAGES            NT_STATUS(0x4000002D)
+#define NT_STATUS_MESSAGE_RETRIEVED                       NT_STATUS(0x4000002E)
+#define NT_STATUS_SYSTEM_POWERSTATE_TRANSITION            NT_STATUS(0x4000002F)
+#define NT_STATUS_ALPC_CHECK_COMPLETION_LIST              NT_STATUS(0x40000030)
+#define NT_STATUS_SYSTEM_POWERSTATE_COMPLEX_TRANSITION    NT_STATUS(0x40000031)
+#define NT_STATUS_ACCESS_AUDIT_BY_POLICY                  NT_STATUS(0x40000032)
+#define NT_STATUS_ABANDON_HIBERFILE                       NT_STATUS(0x40000033)
+#define NT_STATUS_BIZRULES_NOT_ENABLED                    NT_STATUS(0x40000034)
+#define NT_STATUS_WAKE_SYSTEM                             NT_STATUS(0x40000294)
+#define NT_STATUS_DS_SHUTTING_DOWN                        NT_STATUS(0x40000370)
+#define NT_STATUS_DBG_REPLY_LATER                         NT_STATUS(0x40010001)
+#define NT_STATUS_DBG_UNABLE_TO_PROVIDE_HANDLE            NT_STATUS(0x40010002)
+#define NT_STATUS_DBG_TERMINATE_THREAD                    NT_STATUS(0x40010003)
+#define NT_STATUS_DBG_TERMINATE_PROCESS                   NT_STATUS(0x40010004)
+#define NT_STATUS_DBG_CONTROL_C                           NT_STATUS(0x40010005)
+#define NT_STATUS_DBG_PRINTEXCEPTION_C                    NT_STATUS(0x40010006)
+#define NT_STATUS_DBG_RIPEXCEPTION                        NT_STATUS(0x40010007)
+#define NT_STATUS_DBG_CONTROL_BREAK                       NT_STATUS(0x40010008)
+#define NT_STATUS_DBG_COMMAND_EXCEPTION                   NT_STATUS(0x40010009)
+#define NT_STATUS_RPC_UUID_LOCAL_ONLY                     NT_STATUS(0x40020056)
+#define NT_STATUS_RPC_SEND_INCOMPLETE                     NT_STATUS(0x400200AF)
+#define NT_STATUS_CTX_CDM_CONNECT                         NT_STATUS(0x400A0004)
+#define NT_STATUS_CTX_CDM_DISCONNECT                      NT_STATUS(0x400A0005)
+#define NT_STATUS_SXS_RELEASE_ACTIVATION_CONTEXT          NT_STATUS(0x4015000D)
+#define NT_STATUS_RECOVERY_NOT_NEEDED                     NT_STATUS(0x40190034)
+#define NT_STATUS_RM_ALREADY_STARTED                      NT_STATUS(0x40190035)
+#define NT_STATUS_LOG_NO_RESTART                          NT_STATUS(0x401A000C)
+#define NT_STATUS_VIDEO_DRIVER_DEBUG_REPORT_REQUEST       NT_STATUS(0x401B00EC)
+#define NT_STATUS_GRAPHICS_PARTIAL_DATA_POPULATED         NT_STATUS(0x401E000A)
+#define NT_STATUS_GRAPHICS_DRIVER_MISMATCH                NT_STATUS(0x401E0117)
+#define NT_STATUS_GRAPHICS_MODE_NOT_PINNED                NT_STATUS(0x401E0307)
+#define NT_STATUS_GRAPHICS_NO_PREFERRED_MODE              NT_STATUS(0x401E031E)
+#define NT_STATUS_GRAPHICS_DATASET_IS_EMPTY               NT_STATUS(0x401E034B)
+#define NT_STATUS_GRAPHICS_NO_MORE_ELEMENTS_IN_DATASET    NT_STATUS(0x401E034C)
+#define NT_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_PINNED NT_STATUS(0x401E0351)
+#define NT_STATUS_GRAPHICS_UNKNOWN_CHILD_STATUS           NT_STATUS(0x401E042F)
+#define NT_STATUS_GRAPHICS_LEADLINK_START_DEFERRED        NT_STATUS(0x401E0437)
+#define NT_STATUS_GRAPHICS_POLLING_TOO_FREQUENTLY         NT_STATUS(0x401E0439)
+#define NT_STATUS_GRAPHICS_START_DEFERRED                 NT_STATUS(0x401E043A)
+#define NT_STATUS_NDIS_INDICATION_REQUIRED                NT_STATUS(0x40230001)
+#define NT_STATUS_GUARD_PAGE_VIOLATION                    NT_STATUS(0x80000001)
+#define NT_STATUS_DATATYPE_MISALIGNMENT                   NT_STATUS(0x80000002)
+#define NT_STATUS_BREAKPOINT                              NT_STATUS(0x80000003)
+#define NT_STATUS_SINGLE_STEP                             NT_STATUS(0x80000004)
+#define NT_STATUS_WAKE_SYSTEM_DEBUGGER                    NT_STATUS(0x80000007)
+#define NT_STATUS_HANDLES_CLOSED                          NT_STATUS(0x8000000A)
+#define NT_STATUS_NO_INHERITANCE                          NT_STATUS(0x8000000B)
+#define NT_STATUS_GUID_SUBSTITUTION_MADE                  NT_STATUS(0x8000000C)
+#define NT_STATUS_PARTIAL_COPY                            NT_STATUS(0x8000000D)
+#define NT_STATUS_DEVICE_PAPER_EMPTY                      NT_STATUS(0x8000000E)
+#define NT_STATUS_DEVICE_POWERED_OFF                      NT_STATUS(0x8000000F)
+#define NT_STATUS_DEVICE_OFF_LINE                         NT_STATUS(0x80000010)
+#define NT_STATUS_DEVICE_BUSY                             NT_STATUS(0x80000011)
+#define NT_STATUS_VERIFY_REQUIRED                         NT_STATUS(0x80000016)
+#define NT_STATUS_EXTRANEOUS_INFORMATION                  NT_STATUS(0x80000017)
+#define NT_STATUS_RXACT_COMMIT_NECESSARY                  NT_STATUS(0x80000018)
+#define NT_STATUS_FILEMARK_DETECTED                       NT_STATUS(0x8000001B)
+#define NT_STATUS_MEDIA_CHANGED                           NT_STATUS(0x8000001C)
+#define NT_STATUS_BUS_RESET                               NT_STATUS(0x8000001D)
+#define NT_STATUS_END_OF_MEDIA                            NT_STATUS(0x8000001E)
+#define NT_STATUS_BEGINNING_OF_MEDIA                      NT_STATUS(0x8000001F)
+#define NT_STATUS_MEDIA_CHECK                             NT_STATUS(0x80000020)
+#define NT_STATUS_SETMARK_DETECTED                        NT_STATUS(0x80000021)
+#define NT_STATUS_NO_DATA_DETECTED                        NT_STATUS(0x80000022)
+#define NT_STATUS_REDIRECTOR_HAS_OPEN_HANDLES             NT_STATUS(0x80000023)
+#define NT_STATUS_SERVER_HAS_OPEN_HANDLES                 NT_STATUS(0x80000024)
+#define NT_STATUS_ALREADY_DISCONNECTED                    NT_STATUS(0x80000025)
+#define NT_STATUS_LONGJUMP                                NT_STATUS(0x80000026)
+#define NT_STATUS_CLEANER_CARTRIDGE_INSTALLED             NT_STATUS(0x80000027)
+#define NT_STATUS_PLUGPLAY_QUERY_VETOED                   NT_STATUS(0x80000028)
+#define NT_STATUS_UNWIND_CONSOLIDATE                      NT_STATUS(0x80000029)
+#define NT_STATUS_REGISTRY_HIVE_RECOVERED                 NT_STATUS(0x8000002A)
+#define NT_STATUS_DLL_MIGHT_BE_INSECURE                   NT_STATUS(0x8000002B)
+#define NT_STATUS_DLL_MIGHT_BE_INCOMPATIBLE               NT_STATUS(0x8000002C)
+#define NT_STATUS_DEVICE_REQUIRES_CLEANING                NT_STATUS(0x80000288)
+#define NT_STATUS_DEVICE_DOOR_OPEN                        NT_STATUS(0x80000289)
+#define NT_STATUS_DATA_LOST_REPAIR                        NT_STATUS(0x80000803)
+#define NT_STATUS_DBG_EXCEPTION_NOT_HANDLED               NT_STATUS(0x80010001)
+#define NT_STATUS_CLUSTER_NODE_ALREADY_UP                 NT_STATUS(0x80130001)
+#define NT_STATUS_CLUSTER_NODE_ALREADY_DOWN               NT_STATUS(0x80130002)
+#define NT_STATUS_CLUSTER_NETWORK_ALREADY_ONLINE          NT_STATUS(0x80130003)
+#define NT_STATUS_CLUSTER_NETWORK_ALREADY_OFFLINE         NT_STATUS(0x80130004)
+#define NT_STATUS_CLUSTER_NODE_ALREADY_MEMBER             NT_STATUS(0x80130005)
+#define NT_STATUS_COULD_NOT_RESIZE_LOG                    NT_STATUS(0x80190009)
+#define NT_STATUS_NO_TXF_METADATA                         NT_STATUS(0x80190029)
+#define NT_STATUS_CANT_RECOVER_WITH_HANDLE_OPEN           NT_STATUS(0x80190031)
+#define NT_STATUS_TXF_METADATA_ALREADY_PRESENT            NT_STATUS(0x80190041)
+#define NT_STATUS_TRANSACTION_SCOPE_CALLBACKS_NOT_SET     NT_STATUS(0x80190042)
+#define NT_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD_RECOVERED NT_STATUS(0x801B00EB)
+#define NT_STATUS_FLT_BUFFER_TOO_SMALL                    NT_STATUS(0x801C0001)
+#define NT_STATUS_FVE_PARTIAL_METADATA                    NT_STATUS(0x80210001)
+#define NT_STATUS_FVE_TRANSIENT_STATE                     NT_STATUS(0x80210002)
+#define NT_STATUS_VARIABLE_NOT_FOUND                      NT_STATUS(0xC0000100)
+#define NT_STATUS_BIOS_FAILED_TO_CONNECT_INTERRUPT        NT_STATUS(0xC000016E)
+#define NT_STATUS_IMAGE_ALREADY_LOADED_AS_DLL             NT_STATUS(0xC000019D)
+#define NT_STATUS_INCOMPATIBLE_WITH_GLOBAL_SHORT_NAME_REGISTRY_SETTING NT_STATUS(0xC000019E)
+#define NT_STATUS_SHORT_NAMES_NOT_ENABLED_ON_VOLUME       NT_STATUS(0xC000019F)
+#define NT_STATUS_SECURITY_STREAM_IS_INCONSISTENT         NT_STATUS(0xC00001A0)
+#define NT_STATUS_INVALID_ACE_CONDITION                   NT_STATUS(0xC00001A2)
+#define NT_STATUS_IMAGE_SUBSYSTEM_NOT_PRESENT             NT_STATUS(0xC00001A3)
+#define NT_STATUS_NOTIFICATION_GUID_ALREADY_DEFINED       NT_STATUS(0xC00001A4)
+#define NT_STATUS_NETWORK_OPEN_RESTRICTION                NT_STATUS(0xC0000201)
+#define NT_STATUS_EVALUATION_EXPIRATION                   NT_STATUS(0xC0000268)
+#define NT_STATUS_ILLEGAL_DLL_RELOCATION                  NT_STATUS(0xC0000269)
+#define NT_STATUS_LICENSE_VIOLATION                       NT_STATUS(0xC000026A)
+#define NT_STATUS_DLL_INIT_FAILED_LOGOFF                  NT_STATUS(0xC000026B)
+#define NT_STATUS_DRIVER_UNABLE_TO_LOAD                   NT_STATUS(0xC000026C)
+#define NT_STATUS_DFS_UNAVAILABLE                         NT_STATUS(0xC000026D)
+#define NT_STATUS_VOLUME_DISMOUNTED                       NT_STATUS(0xC000026E)
+#define NT_STATUS_WX86_INTERNAL_ERROR                     NT_STATUS(0xC000026F)
+#define NT_STATUS_WX86_FLOAT_STACK_CHECK                  NT_STATUS(0xC0000270)
+#define NT_STATUS_VALIDATE_CONTINUE                       NT_STATUS(0xC0000271)
+#define NT_STATUS_NO_MATCH                                NT_STATUS(0xC0000272)
+#define NT_STATUS_NO_MORE_MATCHES                         NT_STATUS(0xC0000273)
+#define NT_STATUS_IO_REPARSE_TAG_INVALID                  NT_STATUS(0xC0000276)
+#define NT_STATUS_IO_REPARSE_TAG_MISMATCH                 NT_STATUS(0xC0000277)
+#define NT_STATUS_REPARSE_POINT_NOT_RESOLVED              NT_STATUS(0xC0000280)
+#define NT_STATUS_DIRECTORY_IS_A_REPARSE_POINT            NT_STATUS(0xC0000281)
+#define NT_STATUS_RANGE_LIST_CONFLICT                     NT_STATUS(0xC0000282)
+#define NT_STATUS_SOURCE_ELEMENT_EMPTY                    NT_STATUS(0xC0000283)
+#define NT_STATUS_DESTINATION_ELEMENT_FULL                NT_STATUS(0xC0000284)
+#define NT_STATUS_ILLEGAL_ELEMENT_ADDRESS                 NT_STATUS(0xC0000285)
+#define NT_STATUS_MAGAZINE_NOT_PRESENT                    NT_STATUS(0xC0000286)
+#define NT_STATUS_REINITIALIZATION_NEEDED                 NT_STATUS(0xC0000287)
+#define NT_STATUS_ENCRYPTION_FAILED                       NT_STATUS(0xC000028A)
+#define NT_STATUS_DECRYPTION_FAILED                       NT_STATUS(0xC000028B)
+#define NT_STATUS_RANGE_NOT_FOUND                         NT_STATUS(0xC000028C)
+#define NT_STATUS_NO_RECOVERY_POLICY                      NT_STATUS(0xC000028D)
+#define NT_STATUS_NO_EFS                                  NT_STATUS(0xC000028E)
+#define NT_STATUS_WRONG_EFS                               NT_STATUS(0xC000028F)
+#define NT_STATUS_NO_USER_KEYS                            NT_STATUS(0xC0000290)
+#define NT_STATUS_FILE_NOT_ENCRYPTED                      NT_STATUS(0xC0000291)
+#define NT_STATUS_NOT_EXPORT_FORMAT                       NT_STATUS(0xC0000292)
+#define NT_STATUS_FILE_ENCRYPTED                          NT_STATUS(0xC0000293)
+#define NT_STATUS_WMI_GUID_NOT_FOUND                      NT_STATUS(0xC0000295)
+#define NT_STATUS_WMI_INSTANCE_NOT_FOUND                  NT_STATUS(0xC0000296)
+#define NT_STATUS_WMI_ITEMID_NOT_FOUND                    NT_STATUS(0xC0000297)
+#define NT_STATUS_WMI_TRY_AGAIN                           NT_STATUS(0xC0000298)
+#define NT_STATUS_SHARED_POLICY                           NT_STATUS(0xC0000299)
+#define NT_STATUS_POLICY_OBJECT_NOT_FOUND                 NT_STATUS(0xC000029A)
+#define NT_STATUS_POLICY_ONLY_IN_DS                       NT_STATUS(0xC000029B)
+#define NT_STATUS_VOLUME_NOT_UPGRADED                     NT_STATUS(0xC000029C)
+#define NT_STATUS_REMOTE_STORAGE_NOT_ACTIVE               NT_STATUS(0xC000029D)
+#define NT_STATUS_REMOTE_STORAGE_MEDIA_ERROR              NT_STATUS(0xC000029E)
+#define NT_STATUS_NO_TRACKING_SERVICE                     NT_STATUS(0xC000029F)
+#define NT_STATUS_SERVER_SID_MISMATCH                     NT_STATUS(0xC00002A0)
+#define NT_STATUS_DS_NO_ATTRIBUTE_OR_VALUE                NT_STATUS(0xC00002A1)
+#define NT_STATUS_DS_INVALID_ATTRIBUTE_SYNTAX             NT_STATUS(0xC00002A2)
+#define NT_STATUS_DS_ATTRIBUTE_TYPE_UNDEFINED             NT_STATUS(0xC00002A3)
+#define NT_STATUS_DS_ATTRIBUTE_OR_VALUE_EXISTS            NT_STATUS(0xC00002A4)
+#define NT_STATUS_DS_BUSY                                 NT_STATUS(0xC00002A5)
+#define NT_STATUS_DS_UNAVAILABLE                          NT_STATUS(0xC00002A6)
+#define NT_STATUS_DS_NO_RIDS_ALLOCATED                    NT_STATUS(0xC00002A7)
+#define NT_STATUS_DS_INCORRECT_ROLE_OWNER                 NT_STATUS(0xC00002A9)
+#define NT_STATUS_DS_RIDMGR_INIT_ERROR                    NT_STATUS(0xC00002AA)
+#define NT_STATUS_DS_OBJ_CLASS_VIOLATION                  NT_STATUS(0xC00002AB)
+#define NT_STATUS_DS_CANT_ON_NON_LEAF                     NT_STATUS(0xC00002AC)
+#define NT_STATUS_DS_CANT_ON_RDN                          NT_STATUS(0xC00002AD)
+#define NT_STATUS_DS_CANT_MOD_OBJ_CLASS                   NT_STATUS(0xC00002AE)
+#define NT_STATUS_DS_CROSS_DOM_MOVE_FAILED                NT_STATUS(0xC00002AF)
+#define NT_STATUS_DS_GC_NOT_AVAILABLE                     NT_STATUS(0xC00002B0)
+#define NT_STATUS_DIRECTORY_SERVICE_REQUIRED              NT_STATUS(0xC00002B1)
+#define NT_STATUS_REPARSE_ATTRIBUTE_CONFLICT              NT_STATUS(0xC00002B2)
+#define NT_STATUS_CANT_ENABLE_DENY_ONLY                   NT_STATUS(0xC00002B3)
+#define NT_STATUS_FLOAT_MULTIPLE_FAULTS                   NT_STATUS(0xC00002B4)
+#define NT_STATUS_FLOAT_MULTIPLE_TRAPS                    NT_STATUS(0xC00002B5)
+#define NT_STATUS_DEVICE_REMOVED                          NT_STATUS(0xC00002B6)
+#define NT_STATUS_JOURNAL_DELETE_IN_PROGRESS              NT_STATUS(0xC00002B7)
+#define NT_STATUS_JOURNAL_NOT_ACTIVE                      NT_STATUS(0xC00002B8)
+#define NT_STATUS_NOINTERFACE                             NT_STATUS(0xC00002B9)
+#define NT_STATUS_DS_ADMIN_LIMIT_EXCEEDED                 NT_STATUS(0xC00002C1)
+#define NT_STATUS_DRIVER_FAILED_SLEEP                     NT_STATUS(0xC00002C2)
+#define NT_STATUS_MUTUAL_AUTHENTICATION_FAILED            NT_STATUS(0xC00002C3)
+#define NT_STATUS_CORRUPT_SYSTEM_FILE                     NT_STATUS(0xC00002C4)
+#define NT_STATUS_DATATYPE_MISALIGNMENT_ERROR             NT_STATUS(0xC00002C5)
+#define NT_STATUS_WMI_READ_ONLY                           NT_STATUS(0xC00002C6)
+#define NT_STATUS_WMI_SET_FAILURE                         NT_STATUS(0xC00002C7)
+#define NT_STATUS_COMMITMENT_MINIMUM                      NT_STATUS(0xC00002C8)
+#define NT_STATUS_REG_NAT_CONSUMPTION                     NT_STATUS(0xC00002C9)
+#define NT_STATUS_TRANSPORT_FULL                          NT_STATUS(0xC00002CA)
+#define NT_STATUS_DS_SAM_INIT_FAILURE                     NT_STATUS(0xC00002CB)
+#define NT_STATUS_ONLY_IF_CONNECTED                       NT_STATUS(0xC00002CC)
+#define NT_STATUS_DS_SENSITIVE_GROUP_VIOLATION            NT_STATUS(0xC00002CD)
+#define NT_STATUS_PNP_RESTART_ENUMERATION                 NT_STATUS(0xC00002CE)
+#define NT_STATUS_JOURNAL_ENTRY_DELETED                   NT_STATUS(0xC00002CF)
+#define NT_STATUS_DS_CANT_MOD_PRIMARYGROUPID              NT_STATUS(0xC00002D0)
+#define NT_STATUS_SYSTEM_IMAGE_BAD_SIGNATURE              NT_STATUS(0xC00002D1)
+#define NT_STATUS_PNP_REBOOT_REQUIRED                     NT_STATUS(0xC00002D2)
+#define NT_STATUS_POWER_STATE_INVALID                     NT_STATUS(0xC00002D3)
+#define NT_STATUS_DS_INVALID_GROUP_TYPE                   NT_STATUS(0xC00002D4)
+#define NT_STATUS_DS_NO_NEST_GLOBALGROUP_IN_MIXEDDOMAIN   NT_STATUS(0xC00002D5)
+#define NT_STATUS_DS_NO_NEST_LOCALGROUP_IN_MIXEDDOMAIN    NT_STATUS(0xC00002D6)
+#define NT_STATUS_DS_GLOBAL_CANT_HAVE_LOCAL_MEMBER        NT_STATUS(0xC00002D7)
+#define NT_STATUS_DS_GLOBAL_CANT_HAVE_UNIVERSAL_MEMBER    NT_STATUS(0xC00002D8)
+#define NT_STATUS_DS_UNIVERSAL_CANT_HAVE_LOCAL_MEMBER     NT_STATUS(0xC00002D9)
+#define NT_STATUS_DS_GLOBAL_CANT_HAVE_CROSSDOMAIN_MEMBER  NT_STATUS(0xC00002DA)
+#define NT_STATUS_DS_LOCAL_CANT_HAVE_CROSSDOMAIN_LOCAL_MEMBER NT_STATUS(0xC00002DB)
+#define NT_STATUS_DS_HAVE_PRIMARY_MEMBERS                 NT_STATUS(0xC00002DC)
+#define NT_STATUS_WMI_NOT_SUPPORTED                       NT_STATUS(0xC00002DD)
+#define NT_STATUS_INSUFFICIENT_POWER                      NT_STATUS(0xC00002DE)
+#define NT_STATUS_SAM_NEED_BOOTKEY_PASSWORD               NT_STATUS(0xC00002DF)
+#define NT_STATUS_SAM_NEED_BOOTKEY_FLOPPY                 NT_STATUS(0xC00002E0)
+#define NT_STATUS_DS_CANT_START                           NT_STATUS(0xC00002E1)
+#define NT_STATUS_DS_INIT_FAILURE                         NT_STATUS(0xC00002E2)
+#define NT_STATUS_SAM_INIT_FAILURE                        NT_STATUS(0xC00002E3)
+#define NT_STATUS_DS_GC_REQUIRED                          NT_STATUS(0xC00002E4)
+#define NT_STATUS_DS_LOCAL_MEMBER_OF_LOCAL_ONLY           NT_STATUS(0xC00002E5)
+#define NT_STATUS_DS_NO_FPO_IN_UNIVERSAL_GROUPS           NT_STATUS(0xC00002E6)
+#define NT_STATUS_DS_MACHINE_ACCOUNT_QUOTA_EXCEEDED       NT_STATUS(0xC00002E7)
+#define NT_STATUS_CANNOT_MAKE                             NT_STATUS(0xC00002EA)
+#define NT_STATUS_SYSTEM_SHUTDOWN                         NT_STATUS(0xC00002EB)
+#define NT_STATUS_DS_INIT_FAILURE_CONSOLE                 NT_STATUS(0xC00002EC)
+#define NT_STATUS_DS_SAM_INIT_FAILURE_CONSOLE             NT_STATUS(0xC00002ED)
+#define NT_STATUS_UNFINISHED_CONTEXT_DELETED              NT_STATUS(0xC00002EE)
+#define NT_STATUS_NO_TGT_REPLY                            NT_STATUS(0xC00002EF)
+#define NT_STATUS_NO_IP_ADDRESSES                         NT_STATUS(0xC00002F1)
+#define NT_STATUS_WRONG_CREDENTIAL_HANDLE                 NT_STATUS(0xC00002F2)
+#define NT_STATUS_CRYPTO_SYSTEM_INVALID                   NT_STATUS(0xC00002F3)
+#define NT_STATUS_MAX_REFERRALS_EXCEEDED                  NT_STATUS(0xC00002F4)
+#define NT_STATUS_MUST_BE_KDC                             NT_STATUS(0xC00002F5)
+#define NT_STATUS_STRONG_CRYPTO_NOT_SUPPORTED             NT_STATUS(0xC00002F6)
+#define NT_STATUS_TOO_MANY_PRINCIPALS                     NT_STATUS(0xC00002F7)
+#define NT_STATUS_NO_PA_DATA                              NT_STATUS(0xC00002F8)
+#define NT_STATUS_PKINIT_NAME_MISMATCH                    NT_STATUS(0xC00002F9)
+#define NT_STATUS_SMARTCARD_LOGON_REQUIRED                NT_STATUS(0xC00002FA)
+#define NT_STATUS_KDC_INVALID_REQUEST                     NT_STATUS(0xC00002FB)
+#define NT_STATUS_KDC_UNABLE_TO_REFER                     NT_STATUS(0xC00002FC)
+#define NT_STATUS_KDC_UNKNOWN_ETYPE                       NT_STATUS(0xC00002FD)
+#define NT_STATUS_SHUTDOWN_IN_PROGRESS                    NT_STATUS(0xC00002FE)
+#define NT_STATUS_SERVER_SHUTDOWN_IN_PROGRESS             NT_STATUS(0xC00002FF)
+#define NT_STATUS_NOT_SUPPORTED_ON_SBS                    NT_STATUS(0xC0000300)
+#define NT_STATUS_WMI_GUID_DISCONNECTED                   NT_STATUS(0xC0000301)
+#define NT_STATUS_WMI_ALREADY_DISABLED                    NT_STATUS(0xC0000302)
+#define NT_STATUS_WMI_ALREADY_ENABLED                     NT_STATUS(0xC0000303)
+#define NT_STATUS_MFT_TOO_FRAGMENTED                      NT_STATUS(0xC0000304)
+#define NT_STATUS_COPY_PROTECTION_FAILURE                 NT_STATUS(0xC0000305)
+#define NT_STATUS_CSS_AUTHENTICATION_FAILURE              NT_STATUS(0xC0000306)
+#define NT_STATUS_CSS_KEY_NOT_PRESENT                     NT_STATUS(0xC0000307)
+#define NT_STATUS_CSS_KEY_NOT_ESTABLISHED                 NT_STATUS(0xC0000308)
+#define NT_STATUS_CSS_SCRAMBLED_SECTOR                    NT_STATUS(0xC0000309)
+#define NT_STATUS_CSS_REGION_MISMATCH                     NT_STATUS(0xC000030A)
+#define NT_STATUS_CSS_RESETS_EXHAUSTED                    NT_STATUS(0xC000030B)
+#define NT_STATUS_PKINIT_FAILURE                          NT_STATUS(0xC0000320)
+#define NT_STATUS_SMARTCARD_SUBSYSTEM_FAILURE             NT_STATUS(0xC0000321)
+#define NT_STATUS_NO_KERB_KEY                             NT_STATUS(0xC0000322)
+#define NT_STATUS_HOST_DOWN                               NT_STATUS(0xC0000350)
+#define NT_STATUS_UNSUPPORTED_PREAUTH                     NT_STATUS(0xC0000351)
+#define NT_STATUS_EFS_ALG_BLOB_TOO_BIG                    NT_STATUS(0xC0000352)
+#define NT_STATUS_PORT_NOT_SET                            NT_STATUS(0xC0000353)
+#define NT_STATUS_DEBUGGER_INACTIVE                       NT_STATUS(0xC0000354)
+#define NT_STATUS_DS_VERSION_CHECK_FAILURE                NT_STATUS(0xC0000355)
+#define NT_STATUS_AUDITING_DISABLED                       NT_STATUS(0xC0000356)
+#define NT_STATUS_PRENT4_MACHINE_ACCOUNT                  NT_STATUS(0xC0000357)
+#define NT_STATUS_DS_AG_CANT_HAVE_UNIVERSAL_MEMBER        NT_STATUS(0xC0000358)
+#define NT_STATUS_INVALID_IMAGE_WIN_32                    NT_STATUS(0xC0000359)
+#define NT_STATUS_INVALID_IMAGE_WIN_64                    NT_STATUS(0xC000035A)
+#define NT_STATUS_BAD_BINDINGS                            NT_STATUS(0xC000035B)
+#define NT_STATUS_APPHELP_BLOCK                           NT_STATUS(0xC000035D)
+#define NT_STATUS_NOT_SAFE_MODE_DRIVER                    NT_STATUS(0xC000035F)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_DEFAULT       NT_STATUS(0xC0000361)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_PATH          NT_STATUS(0xC0000362)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_PUBLISHER     NT_STATUS(0xC0000363)
+#define NT_STATUS_ACCESS_DISABLED_BY_POLICY_OTHER         NT_STATUS(0xC0000364)
+#define NT_STATUS_FAILED_DRIVER_ENTRY                     NT_STATUS(0xC0000365)
+#define NT_STATUS_DEVICE_ENUMERATION_ERROR                NT_STATUS(0xC0000366)
+#define NT_STATUS_MOUNT_POINT_NOT_RESOLVED                NT_STATUS(0xC0000368)
+#define NT_STATUS_INVALID_DEVICE_OBJECT_PARAMETER         NT_STATUS(0xC0000369)
+#define NT_STATUS_MCA_OCCURED                             NT_STATUS(0xC000036A)
+#define NT_STATUS_DRIVER_BLOCKED_CRITICAL                 NT_STATUS(0xC000036B)
+#define NT_STATUS_DRIVER_BLOCKED                          NT_STATUS(0xC000036C)
+#define NT_STATUS_DRIVER_DATABASE_ERROR                   NT_STATUS(0xC000036D)
+#define NT_STATUS_SYSTEM_HIVE_TOO_LARGE                   NT_STATUS(0xC000036E)
+#define NT_STATUS_INVALID_IMPORT_OF_NON_DLL               NT_STATUS(0xC000036F)
+#define NT_STATUS_NO_SECRETS                              NT_STATUS(0xC0000371)
+#define NT_STATUS_ACCESS_DISABLED_NO_SAFER_UI_BY_POLICY   NT_STATUS(0xC0000372)
+#define NT_STATUS_FAILED_STACK_SWITCH                     NT_STATUS(0xC0000373)
+#define NT_STATUS_HEAP_CORRUPTION                         NT_STATUS(0xC0000374)
+#define NT_STATUS_SMARTCARD_WRONG_PIN                     NT_STATUS(0xC0000380)
+#define NT_STATUS_SMARTCARD_CARD_BLOCKED                  NT_STATUS(0xC0000381)
+#define NT_STATUS_SMARTCARD_CARD_NOT_AUTHENTICATED        NT_STATUS(0xC0000382)
+#define NT_STATUS_SMARTCARD_NO_CARD                       NT_STATUS(0xC0000383)
+#define NT_STATUS_SMARTCARD_NO_KEY_CONTAINER              NT_STATUS(0xC0000384)
+#define NT_STATUS_SMARTCARD_NO_CERTIFICATE                NT_STATUS(0xC0000385)
+#define NT_STATUS_SMARTCARD_NO_KEYSET                     NT_STATUS(0xC0000386)
+#define NT_STATUS_SMARTCARD_IO_ERROR                      NT_STATUS(0xC0000387)
+#define NT_STATUS_SMARTCARD_CERT_REVOKED                  NT_STATUS(0xC0000389)
+#define NT_STATUS_ISSUING_CA_UNTRUSTED                    NT_STATUS(0xC000038A)
+#define NT_STATUS_REVOCATION_OFFLINE_C                    NT_STATUS(0xC000038B)
+#define NT_STATUS_PKINIT_CLIENT_FAILURE                   NT_STATUS(0xC000038C)
+#define NT_STATUS_SMARTCARD_CERT_EXPIRED                  NT_STATUS(0xC000038D)
+#define NT_STATUS_DRIVER_FAILED_PRIOR_UNLOAD              NT_STATUS(0xC000038E)
+#define NT_STATUS_SMARTCARD_SILENT_CONTEXT                NT_STATUS(0xC000038F)
+#define NT_STATUS_PER_USER_TRUST_QUOTA_EXCEEDED           NT_STATUS(0xC0000401)
+#define NT_STATUS_ALL_USER_TRUST_QUOTA_EXCEEDED           NT_STATUS(0xC0000402)
+#define NT_STATUS_USER_DELETE_TRUST_QUOTA_EXCEEDED        NT_STATUS(0xC0000403)
+#define NT_STATUS_DS_NAME_NOT_UNIQUE                      NT_STATUS(0xC0000404)
+#define NT_STATUS_DS_DUPLICATE_ID_FOUND                   NT_STATUS(0xC0000405)
+#define NT_STATUS_DS_GROUP_CONVERSION_ERROR               NT_STATUS(0xC0000406)
+#define NT_STATUS_VOLSNAP_PREPARE_HIBERNATE               NT_STATUS(0xC0000407)
+#define NT_STATUS_USER2USER_REQUIRED                      NT_STATUS(0xC0000408)
+#define NT_STATUS_STACK_BUFFER_OVERRUN                    NT_STATUS(0xC0000409)
+#define NT_STATUS_REVOCATION_OFFLINE_KDC                  NT_STATUS(0xC000040C)
+#define NT_STATUS_ISSUING_CA_UNTRUSTED_KDC                NT_STATUS(0xC000040D)
+#define NT_STATUS_KDC_CERT_EXPIRED                        NT_STATUS(0xC000040E)
+#define NT_STATUS_KDC_CERT_REVOKED                        NT_STATUS(0xC000040F)
+#define NT_STATUS_PARAMETER_QUOTA_EXCEEDED                NT_STATUS(0xC0000410)
+#define NT_STATUS_HIBERNATION_FAILURE                     NT_STATUS(0xC0000411)
+#define NT_STATUS_DELAY_LOAD_FAILED                       NT_STATUS(0xC0000412)
+#define NT_STATUS_AUTHENTICATION_FIREWALL_FAILED          NT_STATUS(0xC0000413)
+#define NT_STATUS_VDM_DISALLOWED                          NT_STATUS(0xC0000414)
+#define NT_STATUS_HUNG_DISPLAY_DRIVER_THREAD              NT_STATUS(0xC0000415)
+#define NT_STATUS_INSUFFICIENT_RESOURCE_FOR_SPECIFIED_SHARED_SECTION_SIZE NT_STATUS(0xC0000416)
+#define NT_STATUS_INVALID_CRUNTIME_PARAMETER              NT_STATUS(0xC0000417)
+#define NT_STATUS_NTLM_BLOCKED                            NT_STATUS(0xC0000418)
+#define NT_STATUS_DS_SRC_SID_EXISTS_IN_FOREST             NT_STATUS(0xC0000419)
+#define NT_STATUS_DS_DOMAIN_NAME_EXISTS_IN_FOREST         NT_STATUS(0xC000041A)
+#define NT_STATUS_DS_FLAT_NAME_EXISTS_IN_FOREST           NT_STATUS(0xC000041B)
+#define NT_STATUS_INVALID_USER_PRINCIPAL_NAME             NT_STATUS(0xC000041C)
+#define NT_STATUS_ASSERTION_FAILURE                       NT_STATUS(0xC0000420)
+#define NT_STATUS_VERIFIER_STOP                           NT_STATUS(0xC0000421)
+#define NT_STATUS_CALLBACK_POP_STACK                      NT_STATUS(0xC0000423)
+#define NT_STATUS_INCOMPATIBLE_DRIVER_BLOCKED             NT_STATUS(0xC0000424)
+#define NT_STATUS_HIVE_UNLOADED                           NT_STATUS(0xC0000425)
+#define NT_STATUS_COMPRESSION_DISABLED                    NT_STATUS(0xC0000426)
+#define NT_STATUS_FILE_SYSTEM_LIMITATION                  NT_STATUS(0xC0000427)
+#define NT_STATUS_INVALID_IMAGE_HASH                      NT_STATUS(0xC0000428)
+#define NT_STATUS_NOT_CAPABLE                             NT_STATUS(0xC0000429)
+#define NT_STATUS_REQUEST_OUT_OF_SEQUENCE                 NT_STATUS(0xC000042A)
+#define NT_STATUS_IMPLEMENTATION_LIMIT                    NT_STATUS(0xC000042B)
+#define NT_STATUS_ELEVATION_REQUIRED                      NT_STATUS(0xC000042C)
+#define NT_STATUS_NO_SECURITY_CONTEXT                     NT_STATUS(0xC000042D)
+#define NT_STATUS_PKU2U_CERT_FAILURE                      NT_STATUS(0xC000042E)
+#define NT_STATUS_BEYOND_VDL                              NT_STATUS(0xC0000432)
+#define NT_STATUS_ENCOUNTERED_WRITE_IN_PROGRESS           NT_STATUS(0xC0000433)
+#define NT_STATUS_PTE_CHANGED                             NT_STATUS(0xC0000434)
+#define NT_STATUS_PURGE_FAILED                            NT_STATUS(0xC0000435)
+#define NT_STATUS_CRED_REQUIRES_CONFIRMATION              NT_STATUS(0xC0000440)
+#define NT_STATUS_CS_ENCRYPTION_INVALID_SERVER_RESPONSE   NT_STATUS(0xC0000441)
+#define NT_STATUS_CS_ENCRYPTION_UNSUPPORTED_SERVER        NT_STATUS(0xC0000442)
+#define NT_STATUS_CS_ENCRYPTION_EXISTING_ENCRYPTED_FILE   NT_STATUS(0xC0000443)
+#define NT_STATUS_CS_ENCRYPTION_NEW_ENCRYPTED_FILE        NT_STATUS(0xC0000444)
+#define NT_STATUS_CS_ENCRYPTION_FILE_NOT_CSE              NT_STATUS(0xC0000445)
+#define NT_STATUS_INVALID_LABEL                           NT_STATUS(0xC0000446)
+#define NT_STATUS_DRIVER_PROCESS_TERMINATED               NT_STATUS(0xC0000450)
+#define NT_STATUS_AMBIGUOUS_SYSTEM_DEVICE                 NT_STATUS(0xC0000451)
+#define NT_STATUS_SYSTEM_DEVICE_NOT_FOUND                 NT_STATUS(0xC0000452)
+#define NT_STATUS_RESTART_BOOT_APPLICATION                NT_STATUS(0xC0000453)
+#define NT_STATUS_INSUFFICIENT_NVRAM_RESOURCES            NT_STATUS(0xC0000454)
+#define NT_STATUS_NO_RANGES_PROCESSED                     NT_STATUS(0xC0000460)
+#define NT_STATUS_DEVICE_FEATURE_NOT_SUPPORTED            NT_STATUS(0xC0000463)
+#define NT_STATUS_DEVICE_UNREACHABLE                      NT_STATUS(0xC0000464)
+#define NT_STATUS_INVALID_TOKEN                           NT_STATUS(0xC0000465)
+#define NT_STATUS_INVALID_TASK_NAME                       NT_STATUS(0xC0000500)
+#define NT_STATUS_INVALID_TASK_INDEX                      NT_STATUS(0xC0000501)
+#define NT_STATUS_THREAD_ALREADY_IN_TASK                  NT_STATUS(0xC0000502)
+#define NT_STATUS_CALLBACK_BYPASS                         NT_STATUS(0xC0000503)
+#define NT_STATUS_FAIL_FAST_EXCEPTION                     NT_STATUS(0xC0000602)
+#define NT_STATUS_IMAGE_CERT_REVOKED                      NT_STATUS(0xC0000603)
+#define NT_STATUS_PORT_CLOSED                             NT_STATUS(0xC0000700)
+#define NT_STATUS_MESSAGE_LOST                            NT_STATUS(0xC0000701)
+#define NT_STATUS_INVALID_MESSAGE                         NT_STATUS(0xC0000702)
+#define NT_STATUS_REQUEST_CANCELED                        NT_STATUS(0xC0000703)
+#define NT_STATUS_RECURSIVE_DISPATCH                      NT_STATUS(0xC0000704)
+#define NT_STATUS_LPC_RECEIVE_BUFFER_EXPECTED             NT_STATUS(0xC0000705)
+#define NT_STATUS_LPC_INVALID_CONNECTION_USAGE            NT_STATUS(0xC0000706)
+#define NT_STATUS_LPC_REQUESTS_NOT_ALLOWED                NT_STATUS(0xC0000707)
+#define NT_STATUS_RESOURCE_IN_USE                         NT_STATUS(0xC0000708)
+#define NT_STATUS_HARDWARE_MEMORY_ERROR                   NT_STATUS(0xC0000709)
+#define NT_STATUS_THREADPOOL_HANDLE_EXCEPTION             NT_STATUS(0xC000070A)
+#define NT_STATUS_THREADPOOL_SET_EVENT_ON_COMPLETION_FAILED NT_STATUS(0xC000070B)
+#define NT_STATUS_THREADPOOL_RELEASE_SEMAPHORE_ON_COMPLETION_FAILED NT_STATUS(0xC000070C)
+#define NT_STATUS_THREADPOOL_RELEASE_MUTEX_ON_COMPLETION_FAILED NT_STATUS(0xC000070D)
+#define NT_STATUS_THREADPOOL_FREE_LIBRARY_ON_COMPLETION_FAILED NT_STATUS(0xC000070E)
+#define NT_STATUS_THREADPOOL_RELEASED_DURING_OPERATION    NT_STATUS(0xC000070F)
+#define NT_STATUS_CALLBACK_RETURNED_WHILE_IMPERSONATING   NT_STATUS(0xC0000710)
+#define NT_STATUS_APC_RETURNED_WHILE_IMPERSONATING        NT_STATUS(0xC0000711)
+#define NT_STATUS_PROCESS_IS_PROTECTED                    NT_STATUS(0xC0000712)
+#define NT_STATUS_MCA_EXCEPTION                           NT_STATUS(0xC0000713)
+#define NT_STATUS_CERTIFICATE_MAPPING_NOT_UNIQUE          NT_STATUS(0xC0000714)
+#define NT_STATUS_SYMLINK_CLASS_DISABLED                  NT_STATUS(0xC0000715)
+#define NT_STATUS_INVALID_IDN_NORMALIZATION               NT_STATUS(0xC0000716)
+#define NT_STATUS_NO_UNICODE_TRANSLATION                  NT_STATUS(0xC0000717)
+#define NT_STATUS_ALREADY_REGISTERED                      NT_STATUS(0xC0000718)
+#define NT_STATUS_CONTEXT_MISMATCH                        NT_STATUS(0xC0000719)
+#define NT_STATUS_PORT_ALREADY_HAS_COMPLETION_LIST        NT_STATUS(0xC000071A)
+#define NT_STATUS_CALLBACK_RETURNED_THREAD_PRIORITY       NT_STATUS(0xC000071B)
+#define NT_STATUS_INVALID_THREAD                          NT_STATUS(0xC000071C)
+#define NT_STATUS_CALLBACK_RETURNED_TRANSACTION           NT_STATUS(0xC000071D)
+#define NT_STATUS_CALLBACK_RETURNED_LDR_LOCK              NT_STATUS(0xC000071E)
+#define NT_STATUS_CALLBACK_RETURNED_LANG                  NT_STATUS(0xC000071F)
+#define NT_STATUS_CALLBACK_RETURNED_PRI_BACK              NT_STATUS(0xC0000720)
+#define NT_STATUS_DISK_REPAIR_DISABLED                    NT_STATUS(0xC0000800)
+#define NT_STATUS_DS_DOMAIN_RENAME_IN_PROGRESS            NT_STATUS(0xC0000801)
+#define NT_STATUS_DISK_QUOTA_EXCEEDED                     NT_STATUS(0xC0000802)
+#define NT_STATUS_CONTENT_BLOCKED                         NT_STATUS(0xC0000804)
+#define NT_STATUS_BAD_CLUSTERS                            NT_STATUS(0xC0000805)
+#define NT_STATUS_VOLUME_DIRTY                            NT_STATUS(0xC0000806)
+#define NT_STATUS_FILE_CHECKED_OUT                        NT_STATUS(0xC0000901)
+#define NT_STATUS_CHECKOUT_REQUIRED                       NT_STATUS(0xC0000902)
+#define NT_STATUS_BAD_FILE_TYPE                           NT_STATUS(0xC0000903)
+#define NT_STATUS_FILE_TOO_LARGE                          NT_STATUS(0xC0000904)
+#define NT_STATUS_FORMS_AUTH_REQUIRED                     NT_STATUS(0xC0000905)
+#define NT_STATUS_VIRUS_INFECTED                          NT_STATUS(0xC0000906)
+#define NT_STATUS_VIRUS_DELETED                           NT_STATUS(0xC0000907)
+#define NT_STATUS_BAD_MCFG_TABLE                          NT_STATUS(0xC0000908)
+#define NT_STATUS_CANNOT_BREAK_OPLOCK                     NT_STATUS(0xC0000909)
+#define NT_STATUS_WOW_ASSERTION                           NT_STATUS(0xC0009898)
+#define NT_STATUS_INVALID_SIGNATURE                       NT_STATUS(0xC000A000)
+#define NT_STATUS_HMAC_NOT_SUPPORTED                      NT_STATUS(0xC000A001)
+#define NT_STATUS_IPSEC_QUEUE_OVERFLOW                    NT_STATUS(0xC000A010)
+#define NT_STATUS_ND_QUEUE_OVERFLOW                       NT_STATUS(0xC000A011)
+#define NT_STATUS_HOPLIMIT_EXCEEDED                       NT_STATUS(0xC000A012)
+#define NT_STATUS_PROTOCOL_NOT_SUPPORTED                  NT_STATUS(0xC000A013)
+#define NT_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_DISCONNECTED NT_STATUS(0xC000A080)
+#define NT_STATUS_LOST_WRITEBEHIND_DATA_NETWORK_SERVER_ERROR NT_STATUS(0xC000A081)
+#define NT_STATUS_LOST_WRITEBEHIND_DATA_LOCAL_DISK_ERROR  NT_STATUS(0xC000A082)
+#define NT_STATUS_XML_PARSE_ERROR                         NT_STATUS(0xC000A083)
+#define NT_STATUS_XMLDSIG_ERROR                           NT_STATUS(0xC000A084)
+#define NT_STATUS_WRONG_COMPARTMENT                       NT_STATUS(0xC000A085)
+#define NT_STATUS_AUTHIP_FAILURE                          NT_STATUS(0xC000A086)
+#define NT_STATUS_DS_OID_MAPPED_GROUP_CANT_HAVE_MEMBERS   NT_STATUS(0xC000A087)
+#define NT_STATUS_DS_OID_NOT_FOUND                        NT_STATUS(0xC000A088)
+#define NT_STATUS_HASH_NOT_SUPPORTED                      NT_STATUS(0xC000A100)
+#define NT_STATUS_HASH_NOT_PRESENT                        NT_STATUS(0xC000A101)
+#define NT_STATUS_OFFLOAD_READ_FLT_NOT_SUPPORTED          NT_STATUS(0xC000A2A1)
+#define NT_STATUS_OFFLOAD_WRITE_FLT_NOT_SUPPORTED         NT_STATUS(0xC000A2A2)
+#define NT_STATUS_OFFLOAD_READ_FILE_NOT_SUPPORTED         NT_STATUS(0xC000A2A3)
+#define NT_STATUS_OFFLOAD_WRITE_FILE_NOT_SUPPORTED        NT_STATUS(0xC000A2A4)
+#define NT_STATUS_DBG_NO_STATE_CHANGE                     NT_STATUS(0xC0010001)
+#define NT_STATUS_DBG_APP_NOT_IDLE                        NT_STATUS(0xC0010002)
+#define NT_STATUS_RPC_INVALID_STRING_BINDING              NT_STATUS(0xC0020001)
+#define NT_STATUS_RPC_WRONG_KIND_OF_BINDING               NT_STATUS(0xC0020002)
+#define NT_STATUS_RPC_INVALID_BINDING                     NT_STATUS(0xC0020003)
+#define NT_STATUS_RPC_INVALID_RPC_PROTSEQ                 NT_STATUS(0xC0020005)
+#define NT_STATUS_RPC_INVALID_STRING_UUID                 NT_STATUS(0xC0020006)
+#define NT_STATUS_RPC_INVALID_ENDPOINT_FORMAT             NT_STATUS(0xC0020007)
+#define NT_STATUS_RPC_INVALID_NET_ADDR                    NT_STATUS(0xC0020008)
+#define NT_STATUS_RPC_NO_ENDPOINT_FOUND                   NT_STATUS(0xC0020009)
+#define NT_STATUS_RPC_INVALID_TIMEOUT                     NT_STATUS(0xC002000A)
+#define NT_STATUS_RPC_OBJECT_NOT_FOUND                    NT_STATUS(0xC002000B)
+#define NT_STATUS_RPC_ALREADY_REGISTERED                  NT_STATUS(0xC002000C)
+#define NT_STATUS_RPC_TYPE_ALREADY_REGISTERED             NT_STATUS(0xC002000D)
+#define NT_STATUS_RPC_ALREADY_LISTENING                   NT_STATUS(0xC002000E)
+#define NT_STATUS_RPC_NO_PROTSEQS_REGISTERED              NT_STATUS(0xC002000F)
+#define NT_STATUS_RPC_NOT_LISTENING                       NT_STATUS(0xC0020010)
+#define NT_STATUS_RPC_UNKNOWN_MGR_TYPE                    NT_STATUS(0xC0020011)
+#define NT_STATUS_RPC_NO_BINDINGS                         NT_STATUS(0xC0020013)
+#define NT_STATUS_RPC_NO_PROTSEQS                         NT_STATUS(0xC0020014)
+#define NT_STATUS_RPC_CANT_CREATE_ENDPOINT                NT_STATUS(0xC0020015)
+#define NT_STATUS_RPC_OUT_OF_RESOURCES                    NT_STATUS(0xC0020016)
+#define NT_STATUS_RPC_SERVER_UNAVAILABLE                  NT_STATUS(0xC0020017)
+#define NT_STATUS_RPC_SERVER_TOO_BUSY                     NT_STATUS(0xC0020018)
+#define NT_STATUS_RPC_INVALID_NETWORK_OPTIONS             NT_STATUS(0xC0020019)
+#define NT_STATUS_RPC_NO_CALL_ACTIVE                      NT_STATUS(0xC002001A)
+#define NT_STATUS_RPC_CALL_FAILED_DNE                     NT_STATUS(0xC002001C)
+#define NT_STATUS_RPC_UNSUPPORTED_TRANS_SYN               NT_STATUS(0xC002001F)
+#define NT_STATUS_RPC_UNSUPPORTED_TYPE                    NT_STATUS(0xC0020021)
+#define NT_STATUS_RPC_INVALID_TAG                         NT_STATUS(0xC0020022)
+#define NT_STATUS_RPC_INVALID_BOUND                       NT_STATUS(0xC0020023)
+#define NT_STATUS_RPC_NO_ENTRY_NAME                       NT_STATUS(0xC0020024)
+#define NT_STATUS_RPC_INVALID_NAME_SYNTAX                 NT_STATUS(0xC0020025)
+#define NT_STATUS_RPC_UUID_NO_ADDRESS                     NT_STATUS(0xC0020028)
+#define NT_STATUS_RPC_DUPLICATE_ENDPOINT                  NT_STATUS(0xC0020029)
+#define NT_STATUS_RPC_UNKNOWN_AUTHN_TYPE                  NT_STATUS(0xC002002A)
+#define NT_STATUS_RPC_MAX_CALLS_TOO_SMALL                 NT_STATUS(0xC002002B)
+#define NT_STATUS_RPC_STRING_TOO_LONG                     NT_STATUS(0xC002002C)
+#define NT_STATUS_RPC_PROTSEQ_NOT_FOUND                   NT_STATUS(0xC002002D)
+#define NT_STATUS_RPC_BINDING_HAS_NO_AUTH                 NT_STATUS(0xC002002F)
+#define NT_STATUS_RPC_UNKNOWN_AUTHN_SERVICE               NT_STATUS(0xC0020030)
+#define NT_STATUS_RPC_UNKNOWN_AUTHN_LEVEL                 NT_STATUS(0xC0020031)
+#define NT_STATUS_RPC_INVALID_AUTH_IDENTITY               NT_STATUS(0xC0020032)
+#define NT_STATUS_RPC_UNKNOWN_AUTHZ_SERVICE               NT_STATUS(0xC0020033)
+#define NT_STATUS_EPT_INVALID_ENTRY                       NT_STATUS(0xC0020034)
+#define NT_STATUS_EPT_CANT_PERFORM_OP                     NT_STATUS(0xC0020035)
+#define NT_STATUS_EPT_NOT_REGISTERED                      NT_STATUS(0xC0020036)
+#define NT_STATUS_RPC_NOTHING_TO_EXPORT                   NT_STATUS(0xC0020037)
+#define NT_STATUS_RPC_INCOMPLETE_NAME                     NT_STATUS(0xC0020038)
+#define NT_STATUS_RPC_INVALID_VERS_OPTION                 NT_STATUS(0xC0020039)
+#define NT_STATUS_RPC_NO_MORE_MEMBERS                     NT_STATUS(0xC002003A)
+#define NT_STATUS_RPC_NOT_ALL_OBJS_UNEXPORTED             NT_STATUS(0xC002003B)
+#define NT_STATUS_RPC_INTERFACE_NOT_FOUND                 NT_STATUS(0xC002003C)
+#define NT_STATUS_RPC_ENTRY_ALREADY_EXISTS                NT_STATUS(0xC002003D)
+#define NT_STATUS_RPC_ENTRY_NOT_FOUND                     NT_STATUS(0xC002003E)
+#define NT_STATUS_RPC_NAME_SERVICE_UNAVAILABLE            NT_STATUS(0xC002003F)
+#define NT_STATUS_RPC_INVALID_NAF_ID                      NT_STATUS(0xC0020040)
+#define NT_STATUS_RPC_NO_CONTEXT_AVAILABLE                NT_STATUS(0xC0020042)
+#define NT_STATUS_RPC_INTERNAL_ERROR                      NT_STATUS(0xC0020043)
+#define NT_STATUS_RPC_ZERO_DIVIDE                         NT_STATUS(0xC0020044)
+#define NT_STATUS_RPC_ADDRESS_ERROR                       NT_STATUS(0xC0020045)
+#define NT_STATUS_RPC_FP_DIV_ZERO                         NT_STATUS(0xC0020046)
+#define NT_STATUS_RPC_FP_UNDERFLOW                        NT_STATUS(0xC0020047)
+#define NT_STATUS_RPC_FP_OVERFLOW                         NT_STATUS(0xC0020048)
+#define NT_STATUS_RPC_CALL_IN_PROGRESS                    NT_STATUS(0xC0020049)
+#define NT_STATUS_RPC_NO_MORE_BINDINGS                    NT_STATUS(0xC002004A)
+#define NT_STATUS_RPC_GROUP_MEMBER_NOT_FOUND              NT_STATUS(0xC002004B)
+#define NT_STATUS_EPT_CANT_CREATE                         NT_STATUS(0xC002004C)
+#define NT_STATUS_RPC_INVALID_OBJECT                      NT_STATUS(0xC002004D)
+#define NT_STATUS_RPC_NO_INTERFACES                       NT_STATUS(0xC002004F)
+#define NT_STATUS_RPC_CALL_CANCELLED                      NT_STATUS(0xC0020050)
+#define NT_STATUS_RPC_BINDING_INCOMPLETE                  NT_STATUS(0xC0020051)
+#define NT_STATUS_RPC_COMM_FAILURE                        NT_STATUS(0xC0020052)
+#define NT_STATUS_RPC_UNSUPPORTED_AUTHN_LEVEL             NT_STATUS(0xC0020053)
+#define NT_STATUS_RPC_NO_PRINC_NAME                       NT_STATUS(0xC0020054)
+#define NT_STATUS_RPC_NOT_RPC_ERROR                       NT_STATUS(0xC0020055)
+#define NT_STATUS_RPC_NOT_CANCELLED                       NT_STATUS(0xC0020058)
+#define NT_STATUS_RPC_INVALID_ASYNC_HANDLE                NT_STATUS(0xC0020062)
+#define NT_STATUS_RPC_INVALID_ASYNC_CALL                  NT_STATUS(0xC0020063)
+#define NT_STATUS_RPC_PROXY_ACCESS_DENIED                 NT_STATUS(0xC0020064)
+#define NT_STATUS_RPC_NO_MORE_ENTRIES                     NT_STATUS(0xC0030001)
+#define NT_STATUS_RPC_SS_CHAR_TRANS_OPEN_FAIL             NT_STATUS(0xC0030002)
+#define NT_STATUS_RPC_SS_CHAR_TRANS_SHORT_FILE            NT_STATUS(0xC0030003)
+#define NT_STATUS_RPC_SS_IN_NULL_CONTEXT                  NT_STATUS(0xC0030004)
+#define NT_STATUS_RPC_SS_CONTEXT_DAMAGED                  NT_STATUS(0xC0030006)
+#define NT_STATUS_RPC_SS_HANDLES_MISMATCH                 NT_STATUS(0xC0030007)
+#define NT_STATUS_RPC_SS_CANNOT_GET_CALL_HANDLE           NT_STATUS(0xC0030008)
+#define NT_STATUS_RPC_NULL_REF_POINTER                    NT_STATUS(0xC0030009)
+#define NT_STATUS_RPC_BYTE_COUNT_TOO_SMALL                NT_STATUS(0xC003000B)
+#define NT_STATUS_RPC_INVALID_ES_ACTION                   NT_STATUS(0xC0030059)
+#define NT_STATUS_RPC_WRONG_ES_VERSION                    NT_STATUS(0xC003005A)
+#define NT_STATUS_RPC_WRONG_STUB_VERSION                  NT_STATUS(0xC003005B)
+#define NT_STATUS_PNP_BAD_MPS_TABLE                       NT_STATUS(0xC0040035)
+#define NT_STATUS_PNP_TRANSLATION_FAILED                  NT_STATUS(0xC0040036)
+#define NT_STATUS_PNP_IRQ_TRANSLATION_FAILED              NT_STATUS(0xC0040037)
+#define NT_STATUS_PNP_INVALID_ID                          NT_STATUS(0xC0040038)
+#define NT_STATUS_IO_REISSUE_AS_CACHED                    NT_STATUS(0xC0040039)
+#define NT_STATUS_CTX_WINSTATION_NAME_INVALID             NT_STATUS(0xC00A0001)
+#define NT_STATUS_CTX_INVALID_PD                          NT_STATUS(0xC00A0002)
+#define NT_STATUS_CTX_PD_NOT_FOUND                        NT_STATUS(0xC00A0003)
+#define NT_STATUS_CTX_CLOSE_PENDING                       NT_STATUS(0xC00A0006)
+#define NT_STATUS_CTX_NO_OUTBUF                           NT_STATUS(0xC00A0007)
+#define NT_STATUS_CTX_MODEM_INF_NOT_FOUND                 NT_STATUS(0xC00A0008)
+#define NT_STATUS_CTX_INVALID_MODEMNAME                   NT_STATUS(0xC00A0009)
+#define NT_STATUS_CTX_RESPONSE_ERROR                      NT_STATUS(0xC00A000A)
+#define NT_STATUS_CTX_MODEM_RESPONSE_TIMEOUT              NT_STATUS(0xC00A000B)
+#define NT_STATUS_CTX_MODEM_RESPONSE_NO_CARRIER           NT_STATUS(0xC00A000C)
+#define NT_STATUS_CTX_MODEM_RESPONSE_NO_DIALTONE          NT_STATUS(0xC00A000D)
+#define NT_STATUS_CTX_MODEM_RESPONSE_BUSY                 NT_STATUS(0xC00A000E)
+#define NT_STATUS_CTX_MODEM_RESPONSE_VOICE                NT_STATUS(0xC00A000F)
+#define NT_STATUS_CTX_TD_ERROR                            NT_STATUS(0xC00A0010)
+#define NT_STATUS_CTX_LICENSE_CLIENT_INVALID              NT_STATUS(0xC00A0012)
+#define NT_STATUS_CTX_LICENSE_NOT_AVAILABLE               NT_STATUS(0xC00A0013)
+#define NT_STATUS_CTX_LICENSE_EXPIRED                     NT_STATUS(0xC00A0014)
+#define NT_STATUS_CTX_WINSTATION_NOT_FOUND                NT_STATUS(0xC00A0015)
+#define NT_STATUS_CTX_WINSTATION_NAME_COLLISION           NT_STATUS(0xC00A0016)
+#define NT_STATUS_CTX_WINSTATION_BUSY                     NT_STATUS(0xC00A0017)
+#define NT_STATUS_CTX_BAD_VIDEO_MODE                      NT_STATUS(0xC00A0018)
+#define NT_STATUS_CTX_GRAPHICS_INVALID                    NT_STATUS(0xC00A0022)
+#define NT_STATUS_CTX_NOT_CONSOLE                         NT_STATUS(0xC00A0024)
+#define NT_STATUS_CTX_CLIENT_QUERY_TIMEOUT                NT_STATUS(0xC00A0026)
+#define NT_STATUS_CTX_CONSOLE_DISCONNECT                  NT_STATUS(0xC00A0027)
+#define NT_STATUS_CTX_CONSOLE_CONNECT                     NT_STATUS(0xC00A0028)
+#define NT_STATUS_CTX_SHADOW_DENIED                       NT_STATUS(0xC00A002A)
+#define NT_STATUS_CTX_WINSTATION_ACCESS_DENIED            NT_STATUS(0xC00A002B)
+#define NT_STATUS_CTX_INVALID_WD                          NT_STATUS(0xC00A002E)
+#define NT_STATUS_CTX_WD_NOT_FOUND                        NT_STATUS(0xC00A002F)
+#define NT_STATUS_CTX_SHADOW_INVALID                      NT_STATUS(0xC00A0030)
+#define NT_STATUS_CTX_SHADOW_DISABLED                     NT_STATUS(0xC00A0031)
+#define NT_STATUS_RDP_PROTOCOL_ERROR                      NT_STATUS(0xC00A0032)
+#define NT_STATUS_CTX_CLIENT_LICENSE_NOT_SET              NT_STATUS(0xC00A0033)
+#define NT_STATUS_CTX_CLIENT_LICENSE_IN_USE               NT_STATUS(0xC00A0034)
+#define NT_STATUS_CTX_SHADOW_ENDED_BY_MODE_CHANGE         NT_STATUS(0xC00A0035)
+#define NT_STATUS_CTX_SHADOW_NOT_RUNNING                  NT_STATUS(0xC00A0036)
+#define NT_STATUS_CTX_LOGON_DISABLED                      NT_STATUS(0xC00A0037)
+#define NT_STATUS_CTX_SECURITY_LAYER_ERROR                NT_STATUS(0xC00A0038)
+#define NT_STATUS_TS_INCOMPATIBLE_SESSIONS                NT_STATUS(0xC00A0039)
+#define NT_STATUS_MUI_FILE_NOT_FOUND                      NT_STATUS(0xC00B0001)
+#define NT_STATUS_MUI_INVALID_FILE                        NT_STATUS(0xC00B0002)
+#define NT_STATUS_MUI_INVALID_RC_CONFIG                   NT_STATUS(0xC00B0003)
+#define NT_STATUS_MUI_INVALID_LOCALE_NAME                 NT_STATUS(0xC00B0004)
+#define NT_STATUS_MUI_INVALID_ULTIMATEFALLBACK_NAME       NT_STATUS(0xC00B0005)
+#define NT_STATUS_MUI_FILE_NOT_LOADED                     NT_STATUS(0xC00B0006)
+#define NT_STATUS_RESOURCE_ENUM_USER_STOP                 NT_STATUS(0xC00B0007)
+#define NT_STATUS_CLUSTER_INVALID_NODE                    NT_STATUS(0xC0130001)
+#define NT_STATUS_CLUSTER_NODE_EXISTS                     NT_STATUS(0xC0130002)
+#define NT_STATUS_CLUSTER_JOIN_IN_PROGRESS                NT_STATUS(0xC0130003)
+#define NT_STATUS_CLUSTER_NODE_NOT_FOUND                  NT_STATUS(0xC0130004)
+#define NT_STATUS_CLUSTER_LOCAL_NODE_NOT_FOUND            NT_STATUS(0xC0130005)
+#define NT_STATUS_CLUSTER_NETWORK_EXISTS                  NT_STATUS(0xC0130006)
+#define NT_STATUS_CLUSTER_NETWORK_NOT_FOUND               NT_STATUS(0xC0130007)
+#define NT_STATUS_CLUSTER_NETINTERFACE_EXISTS             NT_STATUS(0xC0130008)
+#define NT_STATUS_CLUSTER_NETINTERFACE_NOT_FOUND          NT_STATUS(0xC0130009)
+#define NT_STATUS_CLUSTER_INVALID_REQUEST                 NT_STATUS(0xC013000A)
+#define NT_STATUS_CLUSTER_INVALID_NETWORK_PROVIDER        NT_STATUS(0xC013000B)
+#define NT_STATUS_CLUSTER_NODE_DOWN                       NT_STATUS(0xC013000C)
+#define NT_STATUS_CLUSTER_NODE_UNREACHABLE                NT_STATUS(0xC013000D)
+#define NT_STATUS_CLUSTER_NODE_NOT_MEMBER                 NT_STATUS(0xC013000E)
+#define NT_STATUS_CLUSTER_JOIN_NOT_IN_PROGRESS            NT_STATUS(0xC013000F)
+#define NT_STATUS_CLUSTER_INVALID_NETWORK                 NT_STATUS(0xC0130010)
+#define NT_STATUS_CLUSTER_NO_NET_ADAPTERS                 NT_STATUS(0xC0130011)
+#define NT_STATUS_CLUSTER_NODE_UP                         NT_STATUS(0xC0130012)
+#define NT_STATUS_CLUSTER_NODE_PAUSED                     NT_STATUS(0xC0130013)
+#define NT_STATUS_CLUSTER_NODE_NOT_PAUSED                 NT_STATUS(0xC0130014)
+#define NT_STATUS_CLUSTER_NO_SECURITY_CONTEXT             NT_STATUS(0xC0130015)
+#define NT_STATUS_CLUSTER_NETWORK_NOT_INTERNAL            NT_STATUS(0xC0130016)
+#define NT_STATUS_CLUSTER_POISONED                        NT_STATUS(0xC0130017)
+#define NT_STATUS_ACPI_INVALID_OPCODE                     NT_STATUS(0xC0140001)
+#define NT_STATUS_ACPI_STACK_OVERFLOW                     NT_STATUS(0xC0140002)
+#define NT_STATUS_ACPI_ASSERT_FAILED                      NT_STATUS(0xC0140003)
+#define NT_STATUS_ACPI_INVALID_INDEX                      NT_STATUS(0xC0140004)
+#define NT_STATUS_ACPI_INVALID_ARGUMENT                   NT_STATUS(0xC0140005)
+#define NT_STATUS_ACPI_FATAL                              NT_STATUS(0xC0140006)
+#define NT_STATUS_ACPI_INVALID_SUPERNAME                  NT_STATUS(0xC0140007)
+#define NT_STATUS_ACPI_INVALID_ARGTYPE                    NT_STATUS(0xC0140008)
+#define NT_STATUS_ACPI_INVALID_OBJTYPE                    NT_STATUS(0xC0140009)
+#define NT_STATUS_ACPI_INVALID_TARGETTYPE                 NT_STATUS(0xC014000A)
+#define NT_STATUS_ACPI_INCORRECT_ARGUMENT_COUNT           NT_STATUS(0xC014000B)
+#define NT_STATUS_ACPI_ADDRESS_NOT_MAPPED                 NT_STATUS(0xC014000C)
+#define NT_STATUS_ACPI_INVALID_EVENTTYPE                  NT_STATUS(0xC014000D)
+#define NT_STATUS_ACPI_HANDLER_COLLISION                  NT_STATUS(0xC014000E)
+#define NT_STATUS_ACPI_INVALID_DATA                       NT_STATUS(0xC014000F)
+#define NT_STATUS_ACPI_INVALID_REGION                     NT_STATUS(0xC0140010)
+#define NT_STATUS_ACPI_INVALID_ACCESS_SIZE                NT_STATUS(0xC0140011)
+#define NT_STATUS_ACPI_ACQUIRE_GLOBAL_LOCK                NT_STATUS(0xC0140012)
+#define NT_STATUS_ACPI_ALREADY_INITIALIZED                NT_STATUS(0xC0140013)
+#define NT_STATUS_ACPI_NOT_INITIALIZED                    NT_STATUS(0xC0140014)
+#define NT_STATUS_ACPI_INVALID_MUTEX_LEVEL                NT_STATUS(0xC0140015)
+#define NT_STATUS_ACPI_MUTEX_NOT_OWNED                    NT_STATUS(0xC0140016)
+#define NT_STATUS_ACPI_MUTEX_NOT_OWNER                    NT_STATUS(0xC0140017)
+#define NT_STATUS_ACPI_RS_ACCESS                          NT_STATUS(0xC0140018)
+#define NT_STATUS_ACPI_INVALID_TABLE                      NT_STATUS(0xC0140019)
+#define NT_STATUS_ACPI_REG_HANDLER_FAILED                 NT_STATUS(0xC0140020)
+#define NT_STATUS_ACPI_POWER_REQUEST_FAILED               NT_STATUS(0xC0140021)
+#define NT_STATUS_SXS_SECTION_NOT_FOUND                   NT_STATUS(0xC0150001)
+#define NT_STATUS_SXS_CANT_GEN_ACTCTX                     NT_STATUS(0xC0150002)
+#define NT_STATUS_SXS_INVALID_ACTCTXDATA_FORMAT           NT_STATUS(0xC0150003)
+#define NT_STATUS_SXS_ASSEMBLY_NOT_FOUND                  NT_STATUS(0xC0150004)
+#define NT_STATUS_SXS_MANIFEST_FORMAT_ERROR               NT_STATUS(0xC0150005)
+#define NT_STATUS_SXS_MANIFEST_PARSE_ERROR                NT_STATUS(0xC0150006)
+#define NT_STATUS_SXS_ACTIVATION_CONTEXT_DISABLED         NT_STATUS(0xC0150007)
+#define NT_STATUS_SXS_KEY_NOT_FOUND                       NT_STATUS(0xC0150008)
+#define NT_STATUS_SXS_VERSION_CONFLICT                    NT_STATUS(0xC0150009)
+#define NT_STATUS_SXS_WRONG_SECTION_TYPE                  NT_STATUS(0xC015000A)
+#define NT_STATUS_SXS_THREAD_QUERIES_DISABLED             NT_STATUS(0xC015000B)
+#define NT_STATUS_SXS_ASSEMBLY_MISSING                    NT_STATUS(0xC015000C)
+#define NT_STATUS_SXS_PROCESS_DEFAULT_ALREADY_SET         NT_STATUS(0xC015000E)
+#define NT_STATUS_SXS_EARLY_DEACTIVATION                  NT_STATUS(0xC015000F)
+#define NT_STATUS_SXS_INVALID_DEACTIVATION                NT_STATUS(0xC0150010)
+#define NT_STATUS_SXS_MULTIPLE_DEACTIVATION               NT_STATUS(0xC0150011)
+#define NT_STATUS_SXS_SYSTEM_DEFAULT_ACTIVATION_CONTEXT_EMPTY NT_STATUS(0xC0150012)
+#define NT_STATUS_SXS_PROCESS_TERMINATION_REQUESTED       NT_STATUS(0xC0150013)
+#define NT_STATUS_SXS_CORRUPT_ACTIVATION_STACK            NT_STATUS(0xC0150014)
+#define NT_STATUS_SXS_CORRUPTION                          NT_STATUS(0xC0150015)
+#define NT_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_VALUE    NT_STATUS(0xC0150016)
+#define NT_STATUS_SXS_INVALID_IDENTITY_ATTRIBUTE_NAME     NT_STATUS(0xC0150017)
+#define NT_STATUS_SXS_IDENTITY_DUPLICATE_ATTRIBUTE        NT_STATUS(0xC0150018)
+#define NT_STATUS_SXS_IDENTITY_PARSE_ERROR                NT_STATUS(0xC0150019)
+#define NT_STATUS_SXS_COMPONENT_STORE_CORRUPT             NT_STATUS(0xC015001A)
+#define NT_STATUS_SXS_FILE_HASH_MISMATCH                  NT_STATUS(0xC015001B)
+#define NT_STATUS_SXS_MANIFEST_IDENTITY_SAME_BUT_CONTENTS_DIFFERENT NT_STATUS(0xC015001C)
+#define NT_STATUS_SXS_IDENTITIES_DIFFERENT                NT_STATUS(0xC015001D)
+#define NT_STATUS_SXS_ASSEMBLY_IS_NOT_A_DEPLOYMENT        NT_STATUS(0xC015001E)
+#define NT_STATUS_SXS_FILE_NOT_PART_OF_ASSEMBLY           NT_STATUS(0xC015001F)
+#define NT_STATUS_ADVANCED_INSTALLER_FAILED               NT_STATUS(0xC0150020)
+#define NT_STATUS_XML_ENCODING_MISMATCH                   NT_STATUS(0xC0150021)
+#define NT_STATUS_SXS_MANIFEST_TOO_BIG                    NT_STATUS(0xC0150022)
+#define NT_STATUS_SXS_SETTING_NOT_REGISTERED              NT_STATUS(0xC0150023)
+#define NT_STATUS_SXS_TRANSACTION_CLOSURE_INCOMPLETE      NT_STATUS(0xC0150024)
+#define NT_STATUS_SMI_PRIMITIVE_INSTALLER_FAILED          NT_STATUS(0xC0150025)
+#define NT_STATUS_GENERIC_COMMAND_FAILED                  NT_STATUS(0xC0150026)
+#define NT_STATUS_SXS_FILE_HASH_MISSING                   NT_STATUS(0xC0150027)
+#define NT_STATUS_TRANSACTIONAL_CONFLICT                  NT_STATUS(0xC0190001)
+#define NT_STATUS_INVALID_TRANSACTION                     NT_STATUS(0xC0190002)
+#define NT_STATUS_TRANSACTION_NOT_ACTIVE                  NT_STATUS(0xC0190003)
+#define NT_STATUS_TM_INITIALIZATION_FAILED                NT_STATUS(0xC0190004)
+#define NT_STATUS_RM_NOT_ACTIVE                           NT_STATUS(0xC0190005)
+#define NT_STATUS_RM_METADATA_CORRUPT                     NT_STATUS(0xC0190006)
+#define NT_STATUS_TRANSACTION_NOT_JOINED                  NT_STATUS(0xC0190007)
+#define NT_STATUS_DIRECTORY_NOT_RM                        NT_STATUS(0xC0190008)
+#define NT_STATUS_TRANSACTIONS_UNSUPPORTED_REMOTE         NT_STATUS(0xC019000A)
+#define NT_STATUS_LOG_RESIZE_INVALID_SIZE                 NT_STATUS(0xC019000B)
+#define NT_STATUS_REMOTE_FILE_VERSION_MISMATCH            NT_STATUS(0xC019000C)
+#define NT_STATUS_CRM_PROTOCOL_ALREADY_EXISTS             NT_STATUS(0xC019000F)
+#define NT_STATUS_TRANSACTION_PROPAGATION_FAILED          NT_STATUS(0xC0190010)
+#define NT_STATUS_CRM_PROTOCOL_NOT_FOUND                  NT_STATUS(0xC0190011)
+#define NT_STATUS_TRANSACTION_SUPERIOR_EXISTS             NT_STATUS(0xC0190012)
+#define NT_STATUS_TRANSACTION_REQUEST_NOT_VALID           NT_STATUS(0xC0190013)
+#define NT_STATUS_TRANSACTION_NOT_REQUESTED               NT_STATUS(0xC0190014)
+#define NT_STATUS_TRANSACTION_ALREADY_ABORTED             NT_STATUS(0xC0190015)
+#define NT_STATUS_TRANSACTION_ALREADY_COMMITTED           NT_STATUS(0xC0190016)
+#define NT_STATUS_TRANSACTION_INVALID_MARSHALL_BUFFER     NT_STATUS(0xC0190017)
+#define NT_STATUS_CURRENT_TRANSACTION_NOT_VALID           NT_STATUS(0xC0190018)
+#define NT_STATUS_LOG_GROWTH_FAILED                       NT_STATUS(0xC0190019)
+#define NT_STATUS_OBJECT_NO_LONGER_EXISTS                 NT_STATUS(0xC0190021)
+#define NT_STATUS_STREAM_MINIVERSION_NOT_FOUND            NT_STATUS(0xC0190022)
+#define NT_STATUS_STREAM_MINIVERSION_NOT_VALID            NT_STATUS(0xC0190023)
+#define NT_STATUS_MINIVERSION_INACCESSIBLE_FROM_SPECIFIED_TRANSACTION NT_STATUS(0xC0190024)
+#define NT_STATUS_CANT_OPEN_MINIVERSION_WITH_MODIFY_INTENT NT_STATUS(0xC0190025)
+#define NT_STATUS_CANT_CREATE_MORE_STREAM_MINIVERSIONS    NT_STATUS(0xC0190026)
+#define NT_STATUS_HANDLE_NO_LONGER_VALID                  NT_STATUS(0xC0190028)
+#define NT_STATUS_LOG_CORRUPTION_DETECTED                 NT_STATUS(0xC0190030)
+#define NT_STATUS_RM_DISCONNECTED                         NT_STATUS(0xC0190032)
+#define NT_STATUS_ENLISTMENT_NOT_SUPERIOR                 NT_STATUS(0xC0190033)
+#define NT_STATUS_FILE_IDENTITY_NOT_PERSISTENT            NT_STATUS(0xC0190036)
+#define NT_STATUS_CANT_BREAK_TRANSACTIONAL_DEPENDENCY     NT_STATUS(0xC0190037)
+#define NT_STATUS_CANT_CROSS_RM_BOUNDARY                  NT_STATUS(0xC0190038)
+#define NT_STATUS_TXF_DIR_NOT_EMPTY                       NT_STATUS(0xC0190039)
+#define NT_STATUS_INDOUBT_TRANSACTIONS_EXIST              NT_STATUS(0xC019003A)
+#define NT_STATUS_TM_VOLATILE                             NT_STATUS(0xC019003B)
+#define NT_STATUS_ROLLBACK_TIMER_EXPIRED                  NT_STATUS(0xC019003C)
+#define NT_STATUS_TXF_ATTRIBUTE_CORRUPT                   NT_STATUS(0xC019003D)
+#define NT_STATUS_EFS_NOT_ALLOWED_IN_TRANSACTION          NT_STATUS(0xC019003E)
+#define NT_STATUS_TRANSACTIONAL_OPEN_NOT_ALLOWED          NT_STATUS(0xC019003F)
+#define NT_STATUS_TRANSACTED_MAPPING_UNSUPPORTED_REMOTE   NT_STATUS(0xC0190040)
+#define NT_STATUS_TRANSACTION_REQUIRED_PROMOTION          NT_STATUS(0xC0190043)
+#define NT_STATUS_CANNOT_EXECUTE_FILE_IN_TRANSACTION      NT_STATUS(0xC0190044)
+#define NT_STATUS_TRANSACTIONS_NOT_FROZEN                 NT_STATUS(0xC0190045)
+#define NT_STATUS_TRANSACTION_FREEZE_IN_PROGRESS          NT_STATUS(0xC0190046)
+#define NT_STATUS_NOT_SNAPSHOT_VOLUME                     NT_STATUS(0xC0190047)
+#define NT_STATUS_NO_SAVEPOINT_WITH_OPEN_FILES            NT_STATUS(0xC0190048)
+#define NT_STATUS_SPARSE_NOT_ALLOWED_IN_TRANSACTION       NT_STATUS(0xC0190049)
+#define NT_STATUS_TM_IDENTITY_MISMATCH                    NT_STATUS(0xC019004A)
+#define NT_STATUS_FLOATED_SECTION                         NT_STATUS(0xC019004B)
+#define NT_STATUS_CANNOT_ACCEPT_TRANSACTED_WORK           NT_STATUS(0xC019004C)
+#define NT_STATUS_CANNOT_ABORT_TRANSACTIONS               NT_STATUS(0xC019004D)
+#define NT_STATUS_TRANSACTION_NOT_FOUND                   NT_STATUS(0xC019004E)
+#define NT_STATUS_RESOURCEMANAGER_NOT_FOUND               NT_STATUS(0xC019004F)
+#define NT_STATUS_ENLISTMENT_NOT_FOUND                    NT_STATUS(0xC0190050)
+#define NT_STATUS_TRANSACTIONMANAGER_NOT_FOUND            NT_STATUS(0xC0190051)
+#define NT_STATUS_TRANSACTIONMANAGER_NOT_ONLINE           NT_STATUS(0xC0190052)
+#define NT_STATUS_TRANSACTIONMANAGER_RECOVERY_NAME_COLLISION NT_STATUS(0xC0190053)
+#define NT_STATUS_TRANSACTION_NOT_ROOT                    NT_STATUS(0xC0190054)
+#define NT_STATUS_TRANSACTION_OBJECT_EXPIRED              NT_STATUS(0xC0190055)
+#define NT_STATUS_COMPRESSION_NOT_ALLOWED_IN_TRANSACTION  NT_STATUS(0xC0190056)
+#define NT_STATUS_TRANSACTION_RESPONSE_NOT_ENLISTED       NT_STATUS(0xC0190057)
+#define NT_STATUS_TRANSACTION_RECORD_TOO_LONG             NT_STATUS(0xC0190058)
+#define NT_STATUS_NO_LINK_TRACKING_IN_TRANSACTION         NT_STATUS(0xC0190059)
+#define NT_STATUS_OPERATION_NOT_SUPPORTED_IN_TRANSACTION  NT_STATUS(0xC019005A)
+#define NT_STATUS_TRANSACTION_INTEGRITY_VIOLATED          NT_STATUS(0xC019005B)
+#define NT_STATUS_EXPIRED_HANDLE                          NT_STATUS(0xC0190060)
+#define NT_STATUS_TRANSACTION_NOT_ENLISTED                NT_STATUS(0xC0190061)
+#define NT_STATUS_LOG_SECTOR_INVALID                      NT_STATUS(0xC01A0001)
+#define NT_STATUS_LOG_SECTOR_PARITY_INVALID               NT_STATUS(0xC01A0002)
+#define NT_STATUS_LOG_SECTOR_REMAPPED                     NT_STATUS(0xC01A0003)
+#define NT_STATUS_LOG_BLOCK_INCOMPLETE                    NT_STATUS(0xC01A0004)
+#define NT_STATUS_LOG_INVALID_RANGE                       NT_STATUS(0xC01A0005)
+#define NT_STATUS_LOG_BLOCKS_EXHAUSTED                    NT_STATUS(0xC01A0006)
+#define NT_STATUS_LOG_READ_CONTEXT_INVALID                NT_STATUS(0xC01A0007)
+#define NT_STATUS_LOG_RESTART_INVALID                     NT_STATUS(0xC01A0008)
+#define NT_STATUS_LOG_BLOCK_VERSION                       NT_STATUS(0xC01A0009)
+#define NT_STATUS_LOG_BLOCK_INVALID                       NT_STATUS(0xC01A000A)
+#define NT_STATUS_LOG_READ_MODE_INVALID                   NT_STATUS(0xC01A000B)
+#define NT_STATUS_LOG_METADATA_CORRUPT                    NT_STATUS(0xC01A000D)
+#define NT_STATUS_LOG_METADATA_INVALID                    NT_STATUS(0xC01A000E)
+#define NT_STATUS_LOG_METADATA_INCONSISTENT               NT_STATUS(0xC01A000F)
+#define NT_STATUS_LOG_RESERVATION_INVALID                 NT_STATUS(0xC01A0010)
+#define NT_STATUS_LOG_CANT_DELETE                         NT_STATUS(0xC01A0011)
+#define NT_STATUS_LOG_CONTAINER_LIMIT_EXCEEDED            NT_STATUS(0xC01A0012)
+#define NT_STATUS_LOG_START_OF_LOG                        NT_STATUS(0xC01A0013)
+#define NT_STATUS_LOG_POLICY_ALREADY_INSTALLED            NT_STATUS(0xC01A0014)
+#define NT_STATUS_LOG_POLICY_NOT_INSTALLED                NT_STATUS(0xC01A0015)
+#define NT_STATUS_LOG_POLICY_INVALID                      NT_STATUS(0xC01A0016)
+#define NT_STATUS_LOG_POLICY_CONFLICT                     NT_STATUS(0xC01A0017)
+#define NT_STATUS_LOG_PINNED_ARCHIVE_TAIL                 NT_STATUS(0xC01A0018)
+#define NT_STATUS_LOG_RECORD_NONEXISTENT                  NT_STATUS(0xC01A0019)
+#define NT_STATUS_LOG_RECORDS_RESERVED_INVALID            NT_STATUS(0xC01A001A)
+#define NT_STATUS_LOG_SPACE_RESERVED_INVALID              NT_STATUS(0xC01A001B)
+#define NT_STATUS_LOG_TAIL_INVALID                        NT_STATUS(0xC01A001C)
+#define NT_STATUS_LOG_FULL                                NT_STATUS(0xC01A001D)
+#define NT_STATUS_LOG_MULTIPLEXED                         NT_STATUS(0xC01A001E)
+#define NT_STATUS_LOG_DEDICATED                           NT_STATUS(0xC01A001F)
+#define NT_STATUS_LOG_ARCHIVE_NOT_IN_PROGRESS             NT_STATUS(0xC01A0020)
+#define NT_STATUS_LOG_ARCHIVE_IN_PROGRESS                 NT_STATUS(0xC01A0021)
+#define NT_STATUS_LOG_EPHEMERAL                           NT_STATUS(0xC01A0022)
+#define NT_STATUS_LOG_NOT_ENOUGH_CONTAINERS               NT_STATUS(0xC01A0023)
+#define NT_STATUS_LOG_CLIENT_ALREADY_REGISTERED           NT_STATUS(0xC01A0024)
+#define NT_STATUS_LOG_CLIENT_NOT_REGISTERED               NT_STATUS(0xC01A0025)
+#define NT_STATUS_LOG_FULL_HANDLER_IN_PROGRESS            NT_STATUS(0xC01A0026)
+#define NT_STATUS_LOG_CONTAINER_READ_FAILED               NT_STATUS(0xC01A0027)
+#define NT_STATUS_LOG_CONTAINER_WRITE_FAILED              NT_STATUS(0xC01A0028)
+#define NT_STATUS_LOG_CONTAINER_OPEN_FAILED               NT_STATUS(0xC01A0029)
+#define NT_STATUS_LOG_CONTAINER_STATE_INVALID             NT_STATUS(0xC01A002A)
+#define NT_STATUS_LOG_STATE_INVALID                       NT_STATUS(0xC01A002B)
+#define NT_STATUS_LOG_PINNED                              NT_STATUS(0xC01A002C)
+#define NT_STATUS_LOG_METADATA_FLUSH_FAILED               NT_STATUS(0xC01A002D)
+#define NT_STATUS_LOG_INCONSISTENT_SECURITY               NT_STATUS(0xC01A002E)
+#define NT_STATUS_LOG_APPENDED_FLUSH_FAILED               NT_STATUS(0xC01A002F)
+#define NT_STATUS_LOG_PINNED_RESERVATION                  NT_STATUS(0xC01A0030)
+#define NT_STATUS_VIDEO_HUNG_DISPLAY_DRIVER_THREAD        NT_STATUS(0xC01B00EA)
+#define NT_STATUS_FLT_NO_HANDLER_DEFINED                  NT_STATUS(0xC01C0001)
+#define NT_STATUS_FLT_CONTEXT_ALREADY_DEFINED             NT_STATUS(0xC01C0002)
+#define NT_STATUS_FLT_INVALID_ASYNCHRONOUS_REQUEST        NT_STATUS(0xC01C0003)
+#define NT_STATUS_FLT_DISALLOW_FAST_IO                    NT_STATUS(0xC01C0004)
+#define NT_STATUS_FLT_INVALID_NAME_REQUEST                NT_STATUS(0xC01C0005)
+#define NT_STATUS_FLT_NOT_SAFE_TO_POST_OPERATION          NT_STATUS(0xC01C0006)
+#define NT_STATUS_FLT_NOT_INITIALIZED                     NT_STATUS(0xC01C0007)
+#define NT_STATUS_FLT_FILTER_NOT_READY                    NT_STATUS(0xC01C0008)
+#define NT_STATUS_FLT_POST_OPERATION_CLEANUP              NT_STATUS(0xC01C0009)
+#define NT_STATUS_FLT_INTERNAL_ERROR                      NT_STATUS(0xC01C000A)
+#define NT_STATUS_FLT_DELETING_OBJECT                     NT_STATUS(0xC01C000B)
+#define NT_STATUS_FLT_MUST_BE_NONPAGED_POOL               NT_STATUS(0xC01C000C)
+#define NT_STATUS_FLT_DUPLICATE_ENTRY                     NT_STATUS(0xC01C000D)
+#define NT_STATUS_FLT_CBDQ_DISABLED                       NT_STATUS(0xC01C000E)
+#define NT_STATUS_FLT_DO_NOT_ATTACH                       NT_STATUS(0xC01C000F)
+#define NT_STATUS_FLT_DO_NOT_DETACH                       NT_STATUS(0xC01C0010)
+#define NT_STATUS_FLT_INSTANCE_ALTITUDE_COLLISION         NT_STATUS(0xC01C0011)
+#define NT_STATUS_FLT_INSTANCE_NAME_COLLISION             NT_STATUS(0xC01C0012)
+#define NT_STATUS_FLT_FILTER_NOT_FOUND                    NT_STATUS(0xC01C0013)
+#define NT_STATUS_FLT_VOLUME_NOT_FOUND                    NT_STATUS(0xC01C0014)
+#define NT_STATUS_FLT_INSTANCE_NOT_FOUND                  NT_STATUS(0xC01C0015)
+#define NT_STATUS_FLT_CONTEXT_ALLOCATION_NOT_FOUND        NT_STATUS(0xC01C0016)
+#define NT_STATUS_FLT_INVALID_CONTEXT_REGISTRATION        NT_STATUS(0xC01C0017)
+#define NT_STATUS_FLT_NAME_CACHE_MISS                     NT_STATUS(0xC01C0018)
+#define NT_STATUS_FLT_NO_DEVICE_OBJECT                    NT_STATUS(0xC01C0019)
+#define NT_STATUS_FLT_VOLUME_ALREADY_MOUNTED              NT_STATUS(0xC01C001A)
+#define NT_STATUS_FLT_ALREADY_ENLISTED                    NT_STATUS(0xC01C001B)
+#define NT_STATUS_FLT_CONTEXT_ALREADY_LINKED              NT_STATUS(0xC01C001C)
+#define NT_STATUS_FLT_NO_WAITER_FOR_REPLY                 NT_STATUS(0xC01C0020)
+#define NT_STATUS_MONITOR_NO_DESCRIPTOR                   NT_STATUS(0xC01D0001)
+#define NT_STATUS_MONITOR_UNKNOWN_DESCRIPTOR_FORMAT       NT_STATUS(0xC01D0002)
+#define NT_STATUS_MONITOR_INVALID_DESCRIPTOR_CHECKSUM     NT_STATUS(0xC01D0003)
+#define NT_STATUS_MONITOR_INVALID_STANDARD_TIMING_BLOCK   NT_STATUS(0xC01D0004)
+#define NT_STATUS_MONITOR_WMI_DATABLOCK_REGISTRATION_FAILED NT_STATUS(0xC01D0005)
+#define NT_STATUS_MONITOR_INVALID_SERIAL_NUMBER_MONDSC_BLOCK NT_STATUS(0xC01D0006)
+#define NT_STATUS_MONITOR_INVALID_USER_FRIENDLY_MONDSC_BLOCK NT_STATUS(0xC01D0007)
+#define NT_STATUS_MONITOR_NO_MORE_DESCRIPTOR_DATA         NT_STATUS(0xC01D0008)
+#define NT_STATUS_MONITOR_INVALID_DETAILED_TIMING_BLOCK   NT_STATUS(0xC01D0009)
+#define NT_STATUS_MONITOR_INVALID_MANUFACTURE_DATE        NT_STATUS(0xC01D000A)
+#define NT_STATUS_GRAPHICS_NOT_EXCLUSIVE_MODE_OWNER       NT_STATUS(0xC01E0000)
+#define NT_STATUS_GRAPHICS_INSUFFICIENT_DMA_BUFFER        NT_STATUS(0xC01E0001)
+#define NT_STATUS_GRAPHICS_INVALID_DISPLAY_ADAPTER        NT_STATUS(0xC01E0002)
+#define NT_STATUS_GRAPHICS_ADAPTER_WAS_RESET              NT_STATUS(0xC01E0003)
+#define NT_STATUS_GRAPHICS_INVALID_DRIVER_MODEL           NT_STATUS(0xC01E0004)
+#define NT_STATUS_GRAPHICS_PRESENT_MODE_CHANGED           NT_STATUS(0xC01E0005)
+#define NT_STATUS_GRAPHICS_PRESENT_OCCLUDED               NT_STATUS(0xC01E0006)
+#define NT_STATUS_GRAPHICS_PRESENT_DENIED                 NT_STATUS(0xC01E0007)
+#define NT_STATUS_GRAPHICS_CANNOTCOLORCONVERT             NT_STATUS(0xC01E0008)
+#define NT_STATUS_GRAPHICS_PRESENT_REDIRECTION_DISABLED   NT_STATUS(0xC01E000B)
+#define NT_STATUS_GRAPHICS_PRESENT_UNOCCLUDED             NT_STATUS(0xC01E000C)
+#define NT_STATUS_GRAPHICS_NO_VIDEO_MEMORY                NT_STATUS(0xC01E0100)
+#define NT_STATUS_GRAPHICS_CANT_LOCK_MEMORY               NT_STATUS(0xC01E0101)
+#define NT_STATUS_GRAPHICS_ALLOCATION_BUSY                NT_STATUS(0xC01E0102)
+#define NT_STATUS_GRAPHICS_TOO_MANY_REFERENCES            NT_STATUS(0xC01E0103)
+#define NT_STATUS_GRAPHICS_TRY_AGAIN_LATER                NT_STATUS(0xC01E0104)
+#define NT_STATUS_GRAPHICS_TRY_AGAIN_NOW                  NT_STATUS(0xC01E0105)
+#define NT_STATUS_GRAPHICS_ALLOCATION_INVALID             NT_STATUS(0xC01E0106)
+#define NT_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNAVAILABLE NT_STATUS(0xC01E0107)
+#define NT_STATUS_GRAPHICS_UNSWIZZLING_APERTURE_UNSUPPORTED NT_STATUS(0xC01E0108)
+#define NT_STATUS_GRAPHICS_CANT_EVICT_PINNED_ALLOCATION   NT_STATUS(0xC01E0109)
+#define NT_STATUS_GRAPHICS_INVALID_ALLOCATION_USAGE       NT_STATUS(0xC01E0110)
+#define NT_STATUS_GRAPHICS_CANT_RENDER_LOCKED_ALLOCATION  NT_STATUS(0xC01E0111)
+#define NT_STATUS_GRAPHICS_ALLOCATION_CLOSED              NT_STATUS(0xC01E0112)
+#define NT_STATUS_GRAPHICS_INVALID_ALLOCATION_INSTANCE    NT_STATUS(0xC01E0113)
+#define NT_STATUS_GRAPHICS_INVALID_ALLOCATION_HANDLE      NT_STATUS(0xC01E0114)
+#define NT_STATUS_GRAPHICS_WRONG_ALLOCATION_DEVICE        NT_STATUS(0xC01E0115)
+#define NT_STATUS_GRAPHICS_ALLOCATION_CONTENT_LOST        NT_STATUS(0xC01E0116)
+#define NT_STATUS_GRAPHICS_GPU_EXCEPTION_ON_DEVICE        NT_STATUS(0xC01E0200)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY         NT_STATUS(0xC01E0300)
+#define NT_STATUS_GRAPHICS_VIDPN_TOPOLOGY_NOT_SUPPORTED   NT_STATUS(0xC01E0301)
+#define NT_STATUS_GRAPHICS_VIDPN_TOPOLOGY_CURRENTLY_NOT_SUPPORTED NT_STATUS(0xC01E0302)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN                  NT_STATUS(0xC01E0303)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE   NT_STATUS(0xC01E0304)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET   NT_STATUS(0xC01E0305)
+#define NT_STATUS_GRAPHICS_VIDPN_MODALITY_NOT_SUPPORTED   NT_STATUS(0xC01E0306)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_SOURCEMODESET    NT_STATUS(0xC01E0308)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TARGETMODESET    NT_STATUS(0xC01E0309)
+#define NT_STATUS_GRAPHICS_INVALID_FREQUENCY              NT_STATUS(0xC01E030A)
+#define NT_STATUS_GRAPHICS_INVALID_ACTIVE_REGION          NT_STATUS(0xC01E030B)
+#define NT_STATUS_GRAPHICS_INVALID_TOTAL_REGION           NT_STATUS(0xC01E030C)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_SOURCE_MODE NT_STATUS(0xC01E0310)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEO_PRESENT_TARGET_MODE NT_STATUS(0xC01E0311)
+#define NT_STATUS_GRAPHICS_PINNED_MODE_MUST_REMAIN_IN_SET NT_STATUS(0xC01E0312)
+#define NT_STATUS_GRAPHICS_PATH_ALREADY_IN_TOPOLOGY       NT_STATUS(0xC01E0313)
+#define NT_STATUS_GRAPHICS_MODE_ALREADY_IN_MODESET        NT_STATUS(0xC01E0314)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEOPRESENTSOURCESET  NT_STATUS(0xC01E0315)
+#define NT_STATUS_GRAPHICS_INVALID_VIDEOPRESENTTARGETSET  NT_STATUS(0xC01E0316)
+#define NT_STATUS_GRAPHICS_SOURCE_ALREADY_IN_SET          NT_STATUS(0xC01E0317)
+#define NT_STATUS_GRAPHICS_TARGET_ALREADY_IN_SET          NT_STATUS(0xC01E0318)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_PRESENT_PATH     NT_STATUS(0xC01E0319)
+#define NT_STATUS_GRAPHICS_NO_RECOMMENDED_VIDPN_TOPOLOGY  NT_STATUS(0xC01E031A)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGESET NT_STATUS(0xC01E031B)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE NT_STATUS(0xC01E031C)
+#define NT_STATUS_GRAPHICS_FREQUENCYRANGE_NOT_IN_SET      NT_STATUS(0xC01E031D)
+#define NT_STATUS_GRAPHICS_FREQUENCYRANGE_ALREADY_IN_SET  NT_STATUS(0xC01E031F)
+#define NT_STATUS_GRAPHICS_STALE_MODESET                  NT_STATUS(0xC01E0320)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_SOURCEMODESET  NT_STATUS(0xC01E0321)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_SOURCE_MODE    NT_STATUS(0xC01E0322)
+#define NT_STATUS_GRAPHICS_NO_RECOMMENDED_FUNCTIONAL_VIDPN NT_STATUS(0xC01E0323)
+#define NT_STATUS_GRAPHICS_MODE_ID_MUST_BE_UNIQUE         NT_STATUS(0xC01E0324)
+#define NT_STATUS_GRAPHICS_EMPTY_ADAPTER_MONITOR_MODE_SUPPORT_INTERSECTION NT_STATUS(0xC01E0325)
+#define NT_STATUS_GRAPHICS_VIDEO_PRESENT_TARGETS_LESS_THAN_SOURCES NT_STATUS(0xC01E0326)
+#define NT_STATUS_GRAPHICS_PATH_NOT_IN_TOPOLOGY           NT_STATUS(0xC01E0327)
+#define NT_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_SOURCE NT_STATUS(0xC01E0328)
+#define NT_STATUS_GRAPHICS_ADAPTER_MUST_HAVE_AT_LEAST_ONE_TARGET NT_STATUS(0xC01E0329)
+#define NT_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTORSET   NT_STATUS(0xC01E032A)
+#define NT_STATUS_GRAPHICS_INVALID_MONITORDESCRIPTOR      NT_STATUS(0xC01E032B)
+#define NT_STATUS_GRAPHICS_MONITORDESCRIPTOR_NOT_IN_SET   NT_STATUS(0xC01E032C)
+#define NT_STATUS_GRAPHICS_MONITORDESCRIPTOR_ALREADY_IN_SET NT_STATUS(0xC01E032D)
+#define NT_STATUS_GRAPHICS_MONITORDESCRIPTOR_ID_MUST_BE_UNIQUE NT_STATUS(0xC01E032E)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TARGET_SUBSET_TYPE NT_STATUS(0xC01E032F)
+#define NT_STATUS_GRAPHICS_RESOURCES_NOT_RELATED          NT_STATUS(0xC01E0330)
+#define NT_STATUS_GRAPHICS_SOURCE_ID_MUST_BE_UNIQUE       NT_STATUS(0xC01E0331)
+#define NT_STATUS_GRAPHICS_TARGET_ID_MUST_BE_UNIQUE       NT_STATUS(0xC01E0332)
+#define NT_STATUS_GRAPHICS_NO_AVAILABLE_VIDPN_TARGET      NT_STATUS(0xC01E0333)
+#define NT_STATUS_GRAPHICS_MONITOR_COULD_NOT_BE_ASSOCIATED_WITH_ADAPTER NT_STATUS(0xC01E0334)
+#define NT_STATUS_GRAPHICS_NO_VIDPNMGR                    NT_STATUS(0xC01E0335)
+#define NT_STATUS_GRAPHICS_NO_ACTIVE_VIDPN                NT_STATUS(0xC01E0336)
+#define NT_STATUS_GRAPHICS_STALE_VIDPN_TOPOLOGY           NT_STATUS(0xC01E0337)
+#define NT_STATUS_GRAPHICS_MONITOR_NOT_CONNECTED          NT_STATUS(0xC01E0338)
+#define NT_STATUS_GRAPHICS_SOURCE_NOT_IN_TOPOLOGY         NT_STATUS(0xC01E0339)
+#define NT_STATUS_GRAPHICS_INVALID_PRIMARYSURFACE_SIZE    NT_STATUS(0xC01E033A)
+#define NT_STATUS_GRAPHICS_INVALID_VISIBLEREGION_SIZE     NT_STATUS(0xC01E033B)
+#define NT_STATUS_GRAPHICS_INVALID_STRIDE                 NT_STATUS(0xC01E033C)
+#define NT_STATUS_GRAPHICS_INVALID_PIXELFORMAT            NT_STATUS(0xC01E033D)
+#define NT_STATUS_GRAPHICS_INVALID_COLORBASIS             NT_STATUS(0xC01E033E)
+#define NT_STATUS_GRAPHICS_INVALID_PIXELVALUEACCESSMODE   NT_STATUS(0xC01E033F)
+#define NT_STATUS_GRAPHICS_TARGET_NOT_IN_TOPOLOGY         NT_STATUS(0xC01E0340)
+#define NT_STATUS_GRAPHICS_NO_DISPLAY_MODE_MANAGEMENT_SUPPORT NT_STATUS(0xC01E0341)
+#define NT_STATUS_GRAPHICS_VIDPN_SOURCE_IN_USE            NT_STATUS(0xC01E0342)
+#define NT_STATUS_GRAPHICS_CANT_ACCESS_ACTIVE_VIDPN       NT_STATUS(0xC01E0343)
+#define NT_STATUS_GRAPHICS_INVALID_PATH_IMPORTANCE_ORDINAL NT_STATUS(0xC01E0344)
+#define NT_STATUS_GRAPHICS_INVALID_PATH_CONTENT_GEOMETRY_TRANSFORMATION NT_STATUS(0xC01E0345)
+#define NT_STATUS_GRAPHICS_PATH_CONTENT_GEOMETRY_TRANSFORMATION_NOT_SUPPORTED NT_STATUS(0xC01E0346)
+#define NT_STATUS_GRAPHICS_INVALID_GAMMA_RAMP             NT_STATUS(0xC01E0347)
+#define NT_STATUS_GRAPHICS_GAMMA_RAMP_NOT_SUPPORTED       NT_STATUS(0xC01E0348)
+#define NT_STATUS_GRAPHICS_MULTISAMPLING_NOT_SUPPORTED    NT_STATUS(0xC01E0349)
+#define NT_STATUS_GRAPHICS_MODE_NOT_IN_MODESET            NT_STATUS(0xC01E034A)
+#define NT_STATUS_GRAPHICS_INVALID_VIDPN_TOPOLOGY_RECOMMENDATION_REASON NT_STATUS(0xC01E034D)
+#define NT_STATUS_GRAPHICS_INVALID_PATH_CONTENT_TYPE      NT_STATUS(0xC01E034E)
+#define NT_STATUS_GRAPHICS_INVALID_COPYPROTECTION_TYPE    NT_STATUS(0xC01E034F)
+#define NT_STATUS_GRAPHICS_UNASSIGNED_MODESET_ALREADY_EXISTS NT_STATUS(0xC01E0350)
+#define NT_STATUS_GRAPHICS_INVALID_SCANLINE_ORDERING      NT_STATUS(0xC01E0352)
+#define NT_STATUS_GRAPHICS_TOPOLOGY_CHANGES_NOT_ALLOWED   NT_STATUS(0xC01E0353)
+#define NT_STATUS_GRAPHICS_NO_AVAILABLE_IMPORTANCE_ORDINALS NT_STATUS(0xC01E0354)
+#define NT_STATUS_GRAPHICS_INCOMPATIBLE_PRIVATE_FORMAT    NT_STATUS(0xC01E0355)
+#define NT_STATUS_GRAPHICS_INVALID_MODE_PRUNING_ALGORITHM NT_STATUS(0xC01E0356)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_CAPABILITY_ORIGIN NT_STATUS(0xC01E0357)
+#define NT_STATUS_GRAPHICS_INVALID_MONITOR_FREQUENCYRANGE_CONSTRAINT NT_STATUS(0xC01E0358)
+#define NT_STATUS_GRAPHICS_MAX_NUM_PATHS_REACHED          NT_STATUS(0xC01E0359)
+#define NT_STATUS_GRAPHICS_CANCEL_VIDPN_TOPOLOGY_AUGMENTATION NT_STATUS(0xC01E035A)
+#define NT_STATUS_GRAPHICS_INVALID_CLIENT_TYPE            NT_STATUS(0xC01E035B)
+#define NT_STATUS_GRAPHICS_CLIENTVIDPN_NOT_SET            NT_STATUS(0xC01E035C)
+#define NT_STATUS_GRAPHICS_SPECIFIED_CHILD_ALREADY_CONNECTED NT_STATUS(0xC01E0400)
+#define NT_STATUS_GRAPHICS_CHILD_DESCRIPTOR_NOT_SUPPORTED NT_STATUS(0xC01E0401)
+#define NT_STATUS_GRAPHICS_NOT_A_LINKED_ADAPTER           NT_STATUS(0xC01E0430)
+#define NT_STATUS_GRAPHICS_LEADLINK_NOT_ENUMERATED        NT_STATUS(0xC01E0431)
+#define NT_STATUS_GRAPHICS_CHAINLINKS_NOT_ENUMERATED      NT_STATUS(0xC01E0432)
+#define NT_STATUS_GRAPHICS_ADAPTER_CHAIN_NOT_READY        NT_STATUS(0xC01E0433)
+#define NT_STATUS_GRAPHICS_CHAINLINKS_NOT_STARTED         NT_STATUS(0xC01E0434)
+#define NT_STATUS_GRAPHICS_CHAINLINKS_NOT_POWERED_ON      NT_STATUS(0xC01E0435)
+#define NT_STATUS_GRAPHICS_INCONSISTENT_DEVICE_LINK_STATE NT_STATUS(0xC01E0436)
+#define NT_STATUS_GRAPHICS_NOT_POST_DEVICE_DRIVER         NT_STATUS(0xC01E0438)
+#define NT_STATUS_GRAPHICS_ADAPTER_ACCESS_NOT_EXCLUDED    NT_STATUS(0xC01E043B)
+#define NT_STATUS_GRAPHICS_OPM_NOT_SUPPORTED              NT_STATUS(0xC01E0500)
+#define NT_STATUS_GRAPHICS_COPP_NOT_SUPPORTED             NT_STATUS(0xC01E0501)
+#define NT_STATUS_GRAPHICS_UAB_NOT_SUPPORTED              NT_STATUS(0xC01E0502)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_ENCRYPTED_PARAMETERS NT_STATUS(0xC01E0503)
+#define NT_STATUS_GRAPHICS_OPM_PARAMETER_ARRAY_TOO_SMALL  NT_STATUS(0xC01E0504)
+#define NT_STATUS_GRAPHICS_OPM_NO_PROTECTED_OUTPUTS_EXIST NT_STATUS(0xC01E0505)
+#define NT_STATUS_GRAPHICS_PVP_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME NT_STATUS(0xC01E0506)
+#define NT_STATUS_GRAPHICS_PVP_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP NT_STATUS(0xC01E0507)
+#define NT_STATUS_GRAPHICS_PVP_MIRRORING_DEVICES_NOT_SUPPORTED NT_STATUS(0xC01E0508)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_POINTER            NT_STATUS(0xC01E050A)
+#define NT_STATUS_GRAPHICS_OPM_INTERNAL_ERROR             NT_STATUS(0xC01E050B)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_HANDLE             NT_STATUS(0xC01E050C)
+#define NT_STATUS_GRAPHICS_PVP_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE NT_STATUS(0xC01E050D)
+#define NT_STATUS_GRAPHICS_PVP_INVALID_CERTIFICATE_LENGTH NT_STATUS(0xC01E050E)
+#define NT_STATUS_GRAPHICS_OPM_SPANNING_MODE_ENABLED      NT_STATUS(0xC01E050F)
+#define NT_STATUS_GRAPHICS_OPM_THEATER_MODE_ENABLED       NT_STATUS(0xC01E0510)
+#define NT_STATUS_GRAPHICS_PVP_HFS_FAILED                 NT_STATUS(0xC01E0511)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_SRM                NT_STATUS(0xC01E0512)
+#define NT_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_HDCP NT_STATUS(0xC01E0513)
+#define NT_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_ACP NT_STATUS(0xC01E0514)
+#define NT_STATUS_GRAPHICS_OPM_OUTPUT_DOES_NOT_SUPPORT_CGMSA NT_STATUS(0xC01E0515)
+#define NT_STATUS_GRAPHICS_OPM_HDCP_SRM_NEVER_SET         NT_STATUS(0xC01E0516)
+#define NT_STATUS_GRAPHICS_OPM_RESOLUTION_TOO_HIGH        NT_STATUS(0xC01E0517)
+#define NT_STATUS_GRAPHICS_OPM_ALL_HDCP_HARDWARE_ALREADY_IN_USE NT_STATUS(0xC01E0518)
+#define NT_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_NO_LONGER_EXISTS NT_STATUS(0xC01E051A)
+#define NT_STATUS_GRAPHICS_OPM_SESSION_TYPE_CHANGE_IN_PROGRESS NT_STATUS(0xC01E051B)
+#define NT_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_COPP_SEMANTICS NT_STATUS(0xC01E051C)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_INFORMATION_REQUEST NT_STATUS(0xC01E051D)
+#define NT_STATUS_GRAPHICS_OPM_DRIVER_INTERNAL_ERROR      NT_STATUS(0xC01E051E)
+#define NT_STATUS_GRAPHICS_OPM_PROTECTED_OUTPUT_DOES_NOT_HAVE_OPM_SEMANTICS NT_STATUS(0xC01E051F)
+#define NT_STATUS_GRAPHICS_OPM_SIGNALING_NOT_SUPPORTED    NT_STATUS(0xC01E0520)
+#define NT_STATUS_GRAPHICS_OPM_INVALID_CONFIGURATION_REQUEST NT_STATUS(0xC01E0521)
+#define NT_STATUS_GRAPHICS_I2C_NOT_SUPPORTED              NT_STATUS(0xC01E0580)
+#define NT_STATUS_GRAPHICS_I2C_DEVICE_DOES_NOT_EXIST      NT_STATUS(0xC01E0581)
+#define NT_STATUS_GRAPHICS_I2C_ERROR_TRANSMITTING_DATA    NT_STATUS(0xC01E0582)
+#define NT_STATUS_GRAPHICS_I2C_ERROR_RECEIVING_DATA       NT_STATUS(0xC01E0583)
+#define NT_STATUS_GRAPHICS_DDCCI_VCP_NOT_SUPPORTED        NT_STATUS(0xC01E0584)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_DATA             NT_STATUS(0xC01E0585)
+#define NT_STATUS_GRAPHICS_DDCCI_MONITOR_RETURNED_INVALID_TIMING_STATUS_BYTE NT_STATUS(0xC01E0586)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_CAPABILITIES_STRING NT_STATUS(0xC01E0587)
+#define NT_STATUS_GRAPHICS_MCA_INTERNAL_ERROR             NT_STATUS(0xC01E0588)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_COMMAND  NT_STATUS(0xC01E0589)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_LENGTH   NT_STATUS(0xC01E058A)
+#define NT_STATUS_GRAPHICS_DDCCI_INVALID_MESSAGE_CHECKSUM NT_STATUS(0xC01E058B)
+#define NT_STATUS_GRAPHICS_INVALID_PHYSICAL_MONITOR_HANDLE NT_STATUS(0xC01E058C)
+#define NT_STATUS_GRAPHICS_MONITOR_NO_LONGER_EXISTS       NT_STATUS(0xC01E058D)
+#define NT_STATUS_GRAPHICS_ONLY_CONSOLE_SESSION_SUPPORTED NT_STATUS(0xC01E05E0)
+#define NT_STATUS_GRAPHICS_NO_DISPLAY_DEVICE_CORRESPONDS_TO_NAME NT_STATUS(0xC01E05E1)
+#define NT_STATUS_GRAPHICS_DISPLAY_DEVICE_NOT_ATTACHED_TO_DESKTOP NT_STATUS(0xC01E05E2)
+#define NT_STATUS_GRAPHICS_MIRRORING_DEVICES_NOT_SUPPORTED NT_STATUS(0xC01E05E3)
+#define NT_STATUS_GRAPHICS_INVALID_POINTER                NT_STATUS(0xC01E05E4)
+#define NT_STATUS_GRAPHICS_NO_MONITORS_CORRESPOND_TO_DISPLAY_DEVICE NT_STATUS(0xC01E05E5)
+#define NT_STATUS_GRAPHICS_PARAMETER_ARRAY_TOO_SMALL      NT_STATUS(0xC01E05E6)
+#define NT_STATUS_GRAPHICS_INTERNAL_ERROR                 NT_STATUS(0xC01E05E7)
+#define NT_STATUS_GRAPHICS_SESSION_TYPE_CHANGE_IN_PROGRESS NT_STATUS(0xC01E05E8)
+#define NT_STATUS_FVE_LOCKED_VOLUME                       NT_STATUS(0xC0210000)
+#define NT_STATUS_FVE_NOT_ENCRYPTED                       NT_STATUS(0xC0210001)
+#define NT_STATUS_FVE_BAD_INFORMATION                     NT_STATUS(0xC0210002)
+#define NT_STATUS_FVE_TOO_SMALL                           NT_STATUS(0xC0210003)
+#define NT_STATUS_FVE_FAILED_WRONG_FS                     NT_STATUS(0xC0210004)
+#define NT_STATUS_FVE_FAILED_BAD_FS                       NT_STATUS(0xC0210005)
+#define NT_STATUS_FVE_FS_NOT_EXTENDED                     NT_STATUS(0xC0210006)
+#define NT_STATUS_FVE_FS_MOUNTED                          NT_STATUS(0xC0210007)
+#define NT_STATUS_FVE_NO_LICENSE                          NT_STATUS(0xC0210008)
+#define NT_STATUS_FVE_ACTION_NOT_ALLOWED                  NT_STATUS(0xC0210009)
+#define NT_STATUS_FVE_BAD_DATA                            NT_STATUS(0xC021000A)
+#define NT_STATUS_FVE_VOLUME_NOT_BOUND                    NT_STATUS(0xC021000B)
+#define NT_STATUS_FVE_NOT_DATA_VOLUME                     NT_STATUS(0xC021000C)
+#define NT_STATUS_FVE_CONV_READ_ERROR                     NT_STATUS(0xC021000D)
+#define NT_STATUS_FVE_CONV_WRITE_ERROR                    NT_STATUS(0xC021000E)
+#define NT_STATUS_FVE_OVERLAPPED_UPDATE                   NT_STATUS(0xC021000F)
+#define NT_STATUS_FVE_FAILED_SECTOR_SIZE                  NT_STATUS(0xC0210010)
+#define NT_STATUS_FVE_FAILED_AUTHENTICATION               NT_STATUS(0xC0210011)
+#define NT_STATUS_FVE_NOT_OS_VOLUME                       NT_STATUS(0xC0210012)
+#define NT_STATUS_FVE_KEYFILE_NOT_FOUND                   NT_STATUS(0xC0210013)
+#define NT_STATUS_FVE_KEYFILE_INVALID                     NT_STATUS(0xC0210014)
+#define NT_STATUS_FVE_KEYFILE_NO_VMK                      NT_STATUS(0xC0210015)
+#define NT_STATUS_FVE_TPM_DISABLED                        NT_STATUS(0xC0210016)
+#define NT_STATUS_FVE_TPM_SRK_AUTH_NOT_ZERO               NT_STATUS(0xC0210017)
+#define NT_STATUS_FVE_TPM_INVALID_PCR                     NT_STATUS(0xC0210018)
+#define NT_STATUS_FVE_TPM_NO_VMK                          NT_STATUS(0xC0210019)
+#define NT_STATUS_FVE_PIN_INVALID                         NT_STATUS(0xC021001A)
+#define NT_STATUS_FVE_AUTH_INVALID_APPLICATION            NT_STATUS(0xC021001B)
+#define NT_STATUS_FVE_AUTH_INVALID_CONFIG                 NT_STATUS(0xC021001C)
+#define NT_STATUS_FVE_DEBUGGER_ENABLED                    NT_STATUS(0xC021001D)
+#define NT_STATUS_FVE_DRY_RUN_FAILED                      NT_STATUS(0xC021001E)
+#define NT_STATUS_FVE_BAD_METADATA_POINTER                NT_STATUS(0xC021001F)
+#define NT_STATUS_FVE_OLD_METADATA_COPY                   NT_STATUS(0xC0210020)
+#define NT_STATUS_FVE_REBOOT_REQUIRED                     NT_STATUS(0xC0210021)
+#define NT_STATUS_FVE_RAW_ACCESS                          NT_STATUS(0xC0210022)
+#define NT_STATUS_FVE_RAW_BLOCKED                         NT_STATUS(0xC0210023)
+#define NT_STATUS_FVE_NO_FEATURE_LICENSE                  NT_STATUS(0xC0210026)
+#define NT_STATUS_FVE_POLICY_USER_DISABLE_RDV_NOT_ALLOWED NT_STATUS(0xC0210027)
+#define NT_STATUS_FVE_CONV_RECOVERY_FAILED                NT_STATUS(0xC0210028)
+#define NT_STATUS_FVE_VIRTUALIZED_SPACE_TOO_BIG           NT_STATUS(0xC0210029)
+#define NT_STATUS_FVE_VOLUME_TOO_SMALL                    NT_STATUS(0xC0210030)
+#define NT_STATUS_FWP_CALLOUT_NOT_FOUND                   NT_STATUS(0xC0220001)
+#define NT_STATUS_FWP_CONDITION_NOT_FOUND                 NT_STATUS(0xC0220002)
+#define NT_STATUS_FWP_FILTER_NOT_FOUND                    NT_STATUS(0xC0220003)
+#define NT_STATUS_FWP_LAYER_NOT_FOUND                     NT_STATUS(0xC0220004)
+#define NT_STATUS_FWP_PROVIDER_NOT_FOUND                  NT_STATUS(0xC0220005)
+#define NT_STATUS_FWP_PROVIDER_CONTEXT_NOT_FOUND          NT_STATUS(0xC0220006)
+#define NT_STATUS_FWP_SUBLAYER_NOT_FOUND                  NT_STATUS(0xC0220007)
+#define NT_STATUS_FWP_NOT_FOUND                           NT_STATUS(0xC0220008)
+#define NT_STATUS_FWP_ALREADY_EXISTS                      NT_STATUS(0xC0220009)
+#define NT_STATUS_FWP_IN_USE                              NT_STATUS(0xC022000A)
+#define NT_STATUS_FWP_DYNAMIC_SESSION_IN_PROGRESS         NT_STATUS(0xC022000B)
+#define NT_STATUS_FWP_WRONG_SESSION                       NT_STATUS(0xC022000C)
+#define NT_STATUS_FWP_NO_TXN_IN_PROGRESS                  NT_STATUS(0xC022000D)
+#define NT_STATUS_FWP_TXN_IN_PROGRESS                     NT_STATUS(0xC022000E)
+#define NT_STATUS_FWP_TXN_ABORTED                         NT_STATUS(0xC022000F)
+#define NT_STATUS_FWP_SESSION_ABORTED                     NT_STATUS(0xC0220010)
+#define NT_STATUS_FWP_INCOMPATIBLE_TXN                    NT_STATUS(0xC0220011)
+#define NT_STATUS_FWP_TIMEOUT                             NT_STATUS(0xC0220012)
+#define NT_STATUS_FWP_NET_EVENTS_DISABLED                 NT_STATUS(0xC0220013)
+#define NT_STATUS_FWP_INCOMPATIBLE_LAYER                  NT_STATUS(0xC0220014)
+#define NT_STATUS_FWP_KM_CLIENTS_ONLY                     NT_STATUS(0xC0220015)
+#define NT_STATUS_FWP_LIFETIME_MISMATCH                   NT_STATUS(0xC0220016)
+#define NT_STATUS_FWP_BUILTIN_OBJECT                      NT_STATUS(0xC0220017)
+#define NT_STATUS_FWP_TOO_MANY_BOOTTIME_FILTERS           NT_STATUS(0xC0220018)
+#define NT_STATUS_FWP_TOO_MANY_CALLOUTS                   NT_STATUS(0xC0220018)
+#define NT_STATUS_FWP_NOTIFICATION_DROPPED                NT_STATUS(0xC0220019)
+#define NT_STATUS_FWP_TRAFFIC_MISMATCH                    NT_STATUS(0xC022001A)
+#define NT_STATUS_FWP_INCOMPATIBLE_SA_STATE               NT_STATUS(0xC022001B)
+#define NT_STATUS_FWP_NULL_POINTER                        NT_STATUS(0xC022001C)
+#define NT_STATUS_FWP_INVALID_ENUMERATOR                  NT_STATUS(0xC022001D)
+#define NT_STATUS_FWP_INVALID_FLAGS                       NT_STATUS(0xC022001E)
+#define NT_STATUS_FWP_INVALID_NET_MASK                    NT_STATUS(0xC022001F)
+#define NT_STATUS_FWP_INVALID_RANGE                       NT_STATUS(0xC0220020)
+#define NT_STATUS_FWP_INVALID_INTERVAL                    NT_STATUS(0xC0220021)
+#define NT_STATUS_FWP_ZERO_LENGTH_ARRAY                   NT_STATUS(0xC0220022)
+#define NT_STATUS_FWP_NULL_DISPLAY_NAME                   NT_STATUS(0xC0220023)
+#define NT_STATUS_FWP_INVALID_ACTION_TYPE                 NT_STATUS(0xC0220024)
+#define NT_STATUS_FWP_INVALID_WEIGHT                      NT_STATUS(0xC0220025)
+#define NT_STATUS_FWP_MATCH_TYPE_MISMATCH                 NT_STATUS(0xC0220026)
+#define NT_STATUS_FWP_TYPE_MISMATCH                       NT_STATUS(0xC0220027)
+#define NT_STATUS_FWP_OUT_OF_BOUNDS                       NT_STATUS(0xC0220028)
+#define NT_STATUS_FWP_RESERVED                            NT_STATUS(0xC0220029)
+#define NT_STATUS_FWP_DUPLICATE_CONDITION                 NT_STATUS(0xC022002A)
+#define NT_STATUS_FWP_DUPLICATE_KEYMOD                    NT_STATUS(0xC022002B)
+#define NT_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_LAYER      NT_STATUS(0xC022002C)
+#define NT_STATUS_FWP_ACTION_INCOMPATIBLE_WITH_SUBLAYER   NT_STATUS(0xC022002D)
+#define NT_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_LAYER     NT_STATUS(0xC022002E)
+#define NT_STATUS_FWP_CONTEXT_INCOMPATIBLE_WITH_CALLOUT   NT_STATUS(0xC022002F)
+#define NT_STATUS_FWP_INCOMPATIBLE_AUTH_METHOD            NT_STATUS(0xC0220030)
+#define NT_STATUS_FWP_INCOMPATIBLE_DH_GROUP               NT_STATUS(0xC0220031)
+#define NT_STATUS_FWP_EM_NOT_SUPPORTED                    NT_STATUS(0xC0220032)
+#define NT_STATUS_FWP_NEVER_MATCH                         NT_STATUS(0xC0220033)
+#define NT_STATUS_FWP_PROVIDER_CONTEXT_MISMATCH           NT_STATUS(0xC0220034)
+#define NT_STATUS_FWP_INVALID_PARAMETER                   NT_STATUS(0xC0220035)
+#define NT_STATUS_FWP_TOO_MANY_SUBLAYERS                  NT_STATUS(0xC0220036)
+#define NT_STATUS_FWP_CALLOUT_NOTIFICATION_FAILED         NT_STATUS(0xC0220037)
+#define NT_STATUS_FWP_INCOMPATIBLE_AUTH_CONFIG            NT_STATUS(0xC0220038)
+#define NT_STATUS_FWP_INCOMPATIBLE_CIPHER_CONFIG          NT_STATUS(0xC0220039)
+#define NT_STATUS_FWP_DUPLICATE_AUTH_METHOD               NT_STATUS(0xC022003C)
+#define NT_STATUS_FWP_TCPIP_NOT_READY                     NT_STATUS(0xC0220100)
+#define NT_STATUS_FWP_INJECT_HANDLE_CLOSING               NT_STATUS(0xC0220101)
+#define NT_STATUS_FWP_INJECT_HANDLE_STALE                 NT_STATUS(0xC0220102)
+#define NT_STATUS_FWP_CANNOT_PEND                         NT_STATUS(0xC0220103)
+#define NT_STATUS_NDIS_CLOSING                            NT_STATUS(0xC0230002)
+#define NT_STATUS_NDIS_BAD_VERSION                        NT_STATUS(0xC0230004)
+#define NT_STATUS_NDIS_BAD_CHARACTERISTICS                NT_STATUS(0xC0230005)
+#define NT_STATUS_NDIS_ADAPTER_NOT_FOUND                  NT_STATUS(0xC0230006)
+#define NT_STATUS_NDIS_OPEN_FAILED                        NT_STATUS(0xC0230007)
+#define NT_STATUS_NDIS_DEVICE_FAILED                      NT_STATUS(0xC0230008)
+#define NT_STATUS_NDIS_MULTICAST_FULL                     NT_STATUS(0xC0230009)
+#define NT_STATUS_NDIS_MULTICAST_EXISTS                   NT_STATUS(0xC023000A)
+#define NT_STATUS_NDIS_MULTICAST_NOT_FOUND                NT_STATUS(0xC023000B)
+#define NT_STATUS_NDIS_REQUEST_ABORTED                    NT_STATUS(0xC023000C)
+#define NT_STATUS_NDIS_RESET_IN_PROGRESS                  NT_STATUS(0xC023000D)
+#define NT_STATUS_NDIS_INVALID_PACKET                     NT_STATUS(0xC023000F)
+#define NT_STATUS_NDIS_INVALID_DEVICE_REQUEST             NT_STATUS(0xC0230010)
+#define NT_STATUS_NDIS_ADAPTER_NOT_READY                  NT_STATUS(0xC0230011)
+#define NT_STATUS_NDIS_INVALID_LENGTH                     NT_STATUS(0xC0230014)
+#define NT_STATUS_NDIS_INVALID_DATA                       NT_STATUS(0xC0230015)
+#define NT_STATUS_NDIS_BUFFER_TOO_SHORT                   NT_STATUS(0xC0230016)
+#define NT_STATUS_NDIS_INVALID_OID                        NT_STATUS(0xC0230017)
+#define NT_STATUS_NDIS_ADAPTER_REMOVED                    NT_STATUS(0xC0230018)
+#define NT_STATUS_NDIS_UNSUPPORTED_MEDIA                  NT_STATUS(0xC0230019)
+#define NT_STATUS_NDIS_GROUP_ADDRESS_IN_USE               NT_STATUS(0xC023001A)
+#define NT_STATUS_NDIS_FILE_NOT_FOUND                     NT_STATUS(0xC023001B)
+#define NT_STATUS_NDIS_ERROR_READING_FILE                 NT_STATUS(0xC023001C)
+#define NT_STATUS_NDIS_ALREADY_MAPPED                     NT_STATUS(0xC023001D)
+#define NT_STATUS_NDIS_RESOURCE_CONFLICT                  NT_STATUS(0xC023001E)
+#define NT_STATUS_NDIS_MEDIA_DISCONNECTED                 NT_STATUS(0xC023001F)
+#define NT_STATUS_NDIS_INVALID_ADDRESS                    NT_STATUS(0xC0230022)
+#define NT_STATUS_NDIS_PAUSED                             NT_STATUS(0xC023002A)
+#define NT_STATUS_NDIS_INTERFACE_NOT_FOUND                NT_STATUS(0xC023002B)
+#define NT_STATUS_NDIS_UNSUPPORTED_REVISION               NT_STATUS(0xC023002C)
+#define NT_STATUS_NDIS_INVALID_PORT                       NT_STATUS(0xC023002D)
+#define NT_STATUS_NDIS_INVALID_PORT_STATE                 NT_STATUS(0xC023002E)
+#define NT_STATUS_NDIS_LOW_POWER_STATE                    NT_STATUS(0xC023002F)
+#define NT_STATUS_NDIS_NOT_SUPPORTED                      NT_STATUS(0xC02300BB)
+#define NT_STATUS_NDIS_OFFLOAD_POLICY                     NT_STATUS(0xC023100F)
+#define NT_STATUS_NDIS_OFFLOAD_CONNECTION_REJECTED        NT_STATUS(0xC0231012)
+#define NT_STATUS_NDIS_OFFLOAD_PATH_REJECTED              NT_STATUS(0xC0231013)
+#define NT_STATUS_NDIS_DOT11_AUTO_CONFIG_ENABLED          NT_STATUS(0xC0232000)
+#define NT_STATUS_NDIS_DOT11_MEDIA_IN_USE                 NT_STATUS(0xC0232001)
+#define NT_STATUS_NDIS_DOT11_POWER_STATE_INVALID          NT_STATUS(0xC0232002)
+#define NT_STATUS_NDIS_PM_WOL_PATTERN_LIST_FULL           NT_STATUS(0xC0232003)
+#define NT_STATUS_NDIS_PM_PROTOCOL_OFFLOAD_LIST_FULL      NT_STATUS(0xC0232004)
+#define NT_STATUS_IPSEC_BAD_SPI                           NT_STATUS(0xC0360001)
+#define NT_STATUS_IPSEC_SA_LIFETIME_EXPIRED               NT_STATUS(0xC0360002)
+#define NT_STATUS_IPSEC_WRONG_SA                          NT_STATUS(0xC0360003)
+#define NT_STATUS_IPSEC_REPLAY_CHECK_FAILED               NT_STATUS(0xC0360004)
+#define NT_STATUS_IPSEC_INVALID_PACKET                    NT_STATUS(0xC0360005)
+#define NT_STATUS_IPSEC_INTEGRITY_CHECK_FAILED            NT_STATUS(0xC0360006)
+#define NT_STATUS_IPSEC_CLEAR_TEXT_DROP                   NT_STATUS(0xC0360007)
+#define NT_STATUS_IPSEC_AUTH_FIREWALL_DROP                NT_STATUS(0xC0360008)
+#define NT_STATUS_IPSEC_THROTTLE_DROP                     NT_STATUS(0xC0360009)
+#define NT_STATUS_IPSEC_DOSP_BLOCK                        NT_STATUS(0xC0368000)
+#define NT_STATUS_IPSEC_DOSP_RECEIVED_MULTICAST           NT_STATUS(0xC0368001)
+#define NT_STATUS_IPSEC_DOSP_INVALID_PACKET               NT_STATUS(0xC0368002)
+#define NT_STATUS_IPSEC_DOSP_STATE_LOOKUP_FAILED          NT_STATUS(0xC0368003)
+#define NT_STATUS_IPSEC_DOSP_MAX_ENTRIES                  NT_STATUS(0xC0368004)
+#define NT_STATUS_IPSEC_DOSP_KEYMOD_NOT_ALLOWED           NT_STATUS(0xC0368005)
+#define NT_STATUS_IPSEC_DOSP_MAX_PER_IP_RATELIMIT_QUEUES  NT_STATUS(0xC0368006)
+#define NT_STATUS_VOLMGR_MIRROR_NOT_SUPPORTED             NT_STATUS(0xC038005B)
+#define NT_STATUS_VOLMGR_RAID5_NOT_SUPPORTED              NT_STATUS(0xC038005C)
+#define NT_STATUS_VIRTDISK_PROVIDER_NOT_FOUND             NT_STATUS(0xC03A0014)
+#define NT_STATUS_VIRTDISK_NOT_VIRTUAL_DISK               NT_STATUS(0xC03A0015)
+#define NT_STATUS_VHD_PARENT_VHD_ACCESS_DENIED            NT_STATUS(0xC03A0016)
+#define NT_STATUS_VHD_CHILD_PARENT_SIZE_MISMATCH          NT_STATUS(0xC03A0017)
+#define NT_STATUS_VHD_DIFFERENCING_CHAIN_CYCLE_DETECTED   NT_STATUS(0xC03A0018)
+#define NT_STATUS_VHD_DIFFERENCING_CHAIN_ERROR_IN_PARENT  NT_STATUS(0xC03A0019)
+#define NT_STATUS_VHD_SHARED                              NT_STATUS(0xC05CFF0A)
+#define NT_STATUS_SMB_NO_PREAUTH_INTEGRITY_HASH_OVERLAP   NT_STATUS(0xC05D0000)
+#define NT_STATUS_SMB_BAD_CLUSTER_DIALECT                 NT_STATUS(0xC05D0001)
 /* I use NT_STATUS_FOOBAR when I have no idea what error code to use -
  * this means we need a torture test */
 #define NT_STATUS_FOOBAR NT_STATUS_UNSUCCESSFUL
+/*****************************************************************************
+ Returns an NT error message.  not amazingly helpful, but better than a number.
+ This version is const, and so neither allocates memory nor uses a
+ static variable for unknown errors.
+ *****************************************************************************/
+const char *nt_errstr_const(NTSTATUS nt_code);
 /*****************************************************************************
 …
  returns an NT_STATUS constant as a string for inclusion in autogen C code
  *****************************************************************************/
 const char *get_nt_error_c_code(NTSTATUS nt_code);
+const char *get_nt_error_c_code(void *mem_ctx, NTSTATUS nt_code);
 /*****************************************************************************
 …
  *****************************************************************************/
 NTSTATUS nt_status_string_to_code(const char *nt_status_str);
-/** Used by ntstatus_dos_equal: */
-extern bool ntstatus_check_dos_mapping;
 /* we need these here for openchange */
 …
 #define NT_STATUS_IS_OK(x) (likely(NT_STATUS_V(x) == 0))
 #define NT_STATUS_IS_ERR(x) (unlikely((NT_STATUS_V(x) & 0xc0000000) == 0xc0000000))
-/* checking for DOS error mapping here is ugly, but unfortunately the
-   alternative is a very intrusive rewrite of the torture code */
-#if _SAMBA_BUILD_ == 4
-#define NT_STATUS_EQUAL(x,y) (NT_STATUS_IS_DOS(x)||NT_STATUS_IS_DOS(y)?ntstatus_dos_equal(x,y):NT_STATUS_V(x) == NT_STATUS_V(y))
-#else
 #define NT_STATUS_EQUAL(x,y) (NT_STATUS_V(x) == NT_STATUS_V(y))
+#endif
+/*
+ * These macros (with the embedded return) are considered poor coding
+ * style per README.Coding
+ *
+ * Please do not use them in new code, and do not rely on them in
+ * projects external to Samba as they will go away at some point.
+ */
 #define NT_STATUS_HAVE_NO_MEMORY(x) do { \

vendor/current/libcli/util/tstream.c

r860	r988
107	107	TALLOC_FREE(subreq);
108	108	if (ret == -1) {
109		status = map_nt_error_from_unix(sys_errno);
	109	status = map_nt_error_from_unix_common(sys_errno);
110	110	tevent_req_nterror(req, status);
111	111	return;

vendor/current/libcli/util/werror.h

-              r740
+              r988
 #if defined(HAVE_IMMEDIATE_STRUCTURES)
 typedef struct {uint32_t v;} WERROR;
+typedef struct {uint32_t w;} WERROR;
 #define W_ERROR(x) ((WERROR) { x })
 #define W_ERROR_V(x) ((x).v)
+#define W_ERROR_V(x) ((x).w)
 #else
 typedef uint32_t WERROR;
 …
 #define WERR_NO_SUCH_SHARE W_ERROR(0x00000043)
 #define WERR_FILE_EXISTS W_ERROR(0x00000050)
-#define WERR_BAD_PASSWORD W_ERROR(0x00000056)
 #define WERR_INVALID_PARAM W_ERROR(0x00000057)
 #define WERR_CALL_NOT_IMPLEMENTED W_ERROR(0x00000078)
 …
 #define WERR_INSUFFICIENT_BUFFER W_ERROR(0x0000007A)
 #define WERR_INVALID_NAME W_ERROR(0x0000007B)
-#define WERR_UNKNOWN_LEVEL W_ERROR(0x0000007C)
 #define WERR_OBJECT_PATH_INVALID W_ERROR(0x000000A1)
 #define WERR_ALREADY_EXISTS W_ERROR(0x000000B7)
 …
 #define WERR_MACHINE_LOCKED W_ERROR(0x000004F7)
 #define WERR_UNKNOWN_REVISION W_ERROR(0x00000519)
-#define WERR_INVALID_OWNER W_ERROR(0x0000051B)
 #define WERR_REVISION_MISMATCH W_ERROR(0x0000051A)
 #define WERR_INVALID_OWNER W_ERROR(0x0000051B)
 …
 /* Generic error code aliases */
 #define WERR_FOOBAR WERR_GENERAL_FAILURE
+/* TODO: remove WERR_UNKNOWN_LEVEL in all callers */
+#define WERR_UNKNOWN_LEVEL WERR_INVALID_LEVEL
 /*****************************************************************************
 …
 #define WERR_DNS_ERROR_RCODE_BADKEY     W_ERROR(0x00002339)
 #define WERR_DNS_ERROR_RCODE_BADTIME    W_ERROR(0x0000233A)
+#define WERR_DNS_ERROR_KEYMASTER_REQUIRED               W_ERROR(0x0000238D)
+#define WERR_DNS_ERROR_NOT_ALLOWED_ON_SIGNED_ZONE       W_ERROR(0x0000238E)
+#define WERR_DNS_ERROR_INVALID_NSEC3_PARAMETERS         W_ERROR(0x0000238F)
+#define WERR_DNS_ERROR_NOT_ENOUGH_SIGNING_KEY_DESCRIPTORS       W_ERROR(0x00002390)
+#define WERR_DNS_ERROR_UNSUPPORTED_ALGORITHM            W_ERROR(0x00002391)
+#define WERR_DNS_ERROR_INVALID_KEY_SIZE                 W_ERROR(0x00002392)
+#define WERR_DNS_ERROR_SIGNING_KEY_NOT_ACCESSIBLE       W_ERROR(0x00002393)
+#define WERR_DNS_ERROR_KSP_DOES_NOT_SUPPORT_PROTECTION  W_ERROR(0x00002394)
+#define WERR_DNS_ERROR_UNEXPECTED_DATA_PROTECTION_ERROR W_ERROR(0x00002395)
+#define WERR_DNS_ERROR_UNEXPECTED_CNG_ERROR             W_ERROR(0x00002396)
+#define WERR_DNS_ERROR_UNKNOWN_SIGNING_PARAMETER_VERSION        W_ERROR(0x00002397)
+#define WERR_DNS_ERROR_KSP_NOT_ACCESSIBLE               W_ERROR(0x00002398)
+#define WERR_DNS_ERROR_TOO_MANY_SKDS                    W_ERROR(0x00002399)
+#define WERR_DNS_ERROR_INVALID_ROLLOVER_PERIOD          W_ERROR(0x0000239A)
+#define WERR_DNS_ERROR_INVALID_INITIAL_ROLLOVER_OFFSET  W_ERROR(0x0000239B)
+#define WERR_DNS_ERROR_ROLLOVER_IN_PROGRESS             W_ERROR(0x0000239C)
+#define WERR_DNS_ERROR_STANDBY_KEY_NOT_PRESENT          W_ERROR(0x0000239D)
+#define WERR_DNS_ERROR_NOT_ALLOWED_ON_ZSK               W_ERROR(0x0000239E)
+#define WERR_DNS_ERROR_NOT_ALLOWED_ON_ACTIVE_SKD        W_ERROR(0x0000239F)
+#define WERR_DNS_ERROR_ROLLOVER_ALREADY_QUEUED          W_ERROR(0x000023A0)
+#define WERR_DNS_ERROR_NOT_ALLOWED_ON_UNSIGNED_ZONE     W_ERROR(0x000023A1)
+#define WERR_DNS_ERROR_BAD_KEYMASTER                    W_ERROR(0x000023A2)
+#define WERR_DNS_ERROR_INVALID_SIGNATURE_VALIDITY_PERIOD        W_ERROR(0x000023A3)
+#define WERR_DNS_ERROR_INVALID_NSEC3_ITERATION_COUNT    W_ERROR(0x000023A4)
+#define WERR_DNS_ERROR_DNSSEC_IS_DISABLED               W_ERROR(0x000023A5)
+#define WERR_DNS_ERROR_INVALID_XML                      W_ERROR(0x000023A6)
+#define WERR_DNS_ERROR_NO_VALID_TRUST_ANCHORS           W_ERROR(0x000023A7)
+#define WERR_DNS_ERROR_ROLLOVER_NOT_POKEABLE            W_ERROR(0x000023A8)
+#define WERR_DNS_ERROR_NSEC3_NAME_COLLISION             W_ERROR(0x000023A9)
 #define WERR_DNS_INFO_NO_RECORDS        W_ERROR(0x0000251D)
 #define WERR_DNS_ERROR_BAD_PACKET       W_ERROR(0x0000251E)
 …
 #define WERR_DNS_ERROR_RCODE    W_ERROR(0x00002520)
 #define WERR_DNS_ERROR_UNSECURE_PACKET  W_ERROR(0x00002521)
+#define WERR_DNS_REQUEST_PENDING        W_ERROR(0x00002522)
 #define WERR_DNS_ERROR_INVALID_TYPE     W_ERROR(0x0000254F)
 #define WERR_DNS_ERROR_INVALID_IP_ADDRESS       W_ERROR(0x00002550)
 …
 #define WERR_DNS_ERROR_BACKGROUND_LOADING       W_ERROR(0x00002560)
 #define WERR_DNS_ERROR_NOT_ALLOWED_ON_RODC      W_ERROR(0x00002561)
+#define WERR_DNS_ERROR_NOT_ALLOWED_UNDER_DNAME  W_ERROR(0x00002562)
+#define WERR_DNS_ERROR_DELEGATION_REQUIRED      W_ERROR(0x00002563)
+#define WERR_DNS_ERROR_INVALID_POLICY_TABLE     W_ERROR(0x00002564)
 #define WERR_DNS_ERROR_ZONE_DOES_NOT_EXIST      W_ERROR(0x00002581)
 #define WERR_DNS_ERROR_NO_ZONE_INFO     W_ERROR(0x00002582)
 …
 #define WERR_DNS_ERROR_DS_ZONE_ALREADY_EXISTS   W_ERROR(0x000025F6)
 #define WERR_DNS_ERROR_NO_BOOTFILE_IF_DS_ZONE   W_ERROR(0x000025F7)
+#define WERR_DNS_ERROR_NODE_IS_DNMAE    W_ERROR(0x000025F8)
+#define WERR_DNS_ERROR_DNAME_COLLISION  W_ERROR(0x000025F9)
+#define WERR_DNS_ERROR_ALIAS_LOOP       W_ERROR(0x000025FA)
 #define WERR_DNS_INFO_AXFR_COMPLETE     W_ERROR(0x00002617)
 #define WERR_DNS_ERROR_AXFR     W_ERROR(0x00002618)

Context Navigation

Legend:

Download in other formats: